WIP: feat: tags property on tests and subtests

TODO: Worried about perf. from extra memory usage in tests. Conditional
values defeat the purpose of tags, too.

moz-webgpu-cts/src/main.rs

@@ -579,6 +579,7 @@ fn run(cli: Cli) -> ExitCode {
                     is_disabled,
                     expected,
                     implementation_status: _,
+                    tags: _,
                 } = properties;
 
                 let test_name = Arc::new(test_name);
@@ -703,6 +704,7 @@ fn run(cli: Cli) -> ExitCode {
                         is_disabled,
                         expected,
                         implementation_status: _,
+                        tags: _,
                     } = properties;
 
                     if is_disabled {

moz-webgpu-cts/src/wpt/metadata.rs

@@ -759,6 +759,7 @@ where
             is_disabled,
             expected,
             implementation_status,
+            tags,
         } = property;
 
         if *is_disabled {
@@ -839,6 +840,25 @@ where
             Ok(())
         }
 
+        if let Some(tags) = tags {
+            use std::borrow::Cow;
+
+            #[derive(Clone, Debug, Default, Eq, PartialEq)]
+            struct TagsDisplay<'a>(Cow<'a, Vec<String>>);
+
+            impl Display for TagsDisplay<'_> {
+                fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                    let Self(tags) = self;
+                    Display::fmt(&tags.iter().join_with(", "), f)
+                }
+            }
+
+            let tags_ref = tags.as_ref();
+            let tags_ref = tags_ref.map(Cow::Borrowed).map(TagsDisplay);
+
+            write_normalized(f, &indent, TAGS_IDENT, tags_ref)?;
+        }
+
         if let Some(implementation_status) = implementation_status {
             write_normalized(
                 f,
@@ -877,6 +897,7 @@ where
     pub is_disabled: bool,
     pub expected: Option<ExpandedPropertyValue<Expected<Out>>>,
     pub implementation_status: Option<ExpandedPropertyValue<ImplementationStatus>>,
+    pub tags: Option<ExpandedPropertyValue<Vec<String>>>,
 }
 
 impl<'a, Out> TestProps<Out>
@@ -888,6 +909,7 @@ where
             is_disabled,
             expected,
             implementation_status,
+            tags,
         } = self;
 
         let TestProp { kind, span } = prop;
@@ -966,6 +988,7 @@ where
                 implementation_status,
                 val,
             ),
+            TestPropKind::Tags(val) => conditional(emitter, span, TAGS_IDENT, tags, val),
         }
     }
 }
@@ -993,6 +1016,7 @@ where
     Expected(PropertyValue<Applicability, Expected<Out>>),
     Disabled,
     ImplementationStatus(PropertyValue<Applicability, ImplementationStatus>),
+    Tags(PropertyValue<Applicability, Vec<String>>),
 }
 
 impl<Out> TestProp<Out>
@@ -1170,18 +1194,23 @@ where
             helper
                 .parser(
                     ImplementationStatus::property_ident_parser(),
-                    conditional_term,
+                    conditional_term.clone(),
                     ImplementationStatus::property_value_parser(),
                 )
                 .map_with(|((), val), e| TestProp {
                     span: e.span(),
                     kind: TestPropKind::ImplementationStatus(val),
                 }),
+            tags_parser(helper, conditional_term).map_with(|val, e| TestProp {
+                span: e.span(),
+                kind: TestPropKind::Tags(val),
+            }),
         ))
     }
 }
 
 pub(crate) const EXPECTED_IDENT: &str = "expected";
+pub(crate) const TAGS_IDENT: &str = "expected";
 pub(crate) const PASS: &str = "PASS";
 pub(crate) const FAIL: &str = "FAIL";
 pub(crate) const NOTRUN: &str = "NOTRUN";

moz-webgpu-cts/src/wpt/metadata/properties.rs

@@ -290,6 +290,12 @@ impl<T> ExpandedPropertyValue<T> {
         let Self(inner) = self;
         inner
     }
+
+    pub(crate) fn as_ref(&self) -> ExpandedPropertyValue<&T> {
+        ExpandedPropertyValue::from_query(|platform, build_profile| {
+            &self[(platform, build_profile)]
+        })
+    }
 }
 
 impl<T> ExpandedPropertyValue<T> {