Implement WGSLLanguageExtension

naga/src/front/wgsl/mod.rs

@@ -20,6 +20,8 @@ pub use crate::front::wgsl::error::ParseError;
 use crate::front::wgsl::lower::Lowerer;
 use crate::Scalar;
 
+pub use crate::front::wgsl::parse::directive::language_extension::ImplementedLanguageExtension as WGSLLanguageExtension;
+
 pub struct Frontend {
     parser: Parser,
 }

naga/src/front/wgsl/parse/directive/language_extension.rs

@@ -41,7 +41,7 @@ impl LanguageExtension {
     /// 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) => match kind {},
+            Self::Implemented(kind) => kind.to_ident(),
             Self::Unimplemented(kind) => match kind {
                 UnimplementedLanguageExtension::ReadOnlyAndReadWriteStorageTextures => {
                     Self::READONLY_AND_READWRITE_STORAGE_TEXTURES
@@ -60,9 +60,25 @@ impl LanguageExtension {
     }
 }
 
-/// A variant of [`LanguageExtension::Implemented`].
+// A variant of [`LanguageExtension::Implemented`].
+/// Enum of all WGSL extensions that are implemented
+/// WGSL spec.: <https://www.w3.org/TR/WGSL/#language-extensions-sec>
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub(crate) enum ImplementedLanguageExtension {}
+pub enum ImplementedLanguageExtension {}
+
+impl ImplementedLanguageExtension {
+    const ALL: [ImplementedLanguageExtension; 0] = [];
+
+    /// Returns slice of all variants of [`ImplementedLanguageExtension`]
+    pub const fn all() -> &'static [Self] {
+        &Self::ALL
+    }
+
+    /// Maps this [`ImplementedLanguageExtension`] into the sentinel word associated with it in WGSL.
+    pub const fn to_ident(self) -> &'static str {
+        match self {}
+    }
+}
 
 /// A variant of [`LanguageExtension::Unimplemented`].
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]

wgpu/Cargo.toml

@@ -187,6 +187,7 @@ optional = true
 
 [dependencies]
 arrayvec.workspace = true
+bitflags.workspace = true
 document-features.workspace = true
 log.workspace = true
 parking_lot.workspace = true

wgpu/src/api/instance.rs

@@ -4,6 +4,23 @@ use crate::{dispatch::InstanceInterface, *};
 
 use std::{future::Future, sync::Arc};
 
+bitflags::bitflags! {
+    /// WGSL language extensions.
+    ///
+    /// WGSL spec.: <https://www.w3.org/TR/WGSL/#language-extensions-sec>
+    #[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Eq, Hash)]
+    pub struct WGSLLanguageFeatures: u32 {
+        /// <https://www.w3.org/TR/WGSL/#language_extension-readonly_and_readwrite_storage_textures>
+        const ReadOnlyAndReadWriteStorageTextures = 1 << 0;
+        /// <https://www.w3.org/TR/WGSL/#language_extension-packed_4x8_integer_dot_product>
+        const Packed4x8IntegerDotProduct = 1 << 1;
+        /// <https://www.w3.org/TR/WGSL/#language_extension-unrestricted_pointer_parameters>
+        const UnrestrictedPointerParameters = 1 << 2;
+        /// <https://www.w3.org/TR/WGSL/#language_extension-pointer_composite_access>
+        const PointerCompositeAccess = 1 << 3;
+    }
+}
+
 /// Context for all other wgpu objects. Instance of wgpu.
 ///
 /// This is the first thing you create when using wgpu.
@@ -395,4 +412,12 @@ impl Instance {
     pub fn generate_report(&self) -> Option<wgc::global::GlobalReport> {
         self.inner.as_core_opt().map(|ctx| ctx.generate_report())
     }
+
+    /// Returns set of supported WGSL language extensions supported by this instance
+    ///
+    /// <https://www.w3.org/TR/webgpu/#gpuwgsllanguagefeatures>
+    #[cfg(feature = "wgsl")]
+    pub fn wgsl_language_features(&self) -> WGSLLanguageFeatures {
+        self.inner.wgsl_language_features()
+    }
 }

wgpu/src/backend/webgpu.rs

@@ -1562,6 +1562,40 @@ impl dispatch::InstanceInterface for ContextWebGpu {
         // Devices are automatically polled.
         true
     }
+
+    #[cfg(feature = "wgsl")]
+    fn wgsl_language_features(&self) -> crate::WGSLLanguageFeatures {
+        let mut wgsl_language_features = crate::WGSLLanguageFeatures::empty();
+        if let Some(gpu) = &self.gpu {
+            gpu.wgsl_language_features()
+                .keys()
+                .into_iter()
+                .map(|wlf| wlf.expect("WGSLLanguageFeatures elements should be valid"))
+                .map(|wlf| {
+                    wlf.as_string()
+                        .expect("WGSLLanguageFeatures should be string set")
+                })
+                .filter_map(|wlf| match wlf.as_str() {
+                    "readonly_and_readwrite_storage_textures" => {
+                        Some(crate::WGSLLanguageFeatures::ReadOnlyAndReadWriteStorageTextures)
+                    }
+                    "packed_4x8_integer_dot_product" => {
+                        Some(crate::WGSLLanguageFeatures::Packed4x8IntegerDotProduct)
+                    }
+                    "unrestricted_pointer_parameters" => {
+                        Some(crate::WGSLLanguageFeatures::UnrestrictedPointerParameters)
+                    }
+                    "pointer_composite_access" => {
+                        Some(crate::WGSLLanguageFeatures::PointerCompositeAccess)
+                    }
+                    _ => None,
+                })
+                .for_each(|wlf| {
+                    wgsl_language_features |= wlf;
+                })
+        }
+        wgsl_language_features
+    }
 }
 
 impl Drop for ContextWebGpu {

wgpu/src/backend/wgpu_core.rs

@@ -851,6 +851,16 @@ impl dispatch::InstanceInterface for ContextWgpuCore {
             Err(err) => self.handle_error_fatal(err, "Instance::poll_all_devices"),
         }
     }
+
+    #[cfg(feature = "wgsl")]
+    fn wgsl_language_features(&self) -> crate::WGSLLanguageFeatures {
+        use wgc::naga::front::wgsl::WGSLLanguageExtension;
+        let wgsl_language_features = crate::WGSLLanguageFeatures::empty();
+        WGSLLanguageExtension::all()
+            .iter()
+            .for_each(|wle| match *wle {});
+        wgsl_language_features
+    }
 }
 
 impl dispatch::AdapterInterface for CoreAdapter {

wgpu/src/dispatch.rs

@@ -100,6 +100,9 @@ pub trait InstanceInterface: CommonTraits {
     ) -> Pin<Box<dyn RequestAdapterFuture>>;
 
     fn poll_all_devices(&self, force_wait: bool) -> bool;
+
+    #[cfg(feature = "wgsl")]
+    fn wgsl_language_features(&self) -> crate::WGSLLanguageFeatures;
 }
 
 pub trait AdapterInterface: CommonTraits {