[naga] Support builtin function overloads correctly.

Define a new trait, `proc::builtins::OverloadSet`, for types that
represent a Naga IR builtin function's set of overloads. The
`OverloadSet` trait includes operations needed to validate calls,
choose automatic type conversions, and generate diagnostics.

Add a new function, `ir::MathFunction::overloads`, which returns the
given `MathFunction`'s set of overloads as an `impl OverloadSet`
value. Use this in the WGSL front end, the validator, and the
typifier.

To support `MathFunction::overloads`, provide several implementations
of `OverloadSet`, some that are very flexible but verbose, and others
that are concise but more restrictive.

Author: jimblandy

naga/src/common/diagnostic_debug.rs

@@ -0,0 +1,86 @@
+//! Displaying Naga IR terms in debugging output.
+
+#[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+use crate::common::wgsl::TypeContext;
+
+use crate::proc::TypeResolution;
+use crate::{Handle, Scalar, Type, TypeInner, UniqueArena};
+
+use core::fmt;
+
+/// A wrapper for displaying Naga IR terms in debugging output.
+///
+/// This is like [`DiagnosticDisplay`], but requires weaker context
+/// and produces correspondingly lower-fidelity output. For example,
+/// this cannot show the override names for override-sized array
+/// lengths.
+///
+/// [`DiagnosticDisplay`]: super::DiagnosticDisplay
+pub struct DiagnosticDebug<T>(pub T);
+
+impl fmt::Debug for DiagnosticDebug<(Handle<Type>, &UniqueArena<Type>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (handle, ctx) = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        ctx.write_type(handle, f)?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        {
+            let _ = ctx;
+            write!(f, "{handle:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Debug for DiagnosticDebug<(&TypeInner, &UniqueArena<Type>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (inner, ctx) = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        ctx.write_type_inner(inner, f)?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        {
+            let _ = ctx;
+            write!(f, "{inner:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Debug for DiagnosticDebug<(&TypeResolution, &UniqueArena<Type>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (resolution, ctx) = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        ctx.write_type_resolution(resolution, f)?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        {
+            let _ = ctx;
+            write!(f, "{resolution:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Debug for DiagnosticDebug<Scalar> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let scalar = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        f.write_str(&crate::common::wgsl::TryToWgsl::to_wgsl_for_diagnostics(
+            scalar,
+        ))?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        write!(f, "{scalar:?}")?;
+
+        Ok(())
+    }
+}

naga/src/common/diagnostic_display.rs

@@ -0,0 +1,121 @@
+//! Displaying Naga IR terms in diagnostic output.
+
+use crate::proc::{GlobalCtx, Rule};
+use crate::{Handle, Scalar, Type, TypeInner};
+
+#[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+use crate::common::wgsl::TypeContext;
+
+use core::fmt;
+
+/// A wrapper for displaying Naga IR terms in diagnostic output.
+///
+/// For some Naga IR type `T`, `DiagnosticDisplay<T>` implements
+/// [`core::fmt::Display`] in a way that displays values of type `T`
+/// appropriately for diagnostic messages presented to human readers.
+///
+/// For example, the implementation of [`Display`] for
+/// `DiagnosticDisplay<Scalar>` formats the type represented by the
+/// given [`Scalar`] appropriately for users.
+///
+/// Some types like `Handle<Type>` require contextual information like
+/// a type arena to be displayed. In such cases, we implement [`Display`]
+/// for a type like `DiagnosticDisplay<(Handle<Type>, GlobalCtx)>`, where
+/// the [`GlobalCtx`] type provides the necessary context.
+///
+/// If you only need debugging output, [`DiagnosticDebug`] uses
+/// easier-to-obtain context types but still does a good enough job
+/// for logging or debugging.
+///
+/// [`Display`]: core::fmt::Display
+/// [`Scalar`]: crate::Scalar
+/// [`GlobalCtx`]: crate::proc::GlobalCtx
+/// [`DiagnosticDebug`]: super::DiagnosticDebug
+///
+/// ## Language-sensitive diagnostics
+///
+/// As discussed in #7268, diagnostic output ought to depend on the
+/// source language from which the IR was produced: diagnostics
+/// resulting from processing GLSL code should use GLSL type syntax,
+/// for example. That means that `DiagnosticDisplay` ought to include
+/// some indication of which notation to use.
+///
+/// For the moment, only WGSL output is implemented, so
+/// `DiagnosticDisplay` lacks any support for this. However, the plan
+/// is that all language-independent code in Naga should use
+/// `DiagnosticDisplay` wherever appropriate, such that when its
+/// definition is expanded to include some indication of the right
+/// source language to use, any use site that does not supply this
+/// indication will provoke a compile-time error.
+pub struct DiagnosticDisplay<T>(pub T);
+
+impl fmt::Display for DiagnosticDisplay<(Handle<Type>, GlobalCtx<'_>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (handle, ref ctx) = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        ctx.write_type(handle, f)?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        {
+            let _ = ctx;
+            write!(f, "{handle:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for DiagnosticDisplay<(&TypeInner, GlobalCtx<'_>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (inner, ref ctx) = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        ctx.write_type_inner(inner, f)?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        {
+            let _ = ctx;
+            write!(f, "{inner:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for DiagnosticDisplay<(&str, &Rule, GlobalCtx<'_>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (name, rule, ref ctx) = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        ctx.write_type_rule(name, rule, f)?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        {
+            let _ = ctx;
+            write!(
+                f,
+                "{name}({:?}) -> {:?}",
+                rule.subexpressions, rule.conclusion
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for DiagnosticDisplay<Scalar> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let scalar = self.0;
+
+        #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+        f.write_str(&crate::common::wgsl::TryToWgsl::to_wgsl_for_diagnostics(
+            scalar,
+        ))?;
+
+        #[cfg(not(any(feature = "wgsl-in", feature = "wgsl-out")))]
+        write!(f, "{scalar:?}")?;
+
+        Ok(())
+    }
+}

naga/src/common/mod.rs

@@ -1,8 +1,13 @@
 //! Code common to the front and backends for specific languages.
 
+pub mod diagnostic_debug;
+pub mod diagnostic_display;
 pub mod predeclared;
 pub mod wgsl;
 
+pub use diagnostic_debug::DiagnosticDebug;
+pub use diagnostic_display::DiagnosticDisplay;
+
 /// Helper function that returns the string corresponding to the [`VectorSize`](crate::VectorSize)
 pub const fn vector_size_str(size: crate::VectorSize) -> &'static str {
     match size {

naga/src/common/wgsl/types.rs

@@ -133,6 +133,37 @@ pub trait TypeContext {
         }
     }
 
+    fn write_type_conclusion<W: Write>(
+        &self,
+        conclusion: &crate::proc::Conclusion,
+        out: &mut W,
+    ) -> core::fmt::Result {
+        use crate::proc::Conclusion as Co;
+
+        match *conclusion {
+            Co::Value(ref inner) => self.write_type_inner(inner, out),
+            Co::Predeclared(ref predeclared) => out.write_str(&predeclared.struct_name()),
+        }
+    }
+
+    fn write_type_rule<W: Write>(
+        &self,
+        name: &str,
+        rule: &crate::proc::Rule,
+        out: &mut W,
+    ) -> core::fmt::Result {
+        write!(out, "fn {name}(")?;
+        for (i, arg) in rule.subexpressions.iter().enumerate() {
+            if i > 0 {
+                out.write_str(", ")?;
+            }
+            self.write_type_resolution(arg, out)?
+        }
+        out.write_str(") -> ")?;
+        self.write_type_conclusion(&rule.conclusion, out)?;
+        Ok(())
+    }
+
     fn type_to_string(&self, handle: Handle<crate::Type>) -> String {
         let mut buf = String::new();
         self.write_type(handle, &mut buf).unwrap();
@@ -150,6 +181,12 @@ pub trait TypeContext {
         self.write_type_resolution(resolution, &mut buf).unwrap();
         buf
     }
+
+    fn type_rule_to_string(&self, name: &str, rule: &crate::proc::Rule) -> String {
+        let mut buf = String::new();
+        self.write_type_rule(name, rule, &mut buf).unwrap();
+        buf
+    }
 }
 
 fn try_write_type_inner<C, W>(ctx: &C, inner: &TypeInner, out: &mut W) -> Result<(), WriteTypeError>
@@ -356,3 +393,70 @@ impl From<core::fmt::Error> for WriteTypeError {
         Self::Format(err)
     }
 }
+
+/// Format types as WGSL based on a [`GlobalCtx`].
+///
+/// This is probably good enough for diagnostic output, but it has some
+/// limitations:
+///
+/// - It does not apply [`Namer`] renamings, to avoid collisions.
+///
+/// - It generates invalid WGSL for anonymous struct types.
+///
+/// - It doesn't write the lengths of override-expression-sized arrays
+///   correctly, unless the expression is just the override identifier.
+///
+/// [`GlobalCtx`]: crate::proc::GlobalCtx
+/// [`Namer`]: crate::proc::Namer
+impl TypeContext for crate::proc::GlobalCtx<'_> {
+    fn lookup_type(&self, handle: Handle<crate::Type>) -> &crate::Type {
+        &self.types[handle]
+    }
+
+    fn type_name(&self, handle: Handle<crate::Type>) -> &str {
+        self.types[handle]
+            .name
+            .as_deref()
+            .unwrap_or("{anonymous type}")
+    }
+
+    fn write_override<W: Write>(
+        &self,
+        handle: Handle<crate::Override>,
+        out: &mut W,
+    ) -> core::fmt::Result {
+        match self.overrides[handle].name {
+            Some(ref name) => out.write_str(name),
+            None => write!(out, "{{anonymous override {handle:?}}}"),
+        }
+    }
+}
+
+/// Format types as WGSL based on a `UniqueArena<Type>`.
+///
+/// This is probably only good enough for logging:
+///
+/// - It does not apply any kind of [`Namer`] renamings.
+///
+/// - It generates invalid WGSL for anonymous struct types.
+///
+/// - It doesn't write override-sized arrays properly.
+///
+/// [`Namer`]: crate::proc::Namer
+impl TypeContext for crate::UniqueArena<crate::Type> {
+    fn lookup_type(&self, handle: Handle<crate::Type>) -> &crate::Type {
+        &self[handle]
+    }
+
+    fn type_name(&self, handle: Handle<crate::Type>) -> &str {
+        self[handle].name.as_deref().unwrap_or("{anonymous type}")
+    }
+
+    fn write_override<W: Write>(
+        &self,
+        handle: Handle<crate::Override>,
+        out: &mut W,
+    ) -> core::fmt::Result {
+        write!(out, "{{override {handle:?}}}")
+    }
+}