[wgsl-in] Implement template list discovery and handle all type resolution in the lowerer

naga/src/back/glsl/mod.rs

@@ -663,6 +663,7 @@ impl<'a, W: Write> Writer<'a, W> {
         namer.reset(
             module,
             &keywords::RESERVED_KEYWORD_SET,
+            proc::KeywordSet::empty(),
             proc::CaseInsensitiveKeywordSet::empty(),
             &[
                 "gl_",                     // all GL built-in variables

naga/src/back/hlsl/writer.rs

@@ -155,6 +155,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
         self.namer.reset(
             module,
             &super::keywords::RESERVED_SET,
+            proc::KeywordSet::empty(),
             &super::keywords::RESERVED_CASE_INSENSITIVE_SET,
             super::keywords::RESERVED_PREFIXES,
             &mut self.names,

naga/src/back/msl/writer.rs

@@ -4279,6 +4279,7 @@ impl<W: Write> Writer<W> {
         self.namer.reset(
             module,
             &super::keywords::RESERVED_SET,
+            proc::KeywordSet::empty(),
             proc::CaseInsensitiveKeywordSet::empty(),
             &[CLAMPED_LOD_LOAD_PREFIX],
             &mut self.names,

naga/src/back/wgsl/writer.rs

@@ -100,6 +100,7 @@ impl<W: Write> Writer<W> {
         self.namer.reset(
             module,
             &crate::keywords::wgsl::RESERVED_SET,
+            &crate::keywords::wgsl::BUILTIN_IDENTIFIER_SET,
             // an identifier must not start with two underscore
             proc::CaseInsensitiveKeywordSet::empty(),
             &["__", "_naga"],

naga/src/front/wgsl/error.rs

@@ -135,6 +135,7 @@ pub enum ExpectedToken<'a> {
     Identifier,
     AfterIdentListComma,
     AfterIdentListArg,
+    LhsExpression,
     /// Expected: constant, parenthesized expression, identifier
     PrimaryExpression,
     /// Expected: assignment, increment/decrement expression
@@ -145,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
@@ -191,21 +190,20 @@ pub(crate) enum Error<'a> {
     },
     BadIncrDecrReferenceType(Span),
     InvalidResolve(ResolveError),
-    InvalidForInitializer(Span),
     /// A break if appeared outside of a continuing block
     InvalidBreakIf(Span),
     InvalidGatherComponent(Span),
     InvalidConstructorComponentType(Span, i32),
     InvalidIdentifierUnderscore(Span),
     ReservedIdentifierPrefix(Span),
     UnknownAddressSpace(Span),
+    UnknownRayFlag(Span),
     RepeatedAttribute(Span),
     UnknownAttribute(Span),
     UnknownBuiltin(Span),
     UnknownAccess(Span),
     UnknownIdent(Span, &'a str),
     UnknownScalarType(Span),
-    UnknownType(Span),
     UnknownStorageFormat(Span),
     UnknownConservativeDepth(Span),
     UnknownEnableExtension(Span, &'a str),
@@ -275,6 +273,7 @@ pub(crate) enum Error<'a> {
         span: Span,
     },
     CalledEntryPoint(Span),
+    CalledLocalDecl(Span),
     WrongArgumentCount {
         span: Span,
         expected: Range<u32>,
@@ -412,6 +411,15 @@ pub(crate) enum Error<'a> {
     TypeTooLarge {
         span: Span,
     },
+    UnexpectedIdentForEnumerant(Span),
+    UnexpectedExprForEnumerant(Span),
+    UnusedArgsForTemplate(Vec<Span>),
+    UnexpectedTemplate(Span),
+    MissingTemplateArg {
+        span: Span,
+        arg: &'static str,
+    },
+    UnexpectedExprForTypeExpression(Span),
 }
 
 impl From<ConflictingDiagnosticRuleError> for Error<'_> {
@@ -480,13 +488,16 @@ impl<'a> Error<'a> {
                         Token::IncrementOperation => "increment operation".to_string(),
                         Token::DecrementOperation => "decrement operation".to_string(),
                         Token::Arrow => "->".to_string(),
+                        Token::TemplateArgsStart => "template args start".to_string(),
+                        Token::TemplateArgsEnd => "template args end".to_string(),
                         Token::Unknown(c) => format!("unknown (`{c}`)"),
                         Token::Trivia => "trivia".to_string(),
                         Token::DocComment(s) => format!("doc comment ('{s}')"),
                         Token::ModuleDocComment(s) => format!("module doc comment ('{s}')"),
                         Token::End => "end".to_string(),
                     },
                     ExpectedToken::Identifier => "identifier".to_string(),
+                    ExpectedToken::LhsExpression => "lhs_expression".to_string(),
                     ExpectedToken::PrimaryExpression => "expression".to_string(),
                     ExpectedToken::Assignment => "assignment or increment/decrement".to_string(),
                     ExpectedToken::SwitchItem => concat!(
@@ -503,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 => {
@@ -610,14 +620,6 @@ impl<'a> Error<'a> {
                 labels: vec![],
                 notes: vec![],
             },
-            Error::InvalidForInitializer(bad_span) => ParseError {
-                message: format!(
-                    "for(;;) initializer is not an assignment or a function call: `{}`",
-                    &source[bad_span]
-                ),
-                labels: vec![(bad_span, "not an assignment or function call".into())],
-                notes: vec![],
-            },
             Error::InvalidBreakIf(bad_span) => ParseError {
                 message: "A break if is only allowed in a continuing block".to_string(),
                 labels: vec![(bad_span, "not in a continuing block".into())],
@@ -657,6 +659,11 @@ impl<'a> Error<'a> {
                 labels: vec![(bad_span, "unknown address space".into())],
                 notes: vec![],
             },
+            Error::UnknownRayFlag(bad_span) => ParseError {
+                message: format!("unknown ray flag: `{}`", &source[bad_span]),
+                labels: vec![(bad_span, "unknown ray flag".into())],
+                notes: vec![],
+            },
             Error::RepeatedAttribute(bad_span) => ParseError {
                 message: format!("repeated attribute: `{}`", &source[bad_span]),
                 labels: vec![(bad_span, "repeated attribute".into())],
@@ -687,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())],
@@ -916,6 +918,11 @@ impl<'a> Error<'a> {
                 labels: vec![(span, "entry point cannot be called".into())],
                 notes: vec![],
             },
+            Error::CalledLocalDecl(span) => ParseError {
+                message: "local declaration cannot be called".to_string(),
+                labels: vec![(span, "local declaration cannot be called".into())],
+                notes: vec![],
+            },
             Error::WrongArgumentCount {
                 span,
                 ref expected,
@@ -1386,6 +1393,45 @@ impl<'a> Error<'a> {
                     crate::valid::MAX_TYPE_SIZE
                 )],
             },
+            Error::UnexpectedIdentForEnumerant(ident_span) => ParseError {
+                message: format!(
+                    "identifier `{}` resolves to a declaration",
+                    &source[ident_span]
+                ),
+                labels: vec![(ident_span, "needs to resolve to a predeclared enumerant".into())],
+                notes: vec![],
+            },
+            Error::UnexpectedExprForEnumerant(expr_span) => ParseError {
+                message: "unexpected expression".to_string(),
+                labels: vec![(expr_span, "needs to be an identifier resolving to a predeclared enumerant".into())],
+                notes: vec![],
+            },
+            Error::UnusedArgsForTemplate(ref expr_spans) => ParseError {
+                message: "unused expressions for template".to_string(),
+                labels: expr_spans.iter().cloned().map(|span| -> (_, _){ (span, "unused".into()) }).collect(),
+                notes: vec![],
+            },
+            Error::UnexpectedTemplate(span) => ParseError {
+                message: "unexpected template".to_string(),
+                labels: vec![(span, "expected identifier".into())],
+                notes: vec![],
+            },
+            Error::MissingTemplateArg {
+                span,
+                arg,
+            } => ParseError {
+                message: format!(
+                    "`{}` needs a template argument specified: {arg}",
+                    &source[span]
+                ),
+                labels: vec![(span, "is missing a template argument".into())],
+                notes: vec![],
+            },
+            Error::UnexpectedExprForTypeExpression(expr_span) => ParseError {
+                message: "unexpected expression".to_string(),
+                labels: vec![(expr_span, "needs to be an identifier resolving to a type declaration (alias or struct) or predeclared type(-generator)".into())],
+                notes: vec![],
+            }
         }
     }
 }