handle all type resolution in the lowerer

Author: teoxoy

naga/src/front/wgsl/error.rs

@@ -146,8 +146,6 @@ pub enum ExpectedToken<'a> {
     WorkgroupSizeSeparator,
     /// Expected: 'struct', 'let', 'var', 'type', ';', 'fn', eof
     GlobalItem,
-    /// Expected a type.
-    Type,
     /// Access of `var`, `let`, `const`.
     Variable,
     /// Access of a function
@@ -206,7 +204,6 @@ pub(crate) enum Error<'a> {
     UnknownAccess(Span),
     UnknownIdent(Span, &'a str),
     UnknownScalarType(Span),
-    UnknownType(Span),
     UnknownStorageFormat(Span),
     UnknownConservativeDepth(Span),
     UnknownEnableExtension(Span, &'a str),
@@ -517,7 +514,6 @@ impl<'a> Error<'a> {
                         "or the end of the file"
                     )
                     .to_string(),
-                    ExpectedToken::Type => "type".to_string(),
                     ExpectedToken::Variable => "variable access".to_string(),
                     ExpectedToken::Function => "function name".to_string(),
                     ExpectedToken::AfterIdentListArg => {
@@ -698,11 +694,6 @@ impl<'a> Error<'a> {
                 labels: vec![(bad_span, "unknown conservative depth".into())],
                 notes: vec![],
             },
-            Error::UnknownType(bad_span) => ParseError {
-                message: format!("unknown type: `{}`", &source[bad_span]),
-                labels: vec![(bad_span, "unknown type".into())],
-                notes: vec![],
-            },
             Error::UnknownEnableExtension(span, word) => ParseError {
                 message: format!("unknown enable-extension `{word}`"),
                 labels: vec![(span, "".into())],

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

@@ -83,7 +83,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> {
         ctx: &mut ExpressionContext<'source, '_, '_>,
     ) -> Result<'source, ir::ArraySize> {
         if let Some(expr) = self.template_list.next() {
-            lowerer.array_size2(*expr, ctx)
+            lowerer.array_size(*expr, ctx)
         } else {
             Ok(ir::ArraySize::Dynamic)
         }

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

@@ -4,7 +4,6 @@ use core::hash::Hash;
 use crate::diagnostic_filter::DiagnosticFilterNode;
 use crate::front::wgsl::parse::directive::enable_extension::EnableExtensions;
 use crate::front::wgsl::parse::number::Number;
-use crate::front::wgsl::Scalar;
 use crate::{Arena, FastIndexSet, Handle, Span};
 
 #[derive(Debug, Default)]
@@ -24,12 +23,6 @@ pub struct TranslationUnit<'a> {
     /// [`Function`]: crate::Function
     pub expressions: Arena<Expression<'a>>,
 
-    /// Non-user-defined types, like `vec4<f32>` or `array<i32, 10>`.
-    ///
-    /// These are referred to by `Handle<ast::Type<'a>>` values.
-    /// User-defined types are referred to by name until lowering.
-    pub types: Arena<Type<'a>>,
-
     /// Arena for all diagnostic filter rules parsed in this module, including those in functions.
     ///
     /// See [`DiagnosticFilterNode`] for details on how the tree is represented and used in
@@ -139,14 +132,14 @@ pub enum GlobalDeclKind<'a> {
 #[derive(Debug)]
 pub struct FunctionArgument<'a> {
     pub name: Ident<'a>,
-    pub ty: Handle<Type<'a>>,
+    pub ty: TemplateElaboratedIdent<'a>,
     pub binding: Option<Binding<'a>>,
     pub handle: Handle<Local>,
 }
 
 #[derive(Debug)]
 pub struct FunctionResult<'a> {
-    pub ty: Handle<Type<'a>>,
+    pub ty: TemplateElaboratedIdent<'a>,
     pub binding: Option<Binding<'a>>,
     pub must_use: bool,
 }
@@ -194,15 +187,15 @@ pub struct GlobalVariable<'a> {
     pub name: Ident<'a>,
     pub template_list: Vec<Handle<Expression<'a>>>,
     pub binding: Option<ResourceBinding<'a>>,
-    pub ty: Option<Handle<Type<'a>>>,
+    pub ty: Option<TemplateElaboratedIdent<'a>>,
     pub init: Option<Handle<Expression<'a>>>,
     pub doc_comments: Vec<&'a str>,
 }
 
 #[derive(Debug)]
 pub struct StructMember<'a> {
     pub name: Ident<'a>,
-    pub ty: Handle<Type<'a>>,
+    pub ty: TemplateElaboratedIdent<'a>,
     pub binding: Option<Binding<'a>>,
     pub align: Option<Handle<Expression<'a>>>,
     pub size: Option<Handle<Expression<'a>>>,
@@ -219,13 +212,13 @@ pub struct Struct<'a> {
 #[derive(Debug)]
 pub struct TypeAlias<'a> {
     pub name: Ident<'a>,
-    pub ty: Handle<Type<'a>>,
+    pub ty: TemplateElaboratedIdent<'a>,
 }
 
 #[derive(Debug)]
 pub struct Const<'a> {
     pub name: Ident<'a>,
-    pub ty: Option<Handle<Type<'a>>>,
+    pub ty: Option<TemplateElaboratedIdent<'a>>,
     pub init: Handle<Expression<'a>>,
     pub doc_comments: Vec<&'a str>,
 }
@@ -234,69 +227,10 @@ pub struct Const<'a> {
 pub struct Override<'a> {
     pub name: Ident<'a>,
     pub id: Option<Handle<Expression<'a>>>,
-    pub ty: Option<Handle<Type<'a>>>,
+    pub ty: Option<TemplateElaboratedIdent<'a>>,
     pub init: Option<Handle<Expression<'a>>>,
 }
 
-/// The size of an [`Array`] or [`BindingArray`].
-///
-/// [`Array`]: Type::Array
-/// [`BindingArray`]: Type::BindingArray
-#[derive(Debug, Copy, Clone)]
-pub enum ArraySize<'a> {
-    /// The length as a constant expression.
-    Constant(Handle<Expression<'a>>),
-    Dynamic,
-}
-
-#[derive(Debug)]
-pub enum Type<'a> {
-    Scalar(Scalar),
-    Vector {
-        size: crate::VectorSize,
-        ty: Handle<Type<'a>>,
-        ty_span: Span,
-    },
-    Matrix {
-        columns: crate::VectorSize,
-        rows: crate::VectorSize,
-        ty: Handle<Type<'a>>,
-        ty_span: Span,
-    },
-    Atomic(Scalar),
-    Pointer {
-        base: Handle<Type<'a>>,
-        space: crate::AddressSpace,
-    },
-    Array {
-        base: Handle<Type<'a>>,
-        size: ArraySize<'a>,
-    },
-    Image {
-        dim: crate::ImageDimension,
-        arrayed: bool,
-        class: crate::ImageClass,
-    },
-    Sampler {
-        comparison: bool,
-    },
-    AccelerationStructure {
-        vertex_return: bool,
-    },
-    RayQuery {
-        vertex_return: bool,
-    },
-    RayDesc,
-    RayIntersection,
-    BindingArray {
-        base: Handle<Type<'a>>,
-        size: ArraySize<'a>,
-    },
-
-    /// A user-defined type, like a struct or a type alias.
-    User(Ident<'a>),
-}
-
 #[derive(Debug, Default)]
 pub struct Block<'a> {
     pub stmts: Vec<Statement<'a>>,
@@ -395,23 +329,23 @@ pub enum Expression<'a> {
 #[derive(Debug)]
 pub struct LocalVariable<'a> {
     pub name: Ident<'a>,
-    pub ty: Option<Handle<Type<'a>>>,
+    pub ty: Option<TemplateElaboratedIdent<'a>>,
     pub init: Option<Handle<Expression<'a>>>,
     pub handle: Handle<Local>,
 }
 
 #[derive(Debug)]
 pub struct Let<'a> {
     pub name: Ident<'a>,
-    pub ty: Option<Handle<Type<'a>>>,
+    pub ty: Option<TemplateElaboratedIdent<'a>>,
     pub init: Handle<Expression<'a>>,
     pub handle: Handle<Local>,
 }
 
 #[derive(Debug)]
 pub struct LocalConst<'a> {
     pub name: Ident<'a>,
-    pub ty: Option<Handle<Type<'a>>>,
+    pub ty: Option<TemplateElaboratedIdent<'a>>,
     pub init: Handle<Expression<'a>>,
     pub handle: Handle<Local>,
 }

naga/src/front/wgsl/parse/ast.rs

@@ -152,60 +152,6 @@ pub fn map_storage_format(word: &str, span: Span) -> Result<'_, crate::StorageFo
     })
 }
 
-pub fn get_scalar_type(
-    enable_extensions: &EnableExtensions,
-    span: Span,
-    word: &str,
-) -> Result<'static, Option<Scalar>> {
-    use crate::ScalarKind as Sk;
-    let scalar = match word {
-        "f16" => Some(Scalar {
-            kind: Sk::Float,
-            width: 2,
-        }),
-        "f32" => Some(Scalar {
-            kind: Sk::Float,
-            width: 4,
-        }),
-        "f64" => Some(Scalar {
-            kind: Sk::Float,
-            width: 8,
-        }),
-        "i32" => Some(Scalar {
-            kind: Sk::Sint,
-            width: 4,
-        }),
-        "u32" => Some(Scalar {
-            kind: Sk::Uint,
-            width: 4,
-        }),
-        "i64" => Some(Scalar {
-            kind: Sk::Sint,
-            width: 8,
-        }),
-        "u64" => Some(Scalar {
-            kind: Sk::Uint,
-            width: 8,
-        }),
-        "bool" => Some(Scalar {
-            kind: Sk::Bool,
-            width: crate::BOOL_WIDTH,
-        }),
-        _ => None,
-    };
-
-    if matches!(scalar, Some(Scalar::F16))
-        && !enable_extensions.contains(ImplementedEnableExtension::F16)
-    {
-        return Err(Box::new(Error::EnableExtensionNotEnabled {
-            span,
-            kind: ImplementedEnableExtension::F16.into(),
-        }));
-    }
-
-    Ok(scalar)
-}
-
 pub fn map_derivative(word: &str) -> Option<(crate::DerivativeAxis, crate::DerivativeControl)> {
     use crate::{DerivativeAxis as Axis, DerivativeControl as Ctrl};
     match word {

naga/src/front/wgsl/parse/conv.rs

@@ -1,8 +1,7 @@
 use super::{number::consume_number, Error, ExpectedToken, Result};
 use crate::front::wgsl::error::NumberError;
 use crate::front::wgsl::parse::directive::enable_extension::EnableExtensions;
-use crate::front::wgsl::parse::{conv, Number};
-use crate::front::wgsl::Scalar;
+use crate::front::wgsl::parse::Number;
 use crate::Span;
 
 use alloc::{boxed::Box, vec::Vec};
@@ -534,10 +533,6 @@ impl<'a> Lexer<'a> {
         Ok(())
     }
 
-    pub(in crate::front::wgsl) fn end_of_generic_arguments(&mut self) -> bool {
-        self.next_if(Token::Separator(',')) && self.peek().0 != Token::TemplateArgsEnd
-    }
-
     pub(in crate::front::wgsl) fn next_ident_with_span(&mut self) -> Result<'a, (&'a str, Span)> {
         match self.next() {
             (Token::Word("_"), span) => Err(Box::new(Error::InvalidIdentifierUnderscore(span))),
@@ -566,60 +561,6 @@ impl<'a> Lexer<'a> {
         }
     }
 
-    /// Parses a generic scalar type, for example `<f32>`.
-    ///
-    /// Returns the span covering the inner type, excluding the brackets.
-    pub(in crate::front::wgsl) fn next_scalar_generic_with_span(
-        &mut self,
-    ) -> Result<'a, (Scalar, Span)> {
-        self.expect(Token::TemplateArgsStart)?;
-
-        let (scalar, span) = match self.next() {
-            (Token::Word(word), span) => {
-                conv::get_scalar_type(&self.enable_extensions, span, word)?
-                    .map(|scalar| (scalar, span))
-                    .ok_or(Error::UnknownScalarType(span))?
-            }
-            (_, span) => return Err(Box::new(Error::UnknownScalarType(span))),
-        };
-
-        self.expect(Token::TemplateArgsEnd)?;
-        Ok((scalar, span))
-    }
-
-    pub(in crate::front::wgsl) fn next_format_generic(
-        &mut self,
-    ) -> Result<'a, (crate::StorageFormat, crate::StorageAccess)> {
-        self.expect(Token::TemplateArgsStart)?;
-        let (ident, ident_span) = self.next_ident_with_span()?;
-        let format = conv::map_storage_format(ident, ident_span)?;
-        self.expect(Token::Separator(','))?;
-        let (ident, ident_span) = self.next_ident_with_span()?;
-        let access = conv::map_access_mode(ident, ident_span)?;
-        self.expect(Token::TemplateArgsEnd)?;
-        Ok((format, access))
-    }
-
-    pub(in crate::front::wgsl) fn next_acceleration_structure_flags(&mut self) -> Result<'a, bool> {
-        Ok(if self.next_if(Token::TemplateArgsStart) {
-            if !self.next_if(Token::TemplateArgsEnd) {
-                let (name, span) = self.next_ident_with_span()?;
-                let ret = if name == "vertex_return" {
-                    true
-                } else {
-                    return Err(Box::new(Error::UnknownAttribute(span)));
-                };
-                self.next_if(Token::Separator(','));
-                self.expect(Token::TemplateArgsEnd)?;
-                ret
-            } else {
-                false
-            }
-        } else {
-            false
-        })
-    }
-
     pub(in crate::front::wgsl) fn open_arguments(&mut self) -> Result<'a, ()> {
         self.expect(Token::Paren('('))
     }