[naga wgsl-in] Use common type-formatting code.

Remove the `naga::front::wgsl::to_wgsl` module. Instead, use the
implementations of `naga::common::wgsl`'s `TryToWgsl` and
`TypeContext` traits.

Author: jimblandy

naga/src/front/wgsl/error.rs

@@ -1,5 +1,6 @@
 //! Formatting WGSL front end error messages.
 
+use crate::common::wgsl::TryToWgsl;
 use crate::diagnostic_filter::ConflictingDiagnosticRuleError;
 use crate::proc::{Alignment, ConstantEvaluatorError, ResolveError};
 use crate::{Scalar, SourceLocation, Span};
@@ -446,7 +447,7 @@ impl<'a> Error<'a> {
             Error::BadMatrixScalarKind(span, scalar) => ParseError {
                 message: format!(
                     "matrix scalar type must be floating-point, but found `{}`",
-                    scalar.to_wgsl()
+                    scalar.to_wgsl_for_diagnostics()
                 ),
                 labels: vec![(span, "must be floating-point (e.g. `f32`)".into())],
                 notes: vec![],
@@ -469,7 +470,7 @@ impl<'a> Error<'a> {
             Error::BadTextureSampleType { span, scalar } => ParseError {
                 message: format!(
                     "texture sample type must be one of f32, i32 or u32, but found {}",
-                    scalar.to_wgsl()
+                    scalar.to_wgsl_for_diagnostics()
                 ),
                 labels: vec![(span, "must be one of f32, i32 or u32".into())],
                 notes: vec![],

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

@@ -7,6 +7,7 @@ use alloc::{
 };
 use core::num::NonZeroU32;
 
+use crate::common::wgsl::TypeContext;
 use crate::front::wgsl::lower::{ExpressionContext, Lowerer};
 use crate::front::wgsl::parse::ast;
 use crate::front::wgsl::{Error, Result};
@@ -71,7 +72,7 @@ impl Constructor<(Handle<crate::Type>, &crate::TypeInner)> {
                 format!("mat{}x{}<?>", columns as u32, rows as u32,)
             }
             Self::PartialArray => "array<?, ?>".to_string(),
-            Self::Type((handle, _inner)) => handle.to_wgsl(&ctx.module.to_ctx()),
+            Self::Type((handle, _inner)) => ctx.type_to_string(handle),
         }
     }
 }
@@ -536,7 +537,7 @@ impl<'source> Lowerer<'source, '_> {
 
             // Bad conversion (type cast)
             (Components::One { span, ty_inner, .. }, constructor) => {
-                let from_type = ty_inner.to_wgsl(&ctx.module.to_ctx());
+                let from_type = ctx.type_inner_to_string(ty_inner);
                 return Err(Box::new(Error::BadTypeCast {
                     span,
                     from_type,

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

@@ -2,6 +2,7 @@
 
 use alloc::{boxed::Box, string::String, vec::Vec};
 
+use crate::common::wgsl::{TryToWgsl, TypeContext};
 use crate::front::wgsl::error::{
     AutoConversionError, AutoConversionLeafScalarError, ConcretizationFailedError,
 };
@@ -53,9 +54,8 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
             match expr_inner.automatically_converts_to(goal_inner, types) {
                 Some(scalars) => scalars,
                 None => {
-                    let gctx = &self.module.to_ctx();
-                    let source_type = expr_resolution.to_wgsl(gctx);
-                    let dest_type = goal_ty.to_wgsl(gctx);
+                    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::AutoConversion(Box::new(
                         AutoConversionError {
@@ -95,11 +95,10 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
         let expr_inner = expr_resolution.inner_with(types);
 
         let make_error = || {
-            let gctx = &self.module.to_ctx();
-            let source_type = expr_resolution.to_wgsl(gctx);
+            let source_type = self.type_resolution_to_string(expr_resolution);
             super::Error::AutoConversionLeafScalar(Box::new(AutoConversionLeafScalarError {
                 dest_span: goal_span,
-                dest_scalar: goal_scalar.to_wgsl(),
+                dest_scalar: goal_scalar.to_wgsl_for_diagnostics(),
                 source_span: expr_span,
                 source_type,
             }))
@@ -275,8 +274,8 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
                         let expr_type = &self.typifier()[expr];
                         super::Error::ConcretizationFailed(Box::new(ConcretizationFailedError {
                             expr_span,
-                            expr_type: expr_type.to_wgsl(&self.module.to_ctx()),
-                            scalar: concretized.to_wgsl(),
+                            expr_type: self.type_resolution_to_string(expr_type),
+                            scalar: concretized.to_wgsl_for_diagnostics(),
                             inner: err,
                         }))
                     })?;
@@ -319,7 +318,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
             "wgsl automatic_conversion_consensus: {:?}",
             inners
                 .clone()
-                .map(|inner| inner.to_wgsl(&self.module.to_ctx()))
+                .map(|inner| self.type_inner_to_string(inner))
                 .collect::<Vec<String>>()
         );
         let mut best = inners.next().unwrap().scalar().ok_or(0_usize)?;
@@ -333,7 +332,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
             }
         }
 
-        log::debug!("    consensus: {:?}", best.to_wgsl());
+        log::debug!("    consensus: {:?}", best.to_wgsl_for_diagnostics());
         Ok(best)
     }
 }

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

@@ -6,6 +6,7 @@ use alloc::{
 };
 use core::num::NonZeroU32;
 
+use crate::common::wgsl::TypeContext;
 use crate::front::wgsl::error::{Error, ExpectedToken, InvalidAssignmentType};
 use crate::front::wgsl::index::Index;
 use crate::front::wgsl::parse::number::Number;
@@ -388,6 +389,30 @@ pub struct ExpressionContext<'source, 'temp, 'out> {
     expr_type: ExpressionContextType<'temp, 'out>,
 }
 
+impl TypeContext for ExpressionContext<'_, '_, '_> {
+    fn lookup_type(&self, handle: Handle<crate::Type>) -> &crate::Type {
+        &self.module.types[handle]
+    }
+
+    fn type_name(&self, handle: Handle<crate::Type>) -> &str {
+        self.module.types[handle]
+            .name
+            .as_deref()
+            .unwrap_or("{anonymous type}")
+    }
+
+    fn write_override<W: core::fmt::Write>(
+        &self,
+        handle: Handle<crate::Override>,
+        out: &mut W,
+    ) -> core::fmt::Result {
+        match self.module.overrides[handle].name {
+            Some(ref name) => out.write_str(name),
+            None => write!(out, "{{anonymous override {handle:?}}}"),
+        }
+    }
+}
+
 impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
     #[allow(dead_code)]
     fn as_const(&mut self) -> ExpressionContext<'source, '_, '_> {
@@ -1256,8 +1281,8 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                 if !explicit_inner.equivalent(init_inner, &ectx.module.types) {
                     return Err(Box::new(Error::InitializationTypeMismatch {
                         name: name.span,
-                        expected: explicit_inner.to_wgsl(&ectx.module.to_ctx()),
-                        got: init_inner.to_wgsl(&ectx.module.to_ctx()),
+                        expected: ectx.type_inner_to_string(explicit_inner),
+                        got: ectx.type_inner_to_string(init_inner),
                     }));
                 }
                 ty = explicit_ty;
@@ -1487,11 +1512,10 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                             .inner
                             .equivalent(&ctx.module.types[init_ty].inner, &ctx.module.types)
                         {
-                            let gctx = &ctx.module.to_ctx();
                             return Err(Box::new(Error::InitializationTypeMismatch {
                                 name: l.name.span,
-                                expected: ty.to_wgsl(gctx),
-                                got: init_ty.to_wgsl(gctx),
+                                expected: ctx.type_to_string(ty),
+                                got: ctx.type_to_string(init_ty),
                             }));
                         }
                     }
@@ -2192,11 +2216,10 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                     crate::TypeInner::Vector { scalar, .. } => scalar,
                     _ => {
                         let ty = resolve!(ctx, expr);
-                        let gctx = &ctx.module.to_ctx();
                         return Err(Box::new(Error::BadTypeCast {
-                            from_type: ty.to_wgsl(gctx),
+                            from_type: ctx.type_resolution_to_string(ty),
                             span: ty_span,
-                            to_type: to_resolved.to_wgsl(gctx),
+                            to_type: ctx.type_to_string(to_resolved),
                         }));
                     }
                 };

naga/src/front/wgsl/mod.rs

@@ -10,7 +10,6 @@ mod lower;
 mod parse;
 #[cfg(test)]
 mod tests;
-mod to_wgsl;
 
 pub use crate::front::wgsl::error::ParseError;
 pub use crate::front::wgsl::parse::directive::language_extension::{