feat(wgsl-in): add unimpl. diag. for @diagnostic(…)s on fns

naga/src/front/wgsl/error.rs

@@ -136,6 +136,8 @@ pub enum ExpectedToken<'a> {
     Variable,
     /// Access of a function
     Function,
+    /// The `diagnostic` identifier of the `@diagnostic(…)` attribute.
+    DiagnosticAttribute,
 }
 
 #[derive(Clone, Copy, Debug, Error, PartialEq)]
@@ -296,6 +298,10 @@ pub(crate) enum Error<'a> {
         severity_control_name_span: Span,
     },
     DiagnosticDuplicateTriggeringRule(ConflictingDiagnosticRuleError),
+    DiagnosticNotYetImplementedAtParseSite {
+        site_name_plural: &'static str,
+        span: Span,
+    },
 }
 
 impl<'a> From<ConflictingDiagnosticRuleError> for Error<'a> {
@@ -380,6 +386,9 @@ impl<'a> Error<'a> {
                     ExpectedToken::AfterIdentListComma => {
                         "next argument or end of list (';')".to_string()
                     }
+                    ExpectedToken::DiagnosticAttribute => {
+                        "the 'diagnostic' attribute identifier".to_string()
+                    }
                 };
                 ParseError {
                     message: format!(
@@ -1043,6 +1052,21 @@ impl<'a> Error<'a> {
                     .into()],
                 }
             }
+            Error::DiagnosticNotYetImplementedAtParseSite {
+                site_name_plural,
+                span,
+            } => ParseError {
+                message: "`@diagnostic(…)` attribute(s) not yet implemented".into(),
+                labels: vec![(
+                    span,
+                    format!("can't use this for {site_name_plural} (yet)").into(),
+                )],
+                notes: vec![format!(concat!(
+                    "Let Naga maintainers know that you ran into this at ",
+                    "<https://github.com/gfx-rs/wgpu/issues/5320>, ",
+                    "so they can prioritize it!"
+                ))],
+            },
         }
     }
 }

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

@@ -1698,7 +1698,7 @@ impl Parser {
                 let _ = lexer.next();
                 self.pop_rule_span(lexer);
             }
-            (Token::Paren('{'), _) => {
+            (Token::Paren('{') | Token::Attribute, _) => {
                 let (inner, span) = self.block(lexer, ctx, brace_nesting_level)?;
                 block.stmts.push(ast::Statement {
                     kind: ast::StatementKind::Block(inner),
@@ -2328,6 +2328,15 @@ impl Parser {
         self.push_rule_span(Rule::Attribute, lexer);
         while lexer.skip(Token::Attribute) {
             let (name, name_span) = lexer.next_ident_with_span()?;
+            if let Some(DirectiveKind::Diagnostic) = DirectiveKind::from_ident(name) {
+                if let Some(_filter) = self.diagnostic_filter(lexer)? {
+                    let span = self.peek_rule_span(lexer);
+                    return Err(Error::DiagnosticNotYetImplementedAtParseSite {
+                        span,
+                        site_name_plural: "functions",
+                    });
+                }
+            }
             match name {
                 "binding" => {
                     lexer.expect(Token::Paren('('))?;