Parse non-true values for disabled properties

moz-webgpu-cts/Cargo.toml

@@ -11,6 +11,7 @@ publish = false
 dist = true
 
 [dependencies]
+arcstr = { version = "1.1.5", features = ["serde"] }
 camino = { version = "1.1.6", features = ["serde1"] }
 clap = { version = "4.4.2", features = ["derive"] }
 env_logger = "0.10.0"

moz-webgpu-cts/src/main.rs

@@ -1046,14 +1046,14 @@ fn run(cli: Cli) -> ExitCode {
                 } = test;
 
                 let TestProps {
-                    is_disabled,
+                    disabled,
                     expected,
                     implementation_status: _,
                 } = properties;
 
                 let test_name = Arc::new(test_name);
 
-                if is_disabled {
+                if disabled.is_some() {
                     analysis.for_each_platform_mut(|analysis| {
                         analysis
                             .tests_with_disabled_or_skip
@@ -1161,12 +1161,12 @@ fn run(cli: Cli) -> ExitCode {
 
                     let Subtest { properties } = subtest;
                     let TestProps {
-                        is_disabled,
+                        disabled,
                         expected,
                         implementation_status: _,
                     } = properties;
 
-                    if is_disabled {
+                    if disabled.is_some() {
                         analysis
                             .windows
                             .tests_with_disabled_or_skip

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

@@ -4,6 +4,7 @@ use std::{
     hash::Hash,
 };
 
+use arcstr::ArcStr;
 use clap::ValueEnum;
 use enum_map::Enum;
 use enumset::EnumSetType;
@@ -31,7 +32,9 @@ use whippit::{
     },
 };
 
-use crate::wpt::metadata::properties::{ExpandedPropertyValue, Expected, NormalizedPropertyValue};
+use crate::wpt::metadata::properties::{
+    DisabledString, ExpandedPropertyValue, Expected, NormalizedPropertyValue,
+};
 
 #[cfg(test)]
 use insta::assert_debug_snapshot;
@@ -63,7 +66,7 @@ impl<'a> metadata::File<'a> for File {
 
 #[derive(Clone, Debug, Default, Serialize)]
 pub struct FileProps {
-    pub is_disabled: Option<PropertyValue<Expr<Value<'static>>, String>>,
+    pub disabled: Option<PropertyValue<Expr<Value<'static>>, DisabledString>>,
     #[allow(clippy::type_complexity)]
     pub prefs: Option<PropertyValue<Expr<Value<'static>>, Vec<(String, String)>>>,
     pub tags: Option<PropertyValue<Expr<Value<'static>>, Vec<String>>>,
@@ -139,11 +142,11 @@ impl<'a> Properties<'a> for FileProps {
                 any()
                     .and_is(newline().or(end()).not())
                     .repeated()
-                    .at_least(1)
                     .to_slice()
-                    .map(|s: &str| s.to_owned()),
+                    .map(ArcStr::from)
+                    .map(DisabledString::new),
             )
-            .map(|((), is_disabled)| FileProp::Disabled(is_disabled));
+            .map(|((), val)| FileProp::Disabled(val));
 
         let implementation_status = helper
             .parser(
@@ -164,7 +167,7 @@ impl<'a> Properties<'a> for FileProps {
         let (span, prop) = prop;
         let Self {
             implementation_status,
-            is_disabled,
+            disabled,
             prefs,
             tags,
         } = self;
@@ -190,7 +193,7 @@ impl<'a> Properties<'a> for FileProps {
             FileProp::Prefs(new_prefs) => check_dupe_then_insert!(new_prefs, prefs, "prefs"),
             FileProp::Tags(new_tags) => check_dupe_then_insert!(new_tags, tags, "tags"),
             FileProp::Disabled(new_is_disabled) => {
-                check_dupe_then_insert!(new_is_disabled, is_disabled, DISABLED_IDENT)
+                check_dupe_then_insert!(new_is_disabled, disabled, DISABLED_IDENT)
             }
         }
     }
@@ -453,7 +456,7 @@ const DISABLED_IDENT: &str = "disabled";
 pub enum FileProp {
     Prefs(PropertyValue<Expr<Value<'static>>, Vec<(String, String)>>),
     Tags(PropertyValue<Expr<Value<'static>>, Vec<String>>),
-    Disabled(PropertyValue<Expr<Value<'static>>, String>),
+    Disabled(PropertyValue<Expr<Value<'static>>, DisabledString>),
     ImplementationStatus(PropertyValue<Expr<Value<'static>>, ImplementationStatus>),
 }
 
@@ -521,7 +524,7 @@ fn format_file_properties(props: &FileProps) -> impl Display + '_ {
     lazy_format!(|f| {
         let FileProps {
             implementation_status,
-            is_disabled,
+            disabled,
             prefs,
             tags,
         } = props;
@@ -559,8 +562,8 @@ fn format_file_properties(props: &FileProps) -> impl Display + '_ {
             )?;
         }
 
-        if let Some(is_disabled) = is_disabled {
-            write_prop_val(DISABLED_IDENT, is_disabled, Display::fmt, f)?;
+        if let Some(disabled) = disabled {
+            write_prop_val(DISABLED_IDENT, disabled, Display::fmt, f)?;
         }
 
         Ok(())
@@ -749,15 +752,11 @@ where
                 .join_with("  ")
         ));
         let TestProps {
-            is_disabled,
+            disabled,
             expected,
             implementation_status,
         } = property;
 
-        if *is_disabled {
-            writeln!(f, "{indent}disabled: true")?;
-        }
-
         fn write_normalized<T>(
             f: &mut Formatter<'_>,
             indent: &dyn Display,
@@ -841,6 +840,10 @@ where
             )?;
         }
 
+        if let Some(disabled) = disabled {
+            write_normalized(f, &indent, "disabled", disabled)?;
+        }
+
         if let Some(exps) = expected {
             write_normalized(f, &indent, EXPECTED_IDENT, exps)?;
         }
@@ -867,7 +870,7 @@ pub struct TestProps<Out>
 where
     Out: EnumSetType,
 {
-    pub is_disabled: bool,
+    pub disabled: Option<ExpandedPropertyValue<DisabledString>>,
     pub expected: Option<ExpandedPropertyValue<Expected<Out>>>,
     pub implementation_status: Option<ExpandedPropertyValue<ImplementationStatus>>,
 }
@@ -878,7 +881,7 @@ where
 {
     fn insert(&mut self, prop: TestProp<Out>, emitter: &mut Emitter<Rich<'a, char>>) {
         let Self {
-            is_disabled,
+            disabled,
             expected,
             implementation_status,
         } = self;
@@ -946,11 +949,8 @@ where
             TestPropKind::Expected(val) => {
                 conditional(emitter, span, EXPECTED_IDENT, expected, val)
             }
-            TestPropKind::Disabled => {
-                if *is_disabled {
-                    emitter.emit(Rich::custom(span, "duplicate `disabled` key detected"))
-                }
-                *is_disabled = true;
+            TestPropKind::Disabled(val) => {
+                conditional(emitter, span, DISABLED_IDENT, disabled, val)
             }
             TestPropKind::ImplementationStatus(val) => conditional(
                 emitter,
@@ -984,7 +984,7 @@ where
     Out: EnumSetType,
 {
     Expected(PropertyValue<Applicability, Expected<Out>>),
-    Disabled,
+    Disabled(PropertyValue<Applicability, DisabledString>),
     ImplementationStatus(PropertyValue<Applicability, ImplementationStatus>),
 }
 
@@ -1143,22 +1143,16 @@ where
                 .parser(
                     just(DISABLED_IDENT).to(()),
                     conditional_term.clone(),
-                    just("true").to(()),
+                    any()
+                        .and_is(newline().not())
+                        .repeated()
+                        .to_slice()
+                        .map(ArcStr::from)
+                        .map(DisabledString::new),
                 )
-                .validate(|((), val), e, emitter| {
-                    match val {
-                        PropertyValue::Unconditional(()) => (),
-                        PropertyValue::Conditional { .. } => {
-                            emitter.emit(Rich::custom(
-                                e.span(),
-                                "conditional rules for `disabled` aren't supported yet",
-                            ));
-                        }
-                    }
-                    TestProp {
-                        span: e.span(),
-                        kind: TestPropKind::Disabled,
-                    }
+                .map_with(|((), val), e| TestProp {
+                    span: e.span(),
+                    kind: TestPropKind::Disabled(val),
                 }),
             helper
                 .parser(

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

@@ -5,6 +5,7 @@
     ops::{BitOr, BitOrAssign, Index, IndexMut},
 };
 
+use arcstr::ArcStr;
 use enum_map::EnumMap;
 use enumset::{EnumSet, EnumSetType};
 use itertools::Itertools;
@@ -206,6 +207,30 @@
 
 impl<Out> Eq for Expected<Out> where Out: EnumSetType + Eq {}
 
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize)]
+pub struct DisabledString(ArcStr);
+
+impl DisabledString {
+    const FALSE: ArcStr = arcstr::literal!("@False");
+
+    pub fn new(inner: ArcStr) -> Self {
+        Self(if inner == Self::FALSE {
+            Self::FALSE
+        } else {
+            inner
+        })
+    }
+
+    pub fn value(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+
+impl Display for DisabledString {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(self.value(), f)
+    }
+}
 /// A completely flat representation of [`NormalizedPropertyValue`] suitable for byte
 /// representation in memory.
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Serialize)]