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

Replace the type printing code in `front::wgsl::to_wgsl` with
calls to the shared type printing code in `common::wgsl`. Use this new
API throughout the front end.

Author: jimblandy

naga/src/front/wgsl/error.rs

@@ -9,6 +9,7 @@ use super::parse::directive::language_extension::{
     LanguageExtension, UnimplementedLanguageExtension,
 };
 use super::parse::lexer::Token;
+use super::to_wgsl::ToWgslForError;
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use codespan_reporting::files::SimpleFile;

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

@@ -9,6 +9,7 @@ use core::num::NonZeroU32;
 use crate::front::wgsl::error::Error;
 use crate::front::wgsl::lower::{ExpressionContext, Lowerer};
 use crate::front::wgsl::parse::ast;
+use crate::front::wgsl::to_wgsl::ToWgslForErrorWithContext;
 use crate::{Handle, Span};
 
 /// A cooked form of `ast::ConstructorType` that uses Naga types whenever

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

@@ -5,6 +5,7 @@ use alloc::{boxed::Box, string::String, vec::Vec};
 use crate::front::wgsl::error::{
     AutoConversionError, AutoConversionLeafScalarError, ConcretizationFailedError,
 };
+use crate::front::wgsl::to_wgsl::{ToWgslForError, ToWgslForErrorWithContext};
 use crate::{Handle, Span};
 
 impl<'source> super::ExpressionContext<'source, '_, '_> {

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

@@ -9,6 +9,7 @@ use crate::front::wgsl::error::{Error, ExpectedToken, InvalidAssignmentType};
 use crate::front::wgsl::index::Index;
 use crate::front::wgsl::parse::number::Number;
 use crate::front::wgsl::parse::{ast, conv};
+use crate::front::wgsl::to_wgsl::ToWgslForErrorWithContext;
 use crate::front::Typifier;
 use crate::proc::{
     ensure_block_returns, Alignment, ConstantEvaluator, Emitter, Layouter, ResolveContext,

naga/src/front/wgsl/mod.rs

@@ -23,6 +23,7 @@ use crate::front::wgsl::error::Error;
 use crate::front::wgsl::lower::Lowerer;
 use crate::front::wgsl::parse::Parser;
 use crate::Scalar;
+pub use to_wgsl::ToWgslForError;
 
 #[cfg(test)]
 use std::println;

naga/src/front/wgsl/to_wgsl.rs

@@ -1,169 +1,112 @@
 //! Producing the WGSL forms of types, for use in error messages.
 
-use crate::common::wgsl::ToWgsl;
-
-use alloc::{
-    format,
-    string::{String, ToString},
-};
+use crate::common::wgsl::{TryToWgsl, TypeContext};
+use crate::proc::{GlobalCtx, TypeResolution};
+use crate::{Handle, Scalar, Type, TypeInner};
+use alloc::format;
+use alloc::string::{String, ToString};
+use core::fmt;
+
+/// A trait for rendering simple Naga IR types into strings for error messages.
+///
+/// Some Naga IR types also require a [`GlobalCtx`] to generate WGSL;
+/// for example, `Handle<Type>` depends on a type arena, and might
+/// refer to overrides as well. Such types should implement
+/// [`ToWgslForErrorWithContext`] instead.
+pub trait ToWgslForError {
+    fn to_wgsl_for_error(&self) -> String;
+}
 
-use crate::proc::GlobalCtx;
-use crate::Handle;
+/// A trait for rendering complex Naga IR types into strings for error messages.
+///
+/// Some Naga IR types do not require a [`GlobalCtx`] to generate
+/// WGSL; for example, [`Scalar`] is self-contained. Such types should
+/// implement [`ToWgslForError`] instead.
+pub trait ToWgslForErrorWithContext {
+    fn write_wgsl_for_error(&self, ctx: &GlobalCtx<'_>, out: &mut String) -> fmt::Result;
+
+    fn to_wgsl_for_error(&self, ctx: &GlobalCtx<'_>) -> String {
+        let mut buf = String::new();
+        self.write_wgsl_for_error(ctx, &mut buf).unwrap();
+        buf
+    }
+}
 
-impl crate::proc::TypeResolution {
-    pub fn to_wgsl_for_error(&self, gctx: &GlobalCtx) -> String {
+impl ToWgslForErrorWithContext for TypeResolution {
+    fn write_wgsl_for_error(&self, ctx: &GlobalCtx<'_>, out: &mut String) -> fmt::Result {
         match *self {
-            crate::proc::TypeResolution::Handle(handle) => handle.to_wgsl_for_error(gctx),
-            crate::proc::TypeResolution::Value(ref inner) => inner.to_wgsl_for_error(gctx),
+            TypeResolution::Handle(handle) => ctx.write_type(handle, out),
+            TypeResolution::Value(ref inner) => ctx.write_type_inner(inner, out),
         }
     }
 }
 
-impl Handle<crate::Type> {
-    /// Formats the type as it is written in wgsl.
-    ///
-    /// For example `vec3<f32>`.
-    pub fn to_wgsl_for_error(self, gctx: &GlobalCtx) -> String {
-        let ty = &gctx.types[self];
-        match ty.name {
-            Some(ref name) => name.clone(),
-            None => ty.inner.to_wgsl_for_error(gctx),
-        }
+impl ToWgslForErrorWithContext for Handle<Type> {
+    fn write_wgsl_for_error(&self, ctx: &GlobalCtx<'_>, out: &mut String) -> fmt::Result {
+        ctx.write_type(*self, out)
     }
 }
 
-impl crate::TypeInner {
-    /// Formats the type as it is written in wgsl.
-    ///
-    /// For example `vec3<f32>`.
-    ///
-    /// Note: `TypeInner::Struct` doesn't include the name of the
-    /// struct type. Therefore this method will simply return "struct"
-    /// for them.
-    pub fn to_wgsl_for_error(&self, gctx: &GlobalCtx) -> String {
-        use crate::TypeInner as Ti;
+impl ToWgslForErrorWithContext for TypeInner {
+    fn write_wgsl_for_error(&self, ctx: &GlobalCtx<'_>, out: &mut String) -> fmt::Result {
+        ctx.write_type_inner(self, out)
+    }
+}
 
-        match *self {
-            Ti::Scalar(scalar) => scalar.to_wgsl_for_error(),
-            Ti::Vector { size, scalar } => {
-                format!("vec{}<{}>", size as u32, scalar.to_wgsl_for_error())
-            }
-            Ti::Matrix {
-                columns,
-                rows,
-                scalar,
-            } => {
-                format!(
-                    "mat{}x{}<{}>",
-                    columns as u32,
-                    rows as u32,
-                    scalar.to_wgsl_for_error(),
-                )
-            }
-            Ti::Atomic(scalar) => {
-                format!("atomic<{}>", scalar.to_wgsl_for_error())
-            }
-            Ti::Pointer { base, .. } => {
-                let name = base.to_wgsl_for_error(gctx);
-                format!("ptr<{name}>")
-            }
-            Ti::ValuePointer { scalar, .. } => {
-                format!("ptr<{}>", scalar.to_wgsl_for_error())
-            }
-            Ti::Array { base, size, .. } => {
-                let base = base.to_wgsl_for_error(gctx);
-                match size {
-                    crate::ArraySize::Constant(size) => format!("array<{base}, {size}>"),
-                    crate::ArraySize::Pending(_) => unreachable!(),
-                    crate::ArraySize::Dynamic => format!("array<{base}>"),
-                }
-            }
-            Ti::Struct { .. } => {
-                // TODO: Actually output the struct?
-                "struct".to_string()
-            }
-            Ti::Image {
-                dim,
-                arrayed,
-                class,
-            } => {
-                let dim_suffix = match dim {
-                    crate::ImageDimension::D1 => "_1d",
-                    crate::ImageDimension::D2 => "_2d",
-                    crate::ImageDimension::D3 => "_3d",
-                    crate::ImageDimension::Cube => "_cube",
-                };
-                let array_suffix = if arrayed { "_array" } else { "" };
+impl ToWgslForError for Scalar {
+    fn to_wgsl_for_error(&self) -> String {
+        match self.try_to_wgsl() {
+            Some(static_string) => static_string.to_string(),
+            None => format!("{{non-WGSL Naga scalar {self:?}}}"),
+        }
+    }
+}
 
-                let class_suffix = match class {
-                    crate::ImageClass::Sampled { multi: true, .. } => "_multisampled",
-                    crate::ImageClass::Depth { multi: false } => "_depth",
-                    crate::ImageClass::Depth { multi: true } => "_depth_multisampled",
-                    crate::ImageClass::Sampled { multi: false, .. }
-                    | crate::ImageClass::Storage { .. } => "",
-                };
+impl<W: fmt::Write> TypeContext<W> for GlobalCtx<'_> {
+    fn lookup_type(&self, handle: Handle<Type>) -> &Type {
+        &self.types[handle]
+    }
 
-                let type_in_brackets = match class {
-                    crate::ImageClass::Sampled { kind, .. } => {
-                        // Note: The only valid widths are 4 bytes wide.
-                        // The lexer has already verified this, so we can safely assume it here.
-                        // https://gpuweb.github.io/gpuweb/wgsl/#sampled-texture-type
-                        let element_type = crate::Scalar { kind, width: 4 }.to_wgsl_for_error();
-                        format!("<{element_type}>")
-                    }
-                    crate::ImageClass::Depth { multi: _ } => String::new(),
-                    crate::ImageClass::Storage { format, access } => {
-                        if access.contains(crate::StorageAccess::STORE) {
-                            format!("<{},write>", format.to_wgsl())
-                        } else {
-                            format!("<{}>", format.to_wgsl())
-                        }
-                    }
-                };
+    fn type_name(&self, handle: Handle<Type>) -> &str {
+        self.types[handle]
+            .name
+            .as_deref()
+            .unwrap_or("{anonymous type}")
+    }
 
-                format!("texture{class_suffix}{dim_suffix}{array_suffix}{type_in_brackets}")
-            }
-            Ti::Sampler { .. } => "sampler".to_string(),
-            Ti::AccelerationStructure { vertex_return } => {
-                let caps = if vertex_return { "<vertex_return>" } else { "" };
-                format!("acceleration_structure{}", caps)
-            }
-            Ti::RayQuery { vertex_return } => {
-                let caps = if vertex_return { "<vertex_return>" } else { "" };
-                format!("ray_query{}", caps)
-            }
-            Ti::BindingArray { base, size, .. } => {
-                let member_type = &gctx.types[base];
-                let base = member_type.name.as_deref().unwrap_or("unknown");
-                match size {
-                    crate::ArraySize::Constant(size) => format!("binding_array<{base}, {size}>"),
-                    crate::ArraySize::Pending(_) => unreachable!(),
-                    crate::ArraySize::Dynamic => format!("binding_array<{base}>"),
-                }
-            }
+    fn write_override(&self, handle: Handle<crate::Override>, out: &mut W) -> fmt::Result {
+        match self.overrides[handle].name {
+            Some(ref name) => out.write_str(name),
+            None => write!(out, "{{anonymous override {handle:?}}}"),
         }
     }
-}
 
-impl crate::Scalar {
-    /// Format a scalar kind+width as a type is written in wgsl.
-    ///
-    /// Examples: `f32`, `u64`, `bool`.
-    pub fn to_wgsl_for_error(self) -> String {
-        let prefix = match self.kind {
-            crate::ScalarKind::Sint => "i",
-            crate::ScalarKind::Uint => "u",
-            crate::ScalarKind::Float => "f",
-            crate::ScalarKind::Bool => return "bool".to_string(),
-            crate::ScalarKind::AbstractInt => return "{AbstractInt}".to_string(),
-            crate::ScalarKind::AbstractFloat => return "{AbstractFloat}".to_string(),
-        };
-        format!("{}{}", prefix, self.width * 8)
+    fn write_non_wgsl_inner(&self, inner: &TypeInner, out: &mut W) -> fmt::Result {
+        write!(out, "{{non-WGSL Naga type {inner:?}}}")
+    }
+
+    fn write_non_wgsl_scalar(&self, scalar: Scalar, out: &mut W) -> fmt::Result {
+        match scalar.kind {
+            crate::ScalarKind::Sint
+            | crate::ScalarKind::Uint
+            | crate::ScalarKind::Float
+            | crate::ScalarKind::Bool => write!(out, "{{non-WGSL Naga scalar {scalar:?}}}"),
+
+            // The abstract types are kind of an odd pseudo-WGSL category:
+            // they are definitely part of the spec, but they are not expressible
+            // in WGSL itself. So we want to call them out by name in error messages,
+            // but the WGSL backend should never generate these.
+            crate::ScalarKind::AbstractInt => out.write_str("{AbstractInt}"),
+            crate::ScalarKind::AbstractFloat => out.write_str("{AbstractFloat}"),
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use super::ToWgslForErrorWithContext;
+
+    use crate::proc::GlobalCtx;
     use alloc::{string::ToString, vec};
 
     #[test]
@@ -193,7 +136,7 @@ mod tests {
             Default::default(),
         );
 
-        let gctx = crate::proc::GlobalCtx {
+        let gctx = GlobalCtx {
             types: &types,
             constants: &crate::Arena::new(),
             overrides: &crate::Arena::new(),
@@ -219,7 +162,7 @@ mod tests {
                 access: crate::StorageAccess::default(),
             },
         };
-        assert_eq!(ptr.to_wgsl_for_error(&gctx), "ptr<MyType2>");
+        assert_eq!(ptr.to_wgsl_for_error(&gctx), "ptr<storage, MyType2>");
 
         let img1 = crate::TypeInner::Image {
             dim: crate::ImageDimension::D2,

naga/src/proc/constant_evaluator.rs

@@ -1554,7 +1554,7 @@ impl<'a> ConstantEvaluator<'a> {
             let from = format!("{:?} {:?}", expr, self.expressions[expr]);
 
             #[cfg(feature = "wgsl-in")]
-            let to = target.to_wgsl_for_error();
+            let to = crate::front::wgsl::ToWgslForError::to_wgsl_for_error(&target);
 
             #[cfg(not(feature = "wgsl-in"))]
             let to = format!("{target:?}");