[wgsl-in] Report remaining type mismatches in WGSL terms

Extend the previous commit to the rest of the places where the WGSL front
end deferred a type error to the IR validator, which can only refer to
the operands by handle index — and, worse, prints handles from different
arenas identically, so that e.g. a `return` mismatch read

    The `return` expression Some([1]) does not match the declared return type Some([1])

`try_automatic_conversions` used to pass concrete values straight
through, on the grounds that reporting them as failed conversions would
be misleading. Instead it now reports a plain type mismatch, so every
caller — `var`/`let` initializers, `return`, call arguments and composite
constructors — gets a diagnostic with spans and WGSL type names, and no
future caller can forget to check.

Binary operators are checked with `proc::binary_op_accepts_operands`,
extracted from the validator so both share one set of typing rules. This
also covers the short-circuiting `&&`/`||`, whose operands never appear
in a `Binary` expression for the validator to inspect, and compound
assignments like `m += v`.

Two consequences worth noting:

- `return` with no value in a function that declares a return type, and
  `return` with a value in one that doesn't, are now parse errors.
- `1.0 < some_vec` and `1.0 & some_vec` are now rejected at parse time.
  WGSL has no mixed scalar/vector overloads for the comparison and
  bitwise operators, and the validator already rejected them, so such
  shaders never compiled — only the error changed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: emilk

CHANGELOG.md

@@ -85,7 +85,7 @@ Bottom level categories:
 
 - Fix panics when shader `var<immediate>` size is larger than 256 bytes. By @beicause in [#9725](https://github.com/gfx-rs/wgpu/pull/9725).
 - Fix a panic in the SPIR-V frontend when a subgroup collective operation (e.g. `OpGroupNonUniformUMin`) or `OpGroupNonUniformBallot` used an argument whose value needed to be spilled to a temporary variable, such as when the argument was computed inside a loop. By @nazar-pc in [#9957](https://github.com/gfx-rs/wgpu/issues/9957).
-- Report WGSL assignments whose value type does not match the assigned-to memory location as a WGSL error naming both types, instead of an IR validation error like `The type of [13] doesn't match the type stored in [10]`. By @emilk in [#9970](https://github.com/gfx-rs/wgpu/pull/9970).
+- Report WGSL type mismatches in assignments, `return` statements, function call arguments, composite constructors and binary operators as WGSL errors naming both types, instead of IR validation errors like `The type of [13] doesn't match the type stored in [10]`. By @emilk in [#9970](https://github.com/gfx-rs/wgpu/pull/9970).
 
 #### Validation
 

naga/src/front/wgsl/error.rs

@@ -399,6 +399,52 @@ pub(crate) enum Error<'a> {
         /// first unacceptable argument.
         allowed: Vec<String>,
     },
+    /// A value passed to a user-declared function has a type that does not
+    /// match the corresponding parameter's type.
+    ParameterTypeMismatch {
+        /// The name of the function being called.
+        function: String,
+
+        /// The argument expression whose type is wrong.
+        arg_span: Span,
+
+        /// The index of that argument.
+        arg_index: u32,
+
+        /// The declared type of the corresponding parameter.
+        expected: String,
+
+        /// The argument's actual type.
+        got: String,
+    },
+    /// A `return` statement's value does not match the function's declared
+    /// return type.
+    ReturnTypeMismatch {
+        /// The returned expression.
+        span: Span,
+
+        /// The function's declared return type.
+        expected: String,
+
+        /// The returned expression's type.
+        got: String,
+    },
+    /// A `return` statement in a function with no declared return type has a
+    /// value.
+    UnexpectedReturnValue {
+        span: Span,
+    },
+    /// A `return` statement in a function with a declared return type has no
+    /// value.
+    MissingReturnValue {
+        span: Span,
+
+        /// The function's declared return type.
+        expected: String,
+    },
+    /// A binary operator was applied to operands whose types it does not
+    /// accept.
+    InvalidBinaryOperandTypes(Box<InvalidBinaryOperandTypesError>),
     FunctionReturnsVoid(Span),
     FunctionMustUseUnused(Span),
     FunctionMustUseReturnsVoid(Span, Span),
@@ -410,6 +456,7 @@ pub(crate) enum Error<'a> {
     ExpectedPositiveArrayLength(Span),
     MissingWorkgroupSize(Span),
     ConstantEvaluatorError(Box<ConstantEvaluatorError>, Span),
+    TypeMismatch(Box<TypeMismatchError>),
     AutoConversion(Box<AutoConversionError>),
     AutoConversionLeafScalar(Box<AutoConversionLeafScalarError>),
     ConcretizationFailed(Box<ConcretizationFailedError>),
@@ -505,6 +552,17 @@ impl From<&'static str> for DiagnosticAttributeNotSupportedPosition {
     }
 }
 
+/// A value's concrete type differs from the type required by its context.
+#[derive(Clone, Debug)]
+pub(crate) struct TypeMismatchError {
+    /// Where the required type comes from.
+    pub dest_span: Span,
+    pub dest_type: String,
+    /// The value whose type is wrong.
+    pub source_span: Span,
+    pub source_type: String,
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct AutoConversionError {
     pub dest_span: Span,
@@ -521,6 +579,16 @@ pub(crate) struct AutoConversionLeafScalarError {
     pub source_type: String,
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct InvalidBinaryOperandTypesError {
+    /// The operator, as it is spelled in WGSL.
+    pub op: &'static str,
+    pub left_span: Span,
+    pub left_type: String,
+    pub right_span: Span,
+    pub right_type: String,
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct ConcretizationFailedError {
     pub expr_span: Span,
@@ -1114,6 +1182,69 @@ impl<'a> Error<'a> {
 
                 ParseError { message, labels, notes }
             }
+            Error::ParameterTypeMismatch {
+                ref function,
+                arg_span,
+                arg_index,
+                ref expected,
+                ref got,
+            } => ParseError {
+                message: format!(
+                    "wrong type passed as argument #{} to `{function}`",
+                    arg_index + 1,
+                ),
+                labels: vec![(
+                    arg_span,
+                    format!("expected `{expected}`, found `{got}`").into(),
+                )],
+                notes: vec![],
+            },
+            Error::ReturnTypeMismatch {
+                span,
+                ref expected,
+                ref got,
+            } => ParseError {
+                message: format!(
+                    "the value returned here has type `{got}`, but the function's return type is `{expected}`"
+                ),
+                labels: vec![(span, format!("this expression has type `{got}`").into())],
+                notes: vec![],
+            },
+            Error::UnexpectedReturnValue { span } => ParseError {
+                message: "`return` with a value in a function with no return type".to_string(),
+                labels: vec![(span, "this function does not return a value".into())],
+                notes: vec![],
+            },
+            Error::MissingReturnValue { span, ref expected } => ParseError {
+                message: format!("`return` with no value in a function returning `{expected}`"),
+                labels: vec![(span, format!("expected a value of type `{expected}`").into())],
+                notes: vec![],
+            },
+            Error::InvalidBinaryOperandTypes(ref error) => {
+                let InvalidBinaryOperandTypesError {
+                    op,
+                    left_span,
+                    ref left_type,
+                    right_span,
+                    ref right_type,
+                } = **error;
+                ParseError {
+                    message: format!(
+                        "the `{op}` operator cannot be applied to `{left_type}` and `{right_type}`"
+                    ),
+                    labels: vec![
+                        (
+                            left_span,
+                            format!("this expression has type `{left_type}`").into(),
+                        ),
+                        (
+                            right_span,
+                            format!("this expression has type `{right_type}`").into(),
+                        ),
+                    ],
+                    notes: vec![],
+                }
+            }
             Error::FunctionReturnsVoid(span) => ParseError {
                 message: "function does not return any value".to_string(),
                 labels: vec![(span, "".into())],
@@ -1191,6 +1322,30 @@ impl<'a> Error<'a> {
                 )],
                 notes: vec![],
             },
+            Error::TypeMismatch(ref error) => {
+                // destructuring ensures all fields are handled
+                let TypeMismatchError {
+                    dest_span,
+                    ref dest_type,
+                    source_span,
+                    ref source_type,
+                } = **error;
+                let mut labels = vec![(
+                    source_span,
+                    format!("this expression has type `{source_type}`").into(),
+                )];
+                if dest_span != source_span {
+                    labels.push((
+                        dest_span,
+                        format!("a value of type `{dest_type}` is required here").into(),
+                    ));
+                }
+                ParseError {
+                    message: format!("expected `{dest_type}`, found `{source_type}`"),
+                    labels,
+                    notes: vec![],
+                }
+            }
             Error::AutoConversion(ref error) => {
                 // destructuring ensures all fields are handled
                 let AutoConversionError {

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

@@ -5,6 +5,7 @@ use alloc::{boxed::Box, string::String, vec::Vec};
 use crate::common::wgsl::{TryToWgsl, TypeContext};
 use crate::front::wgsl::error::{
     AutoConversionError, AutoConversionLeafScalarError, ConcretizationFailedError,
+    TypeMismatchError,
 };
 use crate::front::wgsl::Result;
 use crate::{Handle, Span};
@@ -14,13 +15,15 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
     ///
     /// If no conversions are necessary, return `expr` unchanged.
     ///
-    /// If automatic conversions cannot convert `expr` to `goal_ty`, return an
-    /// [`AutoConversion`] error.
+    /// If `expr`'s type is concrete and differs from `goal_ty`, return a
+    /// [`TypeMismatch`] error. If it is abstract but automatic conversions
+    /// cannot convert it to `goal_ty`, return an [`AutoConversion`] error.
     ///
     /// Although the Load Rule is one of the automatic conversions, this
     /// function assumes it has already been applied if appropriate, as
     /// indicated by the fact that the Rust type of `expr` is not `Typed<_>`.
     ///
+    /// [`TypeMismatch`]: super::Error::TypeMismatch
     /// [`AutoConversion`]: super::Error::AutoConversion
     pub fn try_automatic_conversions(
         &mut self,
@@ -36,20 +39,30 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
         let expr_inner = expr_resolution.inner_with(types);
         let goal_inner = goal_ty.inner_with(types);
 
-        // We can only convert abstract types, so if `expr` is not abstract do not even
-        // attempt conversion. This allows the validator to catch type errors correctly
-        // rather than them being misreported as type conversion errors.
-        // If the type is an array (of an array, etc) then we must check whether the
-        // type of the innermost array's base type is abstract.
-        if !expr_inner.is_abstract(types) {
-            return Ok(expr);
-        }
-
         // If `expr` already has the requested type, we're done.
         if self.module.compare_types(expr_resolution, goal_ty) {
             return Ok(expr);
         }
 
+        // We can only convert abstract types, so if `expr` is not abstract this is
+        // a plain type mismatch, not a failed conversion. Report it as such, rather
+        // than misreporting it as a conversion error.
+        // If the type is an array (of an array, etc) then we must check whether the
+        // type of the innermost array's base type is abstract.
+        if !expr_inner.is_abstract(types) {
+            let source_type = self.type_resolution_to_string(expr_resolution);
+            let dest_type = self.type_resolution_to_string(goal_ty);
+
+            return Err(Box::new(super::Error::TypeMismatch(Box::new(
+                TypeMismatchError {
+                    dest_span: goal_span,
+                    dest_type,
+                    source_span: expr_span,
+                    source_type,
+                },
+            ))));
+        }
+
         let (_expr_scalar, goal_scalar) =
             match expr_inner.automatically_converts_to(goal_inner, types) {
                 Some(scalars) => scalars,