[naga] Support MathFunction 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 two implementations
of `OverloadSet`:

- `List` is flexible but verbose.

- `Regular` is concise but more restrictive.

Some snapshot output is affected because `TypeResolution::Handle`
values turn into `TypeResolution::Value`, since the function database
constructs the return type directly.

To work around #7405, avoid offering abstract-typed overloads of some
functions.

This addresses #6443 for `MathFunction`, although that issue covers
other categories of operations as well.

Author: jimblandy

naga/src/common/diagnostic_display.rs

@@ -1,6 +1,6 @@
 //! Displaying Naga IR terms in diagnostic output.
 
-use crate::proc::GlobalCtx;
+use crate::proc::{GlobalCtx, Rule};
 use crate::{Handle, Scalar, Type, TypeInner};
 
 #[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
@@ -83,6 +83,23 @@ impl fmt::Display for DiagnosticDisplay<(&TypeInner, GlobalCtx<'_>)> {
     }
 }
 
+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.arguments, rule.conclusion)?;
+        }
+
+        Ok(())
+    }
+}
+
 impl fmt::Display for DiagnosticDisplay<Scalar> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let scalar = self.0;

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.arguments.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>

naga/src/front/wgsl/error.rs

@@ -271,6 +271,79 @@ pub(crate) enum Error<'a> {
         expected: Range<u32>,
         found: u32,
     },
+    /// No overload of this function accepts this many arguments.
+    TooManyArguments {
+        /// The name of the function being called.
+        function: String,
+
+        /// The function name in the call expression.
+        call_span: Span,
+
+        /// The first argument that is unacceptable.
+        arg_span: Span,
+
+        /// Maximum number of arguments accepted by any overload of
+        /// this function.
+        max_arguments: u32,
+    },
+    /// A value passed to a builtin function has a type that is not
+    /// accepted by any overload of the function.
+    WrongArgumentType {
+        /// The name of the function being called.
+        function: String,
+
+        /// The function name in the call expression.
+        call_span: Span,
+
+        /// The first argument whose type is unacceptable.
+        arg_span: Span,
+
+        /// The index of the first argument whose type is unacceptable.
+        arg_index: u32,
+
+        /// That argument's actual type.
+        arg_ty: String,
+
+        /// The set of argument types that would have been accepted for
+        /// this argument, given the prior arguments.
+        allowed: Vec<String>,
+    },
+    /// A value passed to a builtin function has a type that is not
+    /// accepted, given the earlier arguments' types.
+    InconsistentArgumentType {
+        /// The name of the function being called.
+        function: String,
+
+        /// The function name in the call expression.
+        call_span: Span,
+
+        /// The first unacceptable argument.
+        arg_span: Span,
+
+        /// The index of the first unacceptable argument.
+        arg_index: u32,
+
+        /// The actual type of the first unacceptable argument.
+        arg_ty: String,
+
+        /// The prior argument whose type made the `arg_span` argument
+        /// unacceptable.
+        prior_span: Span,
+
+        /// The index of the `prior_arg_span` argument.
+        prior_index: u32,
+
+        /// The type of the `prior_arg_span` argument.
+        prior_ty: String,
+
+        /// The types that would have been accepted instead of the
+        /// first unacceptable argument.
+        allowed: Vec<String>,
+    },
+    AmbiguousCall {
+        call_span: Span,
+        alternatives: Vec<String>,
+    },
     FunctionReturnsVoid(Span),
     FunctionMustUseUnused(Span),
     FunctionMustUseReturnsVoid(Span, Span),
@@ -402,7 +475,8 @@ impl<'a> Error<'a> {
                         "workgroup size separator (`,`) or a closing parenthesis".to_string()
                     }
                     ExpectedToken::GlobalItem => concat!(
-                        "global item (`struct`, `const`, `var`, `alias`, `fn`, `diagnostic`, `enable`, `requires`, `;`) ",
+                        "global item (`struct`, `const`, `var`, `alias`, ",
+                        "`fn`, `diagnostic`, `enable`, `requires`, `;`) ",
                         "or the end of the file"
                     )
                     .to_string(),
@@ -831,6 +905,85 @@ impl<'a> Error<'a> {
                 labels: vec![(span, "wrong number of arguments".into())],
                 notes: vec![],
             },
+            Error::TooManyArguments {
+                ref function,
+                call_span,
+                arg_span,
+                max_arguments,
+            } => ParseError {
+                message: format!("too many arguments passed to `{function}`"),
+                labels: vec![
+                    (call_span, "".into()),
+                    (arg_span, format!("unexpected argument #{}", max_arguments + 1).into())
+                ],
+                notes: vec![
+                    format!("The `{function}` function accepts at most {max_arguments} argument(s)")
+                ],
+            },
+            Error::WrongArgumentType {
+                ref function,
+                call_span,
+                arg_span,
+                arg_index,
+                ref arg_ty,
+                ref allowed,
+            } => {
+                let message = format!(
+                    "wrong type passed as argument #{} to `{function}`",
+                    arg_index + 1,
+                );
+                let labels = vec![
+                    (call_span, "".into()),
+                    (arg_span, format!("argument #{} has type `{arg_ty}`", arg_index + 1).into())
+                ];
+
+                let mut notes = vec![];
+                notes.push(format!("`{function}` accepts the following types for argument #{}:", arg_index + 1));
+                notes.extend(allowed.iter().map(|ty| format!("allowed type: {ty}")));
+
+                ParseError { message, labels, notes }
+            },
+            Error::InconsistentArgumentType {
+                ref function,
+                call_span,
+                arg_span,
+                arg_index,
+                ref arg_ty,
+                prior_span,
+                prior_index,
+                ref prior_ty,
+                ref allowed
+            } => {
+                let message = format!(
+                    "inconsistent type passed as argument #{} to `{function}`",
+                    arg_index + 1,
+                );
+                let labels = vec![
+                    (call_span, "".into()),
+                    (arg_span, format!("argument #{} has type {arg_ty}", arg_index + 1).into()),
+                    (prior_span, format!(
+                        "this argument has type {prior_ty}, which constrains subsequent arguments"
+                    ).into()),
+                ];
+                let mut notes = vec![
+                    format!("Because argument #{} has type {prior_ty}, only the following types", prior_index + 1),
+                    format!("(or types that automatically convert to them) are accepted for argument #{}:", arg_index + 1),
+                ];
+                notes.extend(allowed.iter().map(|ty| format!("allowed type: {ty}")));
+
+                ParseError { message, labels, notes }
+            }
+            Error::AmbiguousCall { call_span, ref alternatives } => {
+                let message = "function call is ambiguous: more than one overload could apply".into();
+                let labels = vec![
+                    (call_span, "more than one overload of this function could apply to these arguments".into()),
+                ];
+                let mut notes = vec![
+                    "All of the following overloads could apply, but no one overload is clearly preferable:".into()
+                ];
+                notes.extend(alternatives.iter().map(|alt| format!("possible overload: {alt}")));
+                ParseError { message, labels, notes }
+            },
             Error::FunctionReturnsVoid(span) => ParseError {
                 message: "function does not return any value".to_string(),
                 labels: vec![(span, "".into())],