WIP: feat!: split MacOs into MacOs{Arm,Intel}

Author: ErichDonGubler

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

@@ -845,12 +845,19 @@ where
                     debug_assert!(!by_environment.is_empty());
                     for (environment, t) in by_environment {
                         let environment = {
-                            let os_str = match environment {
-                                Environment::Windows => "win",
-                                Environment::Linux => "linux",
-                                Environment::MacOs => "mac",
+                            let (os, processor) = match environment {
+                                Environment::Windows => ("win", None),
+                                Environment::Linux => ("linux", None),
+                                Environment::MacOsIntel => ("mac", Some("x86_64")),
+                                Environment::MacOsArm => ("mac", Some("aarch64")),
                             };
-                            make_lazy_format!(|f| write!(f, "os == {os_str:?}"))
+                            make_lazy_format!(|f| {
+                                write!(f, "os == {os:?}")?;
+                                if let Some(processor) = processor {
+                                    write!(f, "and processor = {processor:?}")?;
+                                }
+                                Ok(())
+                            })
                         };
                         match t {
                             MaybeCollapsed::Collapsed(t) => {

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

@@ -7,6 +7,7 @@
 use enum_map::Enum;
 use exhaust::Exhaust;
 use serde::Serialize;
+use whippit::reexport::chumsky::{error::Rich, input::Emitter, span::SimpleSpan};
 
 /// The strict subset of WPT property conditionals that can be handled with `moz-webgpu-cts`.
 ///
@@ -27,7 +28,8 @@ pub struct Applicability {
 pub enum Environment {
     Windows,
     Linux,
-    MacOs,
+    MacOsIntel,
+    MacOsArm,
 }
 
 /// The subset of browser build profiles can be handled by `moz-webgpu-cts`. Part of
@@ -40,3 +42,254 @@ pub enum BuildProfile {
     Debug,
     Optimized,
 }
+
+impl Environment {
+    fn os(self) -> Os {
+        match self {
+            Self::Windows => Os::Windows,
+            Self::Linux => Os::Linux,
+            Self::MacOsIntel => Os::MacOs,
+            Self::MacOsArm => Os::MacOs,
+        }
+    }
+
+    fn processor(self) -> Option<Processor> {
+        match self {
+            Self::Windows | Self::Linux => None,
+            Self::MacOsIntel => Some(Processor::X86_64),
+            Self::MacOsArm => Some(Processor::Arm),
+        }
+    }
+
+    fn from_mac_os(processor: Processor) -> Self {
+        match processor {
+            Processor::X86_64 => Self::MacOsIntel,
+            Processor::Arm => Self::MacOsArm,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Processor {
+    X86_64,
+    Arm,
+}
+
+impl Processor {
+    pub fn from_ident(s: &str) -> Option<Self> {
+        match s {
+            "x86_64" => Some(Self::X86_64),
+            "aarch64" => Some(Self::Arm),
+            _ => None,
+        }
+    }
+
+    pub fn to_ident(&self) -> &'static str {
+        match self {
+            Self::X86_64 => "x86_64",
+            Self::Arm => "aarch64",
+        }
+    }
+}
+
+// TODO: rename `Environment` to `Environment`
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Os {
+    Linux,
+    Windows,
+    MacOs,
+}
+
+impl Os {
+    pub fn from_ident(s: &str) -> Option<Self> {
+        match s {
+            "linux" => Some(Self::Linux),
+            "win" => Some(Self::Windows),
+            "mac" => Some(Self::MacOs),
+            _ => None,
+        }
+    }
+
+    pub fn to_ident(&self) -> &'static str {
+        match self {
+            Self::Linux => "linux",
+            Self::Windows => "win",
+            Self::MacOs => "mac",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum ApplicabilityRule {
+    Os(Os),
+    Processor(Processor),
+    Debug { inverted: bool },
+}
+
+enum IncompletePlatform {
+    UnknownProcessor {
+        span: SimpleSpan,
+        processor: Processor,
+    },
+    MacOs {
+        span: SimpleSpan,
+    },
+}
+
+enum EnvironmentMatcher {
+    Finalized {
+        environment: Environment,
+        os_span: SimpleSpan,
+        processor_span: Option<SimpleSpan>,
+    },
+    Incomplete(IncompletePlatform),
+}
+
+enum ApplicabilityParseError {
+    ProcessorFoundAfterIndependentOs {
+        os: Os,
+        os_span: SimpleSpan,
+        processor: Processor,
+        processor_span: SimpleSpan,
+    },
+}
+
+struct ApplicabilityBuilder {
+    environment: Option<EnvironmentMatcher>,
+    build_profile: Option<(SimpleSpan, BuildProfile)>,
+}
+
+impl ApplicabilityBuilder {
+    pub fn handle_rule<'a>(
+        &mut self,
+        rule: ApplicabilityRule,
+        span: SimpleSpan,
+        emitter: &mut Emitter<Rich<'_, char>>,
+    ) -> Result<(), ()> {
+        let Self {
+            environment: platform,
+            build_profile,
+        } = &*self;
+        let already_got_os_err = |prev_span, span| todo!();
+        let processor_with_independent_os_err =
+            |os: Os, os_span, processor: Processor, processor_span| {
+                todo!(
+                    "`processor` comparison is not allowed when `os == {:?}`",
+                    os.to_ident()
+                )
+            };
+        let check_for_dupe_processors = |first, first_span, second, second_span| {
+            if first == second {
+                todo!("emit warning")
+            } else {
+                todo!("contradictory `processor` statements")
+            }
+        };
+        match rule {
+            ApplicabilityRule::Os(name) => {
+                self.environment = Some(match (platform, name) {
+                    (
+                        Some(EnvironmentMatcher::Finalized {
+                            os_span: prev_span, ..
+                        }),
+                        _,
+                    )
+                    | (
+                        Some(EnvironmentMatcher::Incomplete(IncompletePlatform::MacOs {
+                            span: prev_span,
+                        })),
+                        _,
+                    ) => return already_got_os_err(prev_span, span),
+                    (None, platform @ (Os::Linux | Os::Windows)) => EnvironmentMatcher::Finalized {
+                        environment: match platform {
+                            Os::Linux => Environment::Linux,
+                            Os::Windows => Environment::Windows,
+                            Os::MacOs => unreachable!(),
+                        },
+                        os_span: span,
+                        processor_span: None,
+                    },
+                    (None, Os::MacOs) => todo!(),
+                    (
+                        Some(EnvironmentMatcher::Incomplete(
+                            IncompletePlatform::UnknownProcessor {
+                                span: processor_span,
+                                processor,
+                            },
+                        )),
+                        Os::MacOs,
+                    ) => EnvironmentMatcher::Finalized {
+                        environment: match processor {
+                            Processor::X86_64 => Environment::MacOsIntel,
+                            Processor::Arm => Environment::MacOsArm,
+                        },
+                        os_span: span,
+                        processor_span: Some(*processor_span),
+                    },
+                    (
+                        Some(EnvironmentMatcher::Incomplete(
+                            IncompletePlatform::UnknownProcessor {
+                                span: processor_span,
+                                processor,
+                            },
+                        )),
+                        os @ (Os::Linux | Os::Windows),
+                    ) => {
+                        return processor_with_independent_os_err(
+                            os,
+                            span,
+                            *processor,
+                            *processor_span,
+                        )
+                    }
+                })
+            }
+            ApplicabilityRule::Processor(processor) => {
+                self.environment = Some(match platform {
+                    Some(EnvironmentMatcher::Finalized {
+                        environment: platform,
+                        os_span,
+                        processor_span,
+                    }) => {
+                        if let Some(processor_span) = processor_span {
+                            check_for_dupe_processors(
+                                platform.processor().unwrap(),
+                                *processor_span,
+                                processor,
+                                span,
+                            )?;
+                            return Ok(());
+                        } else {
+                            return processor_with_independent_os_err(
+                                platform.os(),
+                                *os_span,
+                                processor,
+                                span,
+                            );
+                        }
+                    }
+                    Some(EnvironmentMatcher::Incomplete(IncompletePlatform::MacOs {
+                        span: os_span,
+                    })) => EnvironmentMatcher::Finalized {
+                        environment: Environment::from_mac_os(processor),
+                        os_span: *os_span,
+                        processor_span: Some(span),
+                    },
+                    Some(EnvironmentMatcher::Incomplete(
+                        IncompletePlatform::UnknownProcessor {
+                            span: prev_span,
+                            processor: prev_processor,
+                        },
+                    )) => {
+                        check_for_dupe_processors(*prev_processor, *prev_span, processor, span)?;
+                        return Ok(());
+                    }
+                    None => todo!(),
+                })
+            }
+            ApplicabilityRule::Debug { inverted } => todo!(),
+        }
+        return Ok(());
+    }
+    pub fn into_applicability(self) -> Result<Applicability, ()> {}
+}