test(naga): cover diagnostic(…); parsing

Author: ErichDonGubler

naga/src/diagnostic_filter.rs

@@ -22,6 +22,7 @@ use serde::Serialize;
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 #[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
+#[cfg_attr(test, derive(strum::EnumIter))]
 pub enum Severity {
     Off,
     Info,
@@ -30,6 +31,17 @@ pub enum Severity {
 }
 
 impl Severity {
+    /// Maps this [`Severity`] into the sentinel word associated with it in WGSL.
+    #[cfg(test)]
+    pub const fn to_wgsl_ident(self) -> &'static str {
+        match self {
+            Self::Error => Self::ERROR,
+            Self::Warning => Self::WARNING,
+            Self::Info => Self::INFO,
+            Self::Off => Self::OFF,
+        }
+    }
+
     /// Checks whether this severity is [`Self::Error`].
     ///
     /// Naga does not yet support diagnostic items at lesser severities than
@@ -74,6 +86,7 @@ pub enum FilterableTriggeringRule {
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 #[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
+#[cfg_attr(test, derive(strum::EnumIter))]
 pub enum StandardFilterableTriggeringRule {
     DerivativeUniformity,
 }

naga/src/front/wgsl/tests.rs

@@ -706,8 +706,77 @@ fn parse_missing_workgroup_size() {
 }
 
 mod diagnostic_filter {
+    use crate::diagnostic_filter::{
+        FilterableTriggeringRule, Severity, StandardFilterableTriggeringRule,
+    };
     use crate::front::wgsl::assert_parse_err;
 
+    use itertools::Itertools as _;
+    use strum::IntoEnumIterator as _;
+
+    #[test]
+    fn basic() {}
+
+    #[test]
+    fn malformed() {
+        assert_parse_err("directive;", snapshot);
+        assert_parse_err("directive(off, asdf;", snapshot);
+        assert_parse_err("directive();", snapshot);
+    }
+
+    #[test]
+    fn severities() {}
+
+    #[test]
+    fn invalid_severity() {}
+
+    #[test]
+    fn triggering_rules() {}
+
+    #[test]
+    fn invalid_triggering_rule() {
+        #[derive(Debug, Clone)]
+        enum Rule {
+            Valid(FilterableTriggeringRule),
+            Invalid,
+        }
+
+        #[derive(Debug, Clone)]
+        enum Sev {
+            Valid(Severity),
+            Invalid,
+        }
+
+        let cases = {
+            let invalid_sev_cases = StandardFilterableTriggeringRule::iter()
+                .map(FilterableTriggeringRule::Standard)
+                .map(Rule::Valid)
+                .cartesian_product([Sev::Invalid]);
+            let invalid_rule_cases = [Rule::Invalid]
+                .into_iter()
+                .cartesian_product(Severity::iter().map(Sev::Valid));
+            invalid_sev_cases.chain(invalid_rule_cases)
+        };
+
+        for (rule, severity) in cases {
+            let rule = match rule {
+                Rule::Valid(rule) => rule.to_wgsl_ident(),
+                Rule::Invalid => "totes_invalid_rule",
+            };
+            let severity = match severity {
+                Sev::Valid(severity) => severity.to_wgsl_ident(),
+                Sev::Invalid => "totes_invalid_severity",
+            };
+            let shader = format!("diagnostic({severity},{rule});");
+            let expected_msg = format!(
+                "\
+"
+            );
+
+            assert_parse_err(&shader, &expected_msg);
+        }
+    }
+
     #[test]
     fn intended_global_directive() {
         let shader = "@diagnostic(off, my.lint);";