diag(wgsl-in): enable-extensions: let user choose "unrecognized" instead of "unsupported"

For WebGPU environments like Firefox, it's important to withhold
information that's not necessary for an app author using JS to know.
This prevents things like fingerprinting, and makes it easier for
uniform developer experience across implementations of WebGPU.

Our current diagnostic noting that an extension is unsupported is
helpful, but ultimately is a minor leak of information that WebGPU is
better without. Let WebGPU environments pick what approach they'd like
by adding a "treat missing capabilities as unknown" flag.

Author: ErichDonGubler

naga-cli/src/bin/naga.rs

@@ -1,4 +1,5 @@
 use anyhow::{anyhow, Context as _};
+use naga::front::wgsl::TreatMissingCapabiltiesAsUnknown;
 use std::fs;
 use std::{error::Error, fmt, io::Read, path::Path, str::FromStr};
 
@@ -144,6 +145,19 @@ struct Args {
     /// defines to be passed to the parser (only glsl is supported)
     #[argh(option, short = 'D')]
     defines: Vec<Defines>,
+
+    /// capabilities for parsing and validation.
+    ///
+    /// Can be a comma-separated list of capability names (e.g.,
+    /// "shader_float16,dual_source_blending"), a numeric bitflags value (e.g.,
+    /// "67108864"), the string "none", or the string "all".
+    #[argh(option, default = "CapabilitiesArg(naga::valid::Capabilities::all())")]
+    capabilities: CapabilitiesArg,
+
+    /// whether diagnostics should recognize enable-extensions whose capabilities are missing, or
+    /// pretend that such an extension is unknown.
+    #[argh(switch)]
+    treat_missing_capabilities_as_unknown: bool,
 }
 
 /// Newtype so we can implement [`FromStr`] for `BoundsCheckPolicy`.
@@ -350,7 +364,7 @@ struct Parameters<'a> {
     input_kind: Option<InputKind>,
     shader_stage: Option<ShaderStage>,
     defines: FastHashMap<String, String>,
-
+    treat_missing_capabilities_as_unknown: bool,
     /// We use this copy of `args.compact` to know whether we should pass the
     /// entrypoint to `process_overrides`, which will result in removal from
     /// the module of anything not reachable from that entry point.
@@ -503,6 +517,7 @@ fn run() -> anyhow::Result<()> {
     );
 
     params.compact = args.compact;
+    params.treat_missing_capabilities_as_unknown = args.treat_missing_capabilities_as_unknown;
 
     if args.bulk_validate {
         return bulk_validate(&args, &params);
@@ -680,7 +695,12 @@ fn parse_input(input_path: &Path, input: Vec<u8>, params: &Parameters) -> anyhow
         },
         InputKind::Wgsl => {
             let input = String::from_utf8(input)?;
-            let result = naga::front::wgsl::parse_str(&input);
+(??)            let options = naga::front::wgsl::Options {
+(??)                parse_doc_comments: false,
+(??)                capabilities: params.capabilities,
+(??)            };
+(??)            let mut frontend = naga::front::wgsl::Frontend::new_with_options(options);
+(??)            let result = frontend.parse(&input);
             match result {
                 Ok(v) => Parsed {
                     module: v,

naga-test/src/lib.rs

@@ -9,7 +9,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use naga::compact::KeepUnused;
+use naga::{compact::KeepUnused, front::wgsl::TreatMissingCapabiltiesAsUnknown};
 use ron::de;
 
 bitflags::bitflags! {
@@ -79,11 +79,15 @@ where
 #[serde(default)]
 pub struct WgslInParameters {
     pub parse_doc_comments: bool,
+    pub treat_missing_capabilities_as_unknown: bool,
 }
 impl From<&WgslInParameters> for naga::front::wgsl::Options {
     fn from(value: &WgslInParameters) -> Self {
         Self {
             parse_doc_comments: value.parse_doc_comments,
+            treat_missing_capabilities_as_unknown: TreatMissingCapabiltiesAsUnknown::from_bool(
+                value.treat_missing_capabilities_as_unknown,
+            ),
         }
     }
 }

naga/src/front/wgsl/error.rs

@@ -475,10 +475,14 @@ impl From<EnableExtensionNotAvailableError> for Error<'_> {
                     kind: extension,
                 }
             }
-            EnableExtensionNotAvailableErrorReason::NotSupported => {
-                Error::EnableExtensionNotSupported {
-                    span,
-                    kind: extension,
+            EnableExtensionNotAvailableErrorReason::NotSupported { treat_as_unknown } => {
+                if treat_as_unknown {
+                    Error::UnknownEnableExtension(span, extension.to_ident())
+                } else {
+                    Error::EnableExtensionNotSupported {
+                        span,
+                        kind: extension,
+                    }
                 }
             }
         }

naga/src/front/wgsl/mod.rs

@@ -12,7 +12,8 @@ mod parse;
 mod tests;
 
 pub use parse::directive::enable_extension::{
-    EnableExtension, ImplementedEnableExtension, UnimplementedEnableExtension,
+    EnableExtension, ImplementedEnableExtension, TreatMissingCapabiltiesAsUnknown,
+    UnimplementedEnableExtension,
 };
 
 pub use crate::front::wgsl::error::ParseError;

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

@@ -49,6 +49,7 @@ impl EnableExtensions {
         span: Span,
         extension: ImplementedEnableExtension,
         capabilities: Capabilities,
+        treat_missing_capabilities_as_unknown: TreatMissingCapabiltiesAsUnknown,
     ) -> core::result::Result<(), EnableExtensionNotAvailableError> {
         let field = match extension {
             ImplementedEnableExtension::WgpuMeshShader => &mut self.wgpu_mesh_shader,
@@ -69,10 +70,11 @@ impl EnableExtensions {
         // Check if the required capability is supported
         let required_capability = extension.capability();
         if !capabilities.contains(required_capability) {
+            let treat_as_unknown = treat_missing_capabilities_as_unknown.to_bool();
             return Err(EnableExtensionNotAvailableError {
                 extension,
                 span,
-                reason: EnableExtensionNotAvailableErrorReason::NotSupported,
+                reason: EnableExtensionNotAvailableErrorReason::NotSupported { treat_as_unknown },
             });
         }
 
@@ -128,7 +130,32 @@ pub struct EnableExtensionNotAvailableError {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EnableExtensionNotAvailableErrorReason {
     NotEnabled,
-    NotSupported,
+    NotSupported { treat_as_unknown: bool },
+}
+
+/// Whether calls to [`EnableExtensions::add`] should hide or inform the user of an unsupported
+/// capability behind an [`ImplementedEnableExtension`] when converted to an [`Error`].
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub enum TreatMissingCapabiltiesAsUnknown {
+    Yes,
+    #[default]
+    No,
+}
+
+impl TreatMissingCapabiltiesAsUnknown {
+    pub const fn to_bool(self) -> bool {
+        match self {
+            Self::Yes => true,
+            Self::No => false,
+        }
+    }
+
+    pub const fn from_bool(value: bool) -> Self {
+        match value {
+            true => Self::Yes,
+            false => Self::No,
+        }
+    }
 }
 
 /// An enable-extension not guaranteed to be present in all environments.

naga/src/front/wgsl/parse/mod.rs

@@ -6,7 +6,9 @@ use crate::diagnostic_filter::{
     ShouldConflictOnFullDuplicate, StandardFilterableTriggeringRule,
 };
 use crate::front::wgsl::error::{DiagnosticAttributeNotSupportedPosition, Error, ExpectedToken};
-use crate::front::wgsl::parse::directive::enable_extension::{EnableExtension, EnableExtensions};
+use crate::front::wgsl::parse::directive::enable_extension::{
+    self, EnableExtension, 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, TokenSpan};
@@ -275,13 +277,20 @@ impl<'a> BindingParser<'a> {
 pub struct Options {
     /// Controls whether the parser should parse doc comments.
     pub parse_doc_comments: bool,
+    /// Whether an unknown or unsupported diagnostic should be emitted for enable-extensions whose
+    /// capability is disabled.
+    pub treat_missing_capabilities_as_unknown: enable_extension::TreatMissingCapabiltiesAsUnknown,
+    /// Capabilities to enable during parsing.
+    pub capabilities: crate::valid::Capabilities,
 }
 
 impl Options {
     /// Creates a new [`Options`] without doc comments parsing.
     pub const fn new() -> Self {
         Options {
             parse_doc_comments: false,
+            treat_missing_capabilities_as_unknown:
+                enable_extension::TreatMissingCapabiltiesAsUnknown::No,
         }
     }
 }
@@ -2231,7 +2240,12 @@ impl Parser {
                                     }))
                                 }
                             };
-                            enable_extensions.add(span, extension, options.capabilities)?;
+                            enable_extensions.add(
+                                span,
+                                extension,
+                                options.capabilities,
+                                options.treat_missing_capabilities_as_unknown,
+                            )?;
                             Ok(())
                         })?;
                     }