Use a bitflags type for the WGSL front end's LanguageExtensions.

jimblandy · jimblandy · commit 301f3730869b · 2025-11-21T16:45:42.000-08:00
diff --git a/naga/src/front/wgsl/error.rs b/naga/src/front/wgsl/error.rs
@@ -7,9 +7,7 @@ use crate::proc::{Alignment, ConstantEvaluatorError, ResolveError};
 use crate::{Scalar, SourceLocation, Span};
 
 use super::parse::directive::enable_extension::EnableExtensions;
-use super::parse::directive::language_extension::{
-    LanguageExtension, UnimplementedLanguageExtension,
-};
+use super::parse::directive::language_extension::LanguageExtensions;
 use super::parse::lexer::Token;
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
@@ -381,7 +379,7 @@ pub(crate) enum Error<'a> {
         span: Span,
     },
     LanguageExtensionNotYetImplemented {
-        kind: UnimplementedLanguageExtension,
+        kind: LanguageExtensions,
         span: Span,
     },
     DiagnosticInvalidSeverity {
@@ -1234,7 +1232,7 @@ impl<'a> Error<'a> {
             Error::LanguageExtensionNotYetImplemented { kind, span } => ParseError {
                 message: format!(
                     "the `{}` language extension is not yet supported",
-                    LanguageExtension::Unimplemented(kind).to_ident()
+                    kind.to_ident()
                 ),
                 labels: vec![(span, "".into())],
                 notes: vec![format!(
@@ -1243,7 +1241,7 @@ impl<'a> Error<'a> {
                         "<https://github.com/gfx-rs/wgpu/issues/{}>, ",
                         "so they can prioritize it!"
                     ),
-                    kind.tracking_issue_num()
+                    kind.tracking_issue_num().unwrap(),
                 )],
             },
             Error::DiagnosticInvalidSeverity {
diff --git a/naga/src/front/wgsl/mod.rs b/naga/src/front/wgsl/mod.rs
@@ -12,11 +12,9 @@ mod parse;
 mod tests;
 
 pub use parse::directive::enable_extension::EnableExtensions;
+pub use parse::directive::language_extension::LanguageExtensions;
 
 pub use crate::front::wgsl::error::ParseError;
-pub use crate::front::wgsl::parse::directive::language_extension::{
-    ImplementedLanguageExtension, LanguageExtension, UnimplementedLanguageExtension,
-};
 pub use crate::front::wgsl::parse::Options;
 
 use alloc::boxed::Box;
diff --git a/naga/src/front/wgsl/parse/directive.rs b/naga/src/front/wgsl/parse/directive.rs
@@ -2,6 +2,59 @@
 //!
 //! See also <https://www.w3.org/TR/WGSL/#directives>.
 
+/// Define a bitflags type representing a set of extensions, with their source names.
+///
+/// This is used to define bitflags types for language and enable
+/// extensions.
+/// 
+/// An invocation of this macro defines a `bitflags` type that
+/// implements `Copy` and `Eq`, with methods `from_ident` and
+/// `to_ident` that convert to and from the WGSL source name for the
+/// extension.
+macro_rules! define_extensions {
+    {
+        $( #[ $( $meta:meta )* ] )*
+        pub struct $typename:ident: $type:ty
+        {
+            $(
+                $( #[ $inner:ident $( $args:tt )* ] )*
+                const $name:ident, $wgsl:literal = $value:expr ;
+            )*
+        }
+    } => {
+        bitflags::bitflags! {
+            $( #[ $( $meta )* ] )*
+            #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+            pub struct $typename: $type {
+                $(
+                    $( #[ $inner $( $args )* ] )*
+                    const $name = $value ;
+                )*
+            }
+        }
+
+        impl $typename {
+            pub fn from_ident(wgsl: &str) -> Option<Self> {
+                match wgsl {
+                    $(
+                        $wgsl => Some($typename :: $name),
+                    )*
+                    _ => None,
+                }
+            }
+
+            pub fn to_ident(self) -> &'static str {
+                match self {
+                    $(
+                        $typename :: $name => $wgsl,
+                    )*
+                    _ => unreachable!("should have exactly one extension bit set"),
+                }
+            }
+        }
+    }
+}
+
 pub mod enable_extension;
 pub(crate) mod language_extension;
 
diff --git a/naga/src/front/wgsl/parse/directive/enable_extension.rs b/naga/src/front/wgsl/parse/directive/enable_extension.rs
@@ -2,52 +2,7 @@
 //!
 //! The focal point of this module is the [`EnableExtensions`] bitflags type.
 
-macro_rules! define_enable_extensions {
-    {
-        $( #[ $( $meta:meta )* ] )*
-        pub struct $typename:ident: $type:ty
-        {
-            $(
-                $( #[ $inner:ident $( $args:tt )* ] )*
-                const $name:ident, $wgsl:literal = $value:expr ;
-            )*
-        }
-    } => {
-        bitflags::bitflags! {
-            $( #[ $( $meta )* ] )*
-            #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-            pub struct $typename: $type {
-                $(
-                    $( #[ $inner $( $args )* ] )*
-                    const $name = $value ;
-                )*
-            }
-        }
-
-        impl $typename {
-            pub fn from_ident(wgsl: &str) -> Option<Self> {
-                match wgsl {
-                    $(
-                        $wgsl => Some($typename :: $name),
-                    )*
-                    _ => None,
-                }
-            }
-
-            pub fn to_ident(self) -> &'static str {
-                match self {
-                    $(
-                        $typename :: $name => $wgsl,
-                    )*
-                    _ => unreachable!("should have exactly one extension bit set"),
-                }
-            }
-        }
-    }
-}
-
-
-define_enable_extensions! {
+define_extensions! {
     /// All enable extensions known to Naga.
     ///
     /// This includes extensions that Naga does not implement; the [`IMPLEMENTED`]
diff --git a/naga/src/front/wgsl/parse/directive/language_extension.rs b/naga/src/front/wgsl/parse/directive/language_extension.rs
@@ -2,113 +2,35 @@
 //!
 //! The focal point of this module is the [`LanguageExtension`] API.
 
-/// A language extension recognized by Naga, but not guaranteed to be present in all environments.
-///
-/// WGSL spec.: <https://www.w3.org/TR/WGSL/#language-extensions-sec>
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub enum LanguageExtension {
-    #[allow(unused)]
-    Implemented(ImplementedLanguageExtension),
-    Unimplemented(UnimplementedLanguageExtension),
-}
-
-impl LanguageExtension {
-    const READONLY_AND_READWRITE_STORAGE_TEXTURES: &'static str =
-        "readonly_and_readwrite_storage_textures";
-    const PACKED4X8_INTEGER_DOT_PRODUCT: &'static str = "packed_4x8_integer_dot_product";
-    const UNRESTRICTED_POINTER_PARAMETERS: &'static str = "unrestricted_pointer_parameters";
-    const POINTER_COMPOSITE_ACCESS: &'static str = "pointer_composite_access";
-
-    /// Convert from a sentinel word in WGSL into its associated [`LanguageExtension`], if possible.
-    pub fn from_ident(s: &str) -> Option<Self> {
-        Some(match s {
-            Self::READONLY_AND_READWRITE_STORAGE_TEXTURES => {
-                Self::Implemented(ImplementedLanguageExtension::ReadOnlyAndReadWriteStorageTextures)
-            }
-            Self::PACKED4X8_INTEGER_DOT_PRODUCT => {
-                Self::Implemented(ImplementedLanguageExtension::Packed4x8IntegerDotProduct)
-            }
-            Self::UNRESTRICTED_POINTER_PARAMETERS => {
-                Self::Unimplemented(UnimplementedLanguageExtension::UnrestrictedPointerParameters)
-            }
-            Self::POINTER_COMPOSITE_ACCESS => {
-                Self::Implemented(ImplementedLanguageExtension::PointerCompositeAccess)
-            }
-            _ => return None,
-        })
-    }
-
-    /// Maps this [`LanguageExtension`] into the sentinel word associated with it in WGSL.
-    pub const fn to_ident(self) -> &'static str {
-        match self {
-            Self::Implemented(kind) => kind.to_ident(),
-            Self::Unimplemented(kind) => match kind {
-                UnimplementedLanguageExtension::UnrestrictedPointerParameters => {
-                    Self::UNRESTRICTED_POINTER_PARAMETERS
-                }
-            },
-        }
+define_extensions! {
+    /// A language extension recognized by Naga, but not guaranteed to be present in all environments.
+    ///
+    /// WGSL spec.: <https://www.w3.org/TR/WGSL/#language-extensions-sec>
+    #[derive(Default)]
+    pub struct LanguageExtensions: u32 {
+        const READONLY_AND_READWRITE_STORAGE_TEXTURES, "readonly_and_readwrite_storage_textures" = 0x1;
+        const PACKED4X8_INTEGER_DOT_PRODUCT, "packed_4x8_integer_dot_product" = 0x2;
+        const UNRESTRICTED_POINTER_PARAMETERS, "unrestricted_pointer_parameters" = 0x4;
+        const POINTER_COMPOSITE_ACCESS, "pointer_composite_access" = 0x8;
     }
 }
 
-/// A variant of [`LanguageExtension::Implemented`].
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(test, derive(strum::VariantArray))]
-pub enum ImplementedLanguageExtension {
-    ReadOnlyAndReadWriteStorageTextures,
-    Packed4x8IntegerDotProduct,
-    PointerCompositeAccess,
-}
+impl LanguageExtensions {
+    pub const IMPLEMENTED: Self =
+        Self::empty()
+        .union(Self::READONLY_AND_READWRITE_STORAGE_TEXTURES)
+        .union(Self::PACKED4X8_INTEGER_DOT_PRODUCT)
+        .union(Self::POINTER_COMPOSITE_ACCESS);
 
-impl ImplementedLanguageExtension {
-    /// A slice of all variants of [`ImplementedLanguageExtension`].
-    pub const VARIANTS: &'static [Self] = &[
-        Self::ReadOnlyAndReadWriteStorageTextures,
-        Self::Packed4x8IntegerDotProduct,
-        Self::PointerCompositeAccess,
-    ];
+    pub const UNIMPLEMENTED: Self = Self::IMPLEMENTED.complement();
 
-    /// Returns slice of all variants of [`ImplementedLanguageExtension`].
-    pub const fn all() -> &'static [Self] {
-        Self::VARIANTS
-    }
-
-    /// Maps this [`ImplementedLanguageExtension`] into the sentinel word associated with it in WGSL.
-    pub const fn to_ident(self) -> &'static str {
+    pub(crate) const fn tracking_issue_num(self) -> Option<u16> {
         match self {
-            ImplementedLanguageExtension::ReadOnlyAndReadWriteStorageTextures => {
-                LanguageExtension::READONLY_AND_READWRITE_STORAGE_TEXTURES
-            }
-            ImplementedLanguageExtension::Packed4x8IntegerDotProduct => {
-                LanguageExtension::PACKED4X8_INTEGER_DOT_PRODUCT
-            }
-            ImplementedLanguageExtension::PointerCompositeAccess => {
-                LanguageExtension::POINTER_COMPOSITE_ACCESS
+            Self::UNRESTRICTED_POINTER_PARAMETERS => Some(5158),
+            other => {
+                assert!(Self::IMPLEMENTED.contains(other));
+                None
             }
         }
     }
 }
-
-#[test]
-/// Asserts that the manual implementation of VARIANTS is the same as the derived strum version would be
-/// while still allowing strum to be a dev-only dependency
-fn test_manual_variants_array_is_correct() {
-    assert_eq!(
-        <ImplementedLanguageExtension as strum::VariantArray>::VARIANTS,
-        ImplementedLanguageExtension::VARIANTS
-    );
-}
-
-/// A variant of [`LanguageExtension::Unimplemented`].
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub enum UnimplementedLanguageExtension {
-    UnrestrictedPointerParameters,
-}
-
-impl UnimplementedLanguageExtension {
-    pub(crate) const fn tracking_issue_num(self) -> u16 {
-        match self {
-            Self::UnrestrictedPointerParameters => 5158,
-        }
-    }
-}
diff --git a/naga/src/front/wgsl/parse/mod.rs b/naga/src/front/wgsl/parse/mod.rs
@@ -1,12 +1,12 @@
 use alloc::{boxed::Box, vec::Vec};
+use directive::language_extension::LanguageExtensions;
 
 use crate::diagnostic_filter::{
     self, DiagnosticFilter, DiagnosticFilterMap, DiagnosticFilterNode, FilterableTriggeringRule,
     ShouldConflictOnFullDuplicate, StandardFilterableTriggeringRule,
 };
 use crate::front::wgsl::error::{DiagnosticAttributeNotSupportedPosition, Error, ExpectedToken};
 use crate::front::wgsl::parse::directive::enable_extension::EnableExtensions;
-use crate::front::wgsl::parse::directive::language_extension::LanguageExtension;
 use crate::front::wgsl::parse::directive::DirectiveKind;
 use crate::front::wgsl::parse::lexer::{Lexer, Token};
 use crate::front::wgsl::parse::number::Number;
@@ -3246,22 +3246,16 @@ impl Parser {
                     }
                     DirectiveKind::Requires => {
                         self.directive_ident_list(&mut lexer, |ident, span| {
-                            match LanguageExtension::from_ident(ident) {
-                                Some(LanguageExtension::Implemented(_kind)) => {
-                                    // NOTE: No further validation is needed for an extension, so
-                                    // just throw parsed information away. If we ever want to apply
-                                    // what we've parsed to diagnostics, maybe we'll want to refer
-                                    // to enabled extensions later?
-                                    Ok(())
-                                }
-                                Some(LanguageExtension::Unimplemented(kind)) => {
-                                    Err(Box::new(Error::LanguageExtensionNotYetImplemented {
-                                        kind,
-                                        span,
-                                    }))
-                                }
-                                None => Err(Box::new(Error::UnknownLanguageExtension(span, ident))),
+                            let extension = LanguageExtensions::from_ident(ident)
+                                .ok_or_else(|| Error::UnknownLanguageExtension(span, ident))?;
+                            if !LanguageExtensions::IMPLEMENTED.contains(extension) {
+                                return Err(Box::new(Error::LanguageExtensionNotYetImplemented { kind: extension, span }));
                             }
+                            // NOTE: No further validation is needed for an extension, so
+                            // just throw parsed information away. If we ever want to apply
+                            // what we've parsed to diagnostics, maybe we'll want to refer
+                            // to enabled extensions later?
+                            Ok(())
                         })?;
                     }
                 }
