wip

Author: jimblandy

naga/src/common/diagnostic_display.rs

@@ -0,0 +1,119 @@
+//! Wrappers for displaying Naga IR terms in diagnostic output.
+
+use crate::proc::GlobalCtx;
+use crate::{Handle, Scalar, Type, TypeInner};
+
+#[cfg(any(feature = "wgsl-in", feature = "wgsl-out"))]
+use crate::common::wgsl::{TryToWgsl, 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.
+///
+/// [`Display`]: core::fmt::Display
+/// [`Scalar`]: crate::Scalar
+/// [`GlobalCtx`]: crate::proc::GlobalCtx
+///
+/// ## 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, ctx) = self.0;
+
+        #[cfg(feature = "wgsl-in")]
+        ctx.write_type(handle, f)?;
+
+        #[cfg(not(feature = "wgsl-in"))]
+        {
+            let _ = ctx;
+            write!(f, "{handle:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<'m> fmt::Display for DiagnosticDisplay<(&'m TypeInner, &GlobalCtx<'m>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (inner, ctx) = self.0;
+
+        #[cfg(feature = "wgsl-in")]
+        ctx.write_type_inner(inner, f)?;
+
+        #[cfg(not(feature = "wgsl-in"))]
+        {
+            let _ = ctx;
+            write!(f, "{inner:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<'m> fmt::Display for DiagnosticDisplay<(&'m TypeInner, &crate::UniqueArena<Type>)> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (inner, ctx) = self.0;
+
+        #[cfg(feature = "wgsl-in")]
+        ctx.write_type_inner(inner, f)?;
+
+        #[cfg(not(feature = "wgsl-in"))]
+        {
+            let _ = ctx;
+            write!(f, "{inner:?}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for DiagnosticDisplay<Scalar> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let scalar = self.0;
+
+        #[cfg(feature = "wgsl-in")]
+        match scalar.try_to_wgsl() {
+            Some(string) => f.write_str(string)?,
+            None => crate::common::wgsl::write_scalar_for_diagnostics(scalar, f)?,
+        }
+
+        #[cfg(not(feature = "wgsl-in"))]
+        write!(f, "{scalar:?}")?;
+
+        Ok(())
+    }
+}
+
+/// A wrapper for displaying types with [`core::fmt::Debug`].
+///
+/// Since we expect this to be implemented in ad-hoc ways across Naga,
+/// we don't supply interesting implementations here.
+pub struct DiagnosticDebug<T>(pub T);

naga/src/common/mod.rs

@@ -1,7 +1,10 @@
 //! Code common to the front and backends for specific languages.
 
+pub mod diagnostic_display;
 pub mod wgsl;
 
+pub use diagnostic_display::{DiagnosticDebug, 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/front/wgsl/error.rs

@@ -272,6 +272,25 @@ pub(crate) enum Error<'a> {
         expected: Range<u32>,
         found: u32,
     },
+    WrongArgumentCountForOverloads {
+        function: String,
+        call_span: Span,
+        arg_span: Span,
+        max_arguments: u32,
+        overloads: Vec<String>,
+    },
+    WrongArgumentType {
+        function: String,
+        call_span: Span,
+        arg_span: Span,
+        arg_index: u32,
+        found: String,
+        allowed: Vec<String>,
+    },
+    AmbiguousCall {
+        call_span: Span,
+        alternatives: Vec<String>,
+    },
     FunctionReturnsVoid(Span),
     FunctionMustUseUnused(Span),
     FunctionMustUseReturnsVoid(Span, Span),
@@ -403,7 +422,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(),
@@ -827,6 +847,70 @@ impl<'a> Error<'a> {
                 labels: vec![(span, "wrong number of arguments".into())],
                 notes: vec![],
             },
+            Error::WrongArgumentCountForOverloads {
+                ref function,
+                call_span,
+                arg_span,
+                max_arguments,
+                ref overloads,
+            } => {
+                let message = format!(
+                    "Given the types of arguments passed, \
+                     `{function}` accepts only {max_arguments} arguments"
+                );
+                let labels = vec![
+                    (call_span, "This function call has too many arguments".into()),
+                    (arg_span, "This is the first excess argument".into())
+                ];
+                let mut notes = vec![
+                    format!("These are the only overloads of `{function}` \
+                             that accept the initial arguments:"),
+                ];
+                notes.extend(overloads.iter().map(|o| format!("overload: {o}")));
+
+                ParseError { message, labels, notes }
+            }
+            Error::WrongArgumentType {
+                ref function,
+                call_span,
+                arg_span,
+                arg_index,
+                ref found,
+                ref allowed,
+            } => {
+                let message = format!(
+                    "This call to `{function}` cannot accept a value of type `{found}` for argument #{}",
+                    arg_index + 1,
+                );
+                let labels = vec![
+                    (call_span, "the function being called".into()),
+                    (arg_span, format!(
+                        "This argument has type `{found}`",
+                    ).into())
+                ];
+
+                let mut notes = vec![];
+                if arg_index > 0 {
+                    notes.push("Given the types of the preceding arguments,".into());
+                    notes.push(format!("the following types are allowed for argument #{}:", arg_index + 1));
+                } else {
+                    notes.push("The following types are allowed for the first argument:".to_string());
+                };
+                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())],

naga/src/front/wgsl/lower/conversion.rs

@@ -71,7 +71,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
         self.convert_leaf_scalar(expr, expr_span, goal_scalar)
     }
 
-    /// Try to convert `expr`'s leaf scalar to `goal` using automatic conversions.
+    /// Try to convert `expr`'s leaf scalar to `goal_scalar` using automatic conversions.
     ///
     /// If no conversions are necessary, return `expr` unchanged.
     ///