WIP

Author: ErichDonGubler

naga/src/proc/overloads/select.rs

@@ -38,6 +38,6 @@ impl TryToWgsl for WgslSymbol {
 
 impl core::fmt::Debug for WgslSymbol {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_str(Self::DESCRIPTION)
+        f.write_str("Select")
     }
 }

naga/src/valid/expression.rs

@@ -1,9 +1,14 @@
-use alloc::{format, string::String};
+use alloc::{
+    format,
+    string::{String, ToString},
+};
+use core::format_args;
 
 use super::{compose::validate_compose, FunctionInfo, ModuleInfo, ShaderStages, TypeFlags};
 use crate::arena::UniqueArena;
 use crate::{
     arena::Handle,
+    common::wgsl::ToWgsl as _,
     proc,
     proc::OverloadSet,
     proc::{IndexableLengthError, ResolveError},
@@ -130,7 +135,7 @@ pub enum ExpressionError {
     InvalidCastArgument,
     #[error("Invalid argument count for {0}")]
     WrongArgumentCount(String),
-    #[error("Argument [{1}] to {0:?} as expression {2:?} has an invalid type.")]
+    #[error("Argument [{1}] to `{0}` as expression {2:?} has an invalid type.")]
     InvalidArgumentType(String, u32, Handle<crate::Expression>),
     #[error(
         "workgroupUniformLoad result type can't be {0:?}. It can only be a constructible type."
@@ -245,14 +250,14 @@ impl super::Validator {
         actuals: A,
     ) -> Result<(), ExpressionError>
     where
-        F: core::fmt::Debug + Copy,
+        F: core::fmt::Display + Copy,
         O: OverloadSet,
         A: Iterator<Item = (Handle<crate::Expression>, &'a crate::TypeInner)> + ExactSizeIterator,
     {
         // Start with the set of all overloads available for `fun`.
         let mut overloads = overloads;
         log::debug!(
-            "initial overloads for {:?}: {:#?}",
+            "initial overloads for {}: {:#?}",
             fun,
             overloads.for_debug(&module.types)
         );
@@ -278,15 +283,15 @@ impl super::Validator {
             if overloads.is_empty() {
                 log::debug!("all overloads eliminated");
                 return Err(ExpressionError::InvalidArgumentType(
-                    format!("{fun:?}"),
+                    fun.to_string(),
                     i as u32,
                     expr,
                 ));
             }
         }
 
         if actuals_len < overloads.min_arguments() {
-            return Err(ExpressionError::WrongArgumentCount(format!("{fun:?}")));
+            return Err(ExpressionError::WrongArgumentCount(fun.to_string()));
         }
 
         Ok(())
@@ -974,7 +979,7 @@ impl super::Validator {
             } => {
                 self.validate_func_call_with_overloads(
                     module,
-                    proc::select::WgslSymbol,
+                    format_args!("`{}`", proc::select::WgslSymbol.to_wgsl()),
                     proc::select::overloads(),
                     [reject, accept, condition]
                         .iter()
@@ -1053,7 +1058,7 @@ impl super::Validator {
 
                 self.validate_func_call_with_overloads(
                     module,
-                    fun,
+                    format_args!("{fun:?}"),
                     fun.overloads(),
                     actuals
                         .iter()