DO NOT MERGE: yeet, fix it later

ErichDonGubler · ErichDonGubler · commit 41f2207ab598 · 2026-01-12T17:06:40.000-05:00
diff --git a/naga/src/front/wgsl/error.rs b/naga/src/front/wgsl/error.rs
@@ -3,10 +3,14 @@
 use crate::common::wgsl::TryToWgsl;
 use crate::diagnostic_filter::ConflictingDiagnosticRuleError;
 use crate::error::replace_control_chars;
+use crate::front::wgsl::parse::directive::enable_extension::NativeOnlyEnableExtensionError;
+use crate::front::wgsl::ImplementedEnableExtension;
 use crate::proc::{Alignment, ConstantEvaluatorError, ResolveError};
 use crate::{Scalar, SourceLocation, Span};
 
-use super::parse::directive::enable_extension::{EnableExtension, UnimplementedEnableExtension};
+use super::parse::directive::enable_extension::{
+    EnableExtension, NativeOnlyEnableExtensionErrorReason, UnimplementedEnableExtension,
+};
 use super::parse::directive::language_extension::{
     LanguageExtension, UnimplementedLanguageExtension,
 };
@@ -381,6 +385,10 @@ pub(crate) enum Error<'a> {
         kind: EnableExtension,
         span: Span,
     },
+    NativeOnlyEnableExtensionsNotAllowed {
+        kind: ImplementedEnableExtension,
+        span: Span,
+    },
     LanguageExtensionNotYetImplemented {
         kind: UnimplementedLanguageExtension,
         span: Span,
@@ -440,6 +448,35 @@ impl From<&'static str> for DiagnosticAttributeNotSupportedPosition {
     }
 }
 
+impl From<NativeOnlyEnableExtensionError> for Error<'_> {
+    fn from(value: NativeOnlyEnableExtensionError) -> Self {
+        let NativeOnlyEnableExtensionError {
+            span,
+            extension,
+            reason,
+        } = value;
+
+        match reason {
+            NativeOnlyEnableExtensionErrorReason::NotEnabled => Error::EnableExtensionNotEnabled {
+                span,
+                kind: extension.into(),
+            },
+            NativeOnlyEnableExtensionErrorReason::NotAllowed {
+                can_suggest_in_diagnostics,
+            } => {
+                if can_suggest_in_diagnostics {
+                    Error::NativeOnlyEnableExtensionsNotAllowed {
+                        span,
+                        kind: extension,
+                    }
+                } else {
+                    Error::UnknownEnableExtension(span, todo!())
+                }
+            }
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct AutoConversionError {
     pub dest_span: Span,
@@ -1221,6 +1258,44 @@ impl<'a> Error<'a> {
                     )
                     .into(),
                 )],
+                notes: if let EnableExtension::Unimplemented(kind) = kind {
+                    vec![format!(
+                        concat!(
+                            "This \"Enable Extension\" is not yet implemented. ",
+                            "Let Naga maintainers know that you ran into this at ",
+                            "<https://github.com/gfx-rs/wgpu/issues/{}>, ",
+                            "so they can prioritize it!"
+                        ),
+                        kind.tracking_issue_num()
+                    )]
+                } else {
+                    vec![
+                        format!(
+                            concat!(
+                                "You can enable this extension by adding `enable {};` ",
+                                "at the top of the shader, before any other items."
+                            ),
+                            kind.to_ident()
+                        ),
+                    ]
+                },
+            },
+            Error::NativeOnlyEnableExtensionsNotAllowed { kind, span } => ParseError {
+                message: format!(
+                    "the `{}` enable extension is not allowed in the current environment",
+                    kind.to_ident()
+                ),
+                labels: vec![(
+                    span,
+                    format!(
+                        concat!(
+                            "the `{}` \"Enable Extension\" is needed for this functionality, ",
+                            "but it is not currently enabled."
+                        ),
+                        kind.to_ident()
+                    )
+                    .into(),
+                )],
                 notes: if let EnableExtension::Unimplemented(kind) = kind {
                     vec![format!(
                         concat!(
diff --git a/naga/src/front/wgsl/parse/directive/enable_extension.rs b/naga/src/front/wgsl/parse/directive/enable_extension.rs
@@ -17,23 +17,23 @@ pub struct EnableExtensions {
     /// Whether `enable clip_distances;` was written earlier in the shader module.
     clip_distances: bool,
     /// Native-only extensions.
-    wgpu: NativeOnly<WgpuEnableExtensions>,
+    native_only: NativeOnly<NativeOnlyEnableExtensions>,
 }
 
 impl EnableExtensions {
     pub(crate) const fn empty(native_only: NativeOnly<()>) -> Self {
         // TODO: It'd be nice to use a `const` `map` helper here, once
         // <https://github.com/rust-lang/rust/issues/73255> has landed.
-        let wgpu = match native_only {
+        let native_only = match native_only {
             NativeOnly::NotAllowed {
                 can_suggest_in_diagnostics,
             } => NativeOnly::NotAllowed {
                 can_suggest_in_diagnostics,
             },
-            NativeOnly::Allowed(()) => NativeOnly::Allowed(WgpuEnableExtensions::empty()),
+            NativeOnly::Allowed(()) => NativeOnly::Allowed(NativeOnlyEnableExtensions::empty()),
         };
         Self {
-            wgpu,
+            native_only,
             f16: false,
             dual_source_blending: false,
             clip_distances: false,
@@ -45,18 +45,18 @@ impl EnableExtensions {
         &mut self,
         span: Span,
         ext: ImplementedEnableExtension,
-    ) -> core::result::Result<(), EnableExtensionNotAvailableError> {
+    ) -> core::result::Result<(), NativeOnlyEnableExtensionError> {
         macro_rules! check_wgpu {
             ($f:expr) => {{
-                let f: fn(&mut WgpuEnableExtensions) -> &mut bool = $f;
-                match &mut self.wgpu {
+                let f: fn(&mut NativeOnlyEnableExtensions) -> &mut bool = $f;
+                match &mut self.native_only {
                     &mut NativeOnly::Allowed(ref mut wgpu) => Ok(f(wgpu)),
                     &mut NativeOnly::NotAllowed {
                         can_suggest_in_diagnostics,
-                    } => Err(EnableExtensionNotAvailableError {
+                    } => Err(NativeOnlyEnableExtensionError {
                         span,
                         extension: ext,
-                        reason: EnableExtensionNotAvailableErrorReason::NotAllowed {
+                        reason: NativeOnlyEnableExtensionErrorReason::NotAllowed {
                             can_suggest_in_diagnostics,
                         },
                     }),
@@ -65,17 +65,17 @@ impl EnableExtensions {
         }
         let field = match ext {
             ImplementedEnableExtension::WgpuMeshShader => {
-                check_wgpu!(|wgpu| &mut wgpu.mesh_shader)?
+                check_wgpu!(|no| &mut no.wgpu_mesh_shader)?
             }
-            ImplementedEnableExtension::WgpuRayQuery => check_wgpu!(|wgpu| &mut wgpu.ray_query)?,
+            ImplementedEnableExtension::WgpuRayQuery => check_wgpu!(|no| &mut no.wgpu_ray_query)?,
             ImplementedEnableExtension::WgpuRayQueryVertexReturn => {
-                check_wgpu!(|wgpu| &mut wgpu.ray_query_vertex_return)?
+                check_wgpu!(|no| &mut no.wgpu_ray_query_vertex_return)?
             }
             ImplementedEnableExtension::DualSourceBlending => &mut self.dual_source_blending,
             ImplementedEnableExtension::F16 => &mut self.f16,
             ImplementedEnableExtension::ClipDistances => &mut self.clip_distances,
             ImplementedEnableExtension::WgpuCooperativeMatrix => {
-                check_wgpu!(|wgpu| &mut wgpu.cooperative_matrix)?
+                check_wgpu!(|no| &mut no.wgpu_cooperative_matrix)?
             }
         };
         *field = true;
@@ -88,41 +88,41 @@ impl EnableExtensions {
         &self,
         span: Span,
         extension: ImplementedEnableExtension,
-    ) -> core::result::Result<(), EnableExtensionNotAvailableError> {
-        let check_wgpu = |f: fn(&WgpuEnableExtensions) -> bool| match &self.wgpu {
+    ) -> core::result::Result<(), NativeOnlyEnableExtensionError> {
+        let check_wgpu = |f: fn(&NativeOnlyEnableExtensions) -> bool| match &self.native_only {
             &NativeOnly::Allowed(ref wgpu) => Ok(f(wgpu)),
             &NativeOnly::NotAllowed {
                 can_suggest_in_diagnostics,
-            } => Err(EnableExtensionNotAvailableError {
+            } => Err(NativeOnlyEnableExtensionError {
                 span,
                 extension,
-                reason: EnableExtensionNotAvailableErrorReason::NotAllowed {
+                reason: NativeOnlyEnableExtensionErrorReason::NotAllowed {
                     can_suggest_in_diagnostics,
                 },
             }),
         };
 
         let is_enabled = match extension {
-            ImplementedEnableExtension::WgpuMeshShader => check_wgpu(|wgpu| wgpu.mesh_shader)?,
-            ImplementedEnableExtension::WgpuRayQuery => check_wgpu(|wgpu| wgpu.ray_query)?,
+            ImplementedEnableExtension::WgpuMeshShader => check_wgpu(|no| no.wgpu_mesh_shader)?,
+            ImplementedEnableExtension::WgpuRayQuery => check_wgpu(|no| no.wgpu_ray_query)?,
             ImplementedEnableExtension::WgpuRayQueryVertexReturn => {
-                check_wgpu(|wgpu| wgpu.ray_query_vertex_return)?
+                check_wgpu(|no| no.wgpu_ray_query_vertex_return)?
             }
             ImplementedEnableExtension::DualSourceBlending => self.dual_source_blending,
             ImplementedEnableExtension::F16 => self.f16,
             ImplementedEnableExtension::ClipDistances => self.clip_distances,
             ImplementedEnableExtension::WgpuCooperativeMatrix => {
-                check_wgpu(|wgpu| wgpu.cooperative_matrix)?
+                check_wgpu(|no| no.wgpu_cooperative_matrix)?
             }
         };
 
         if is_enabled {
             Ok(())
         } else {
-            Err(EnableExtensionNotAvailableError {
+            Err(NativeOnlyEnableExtensionError {
                 span,
                 extension,
-                reason: EnableExtensionNotAvailableErrorReason::NotEnabled,
+                reason: NativeOnlyEnableExtensionErrorReason::NotEnabled,
             })
         }
     }
@@ -174,46 +174,50 @@ impl<T> Default for NativeOnly<T> {
 
 /// Native-only extensions under [`EnableExtensions::wgpu`].
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct WgpuEnableExtensions {
+pub struct NativeOnlyEnableExtensions {
     /// Whether `enable wgpu_mesh_shader;` was written earlier in the shader module.
-    mesh_shader: bool,
+    wgpu_mesh_shader: bool,
     /// Whether `enable wgpu_ray_query;` was written earlier in the shader module.
-    ray_query: bool,
+    wgpu_ray_query: bool,
     /// Whether `enable wgpu_ray_query_vertex_return;` was written earlier in the shader module.
-    ray_query_vertex_return: bool,
+    wgpu_ray_query_vertex_return: bool,
     /// Whether `enable wgpu_cooperative_matrix;` was written earlier in the shader module.
-    cooperative_matrix: bool,
+    wgpu_cooperative_matrix: bool,
 }
 
-impl WgpuEnableExtensions {
+impl NativeOnlyEnableExtensions {
     pub(crate) const fn empty() -> Self {
         Self {
-            mesh_shader: false,
-            ray_query: false,
-            ray_query_vertex_return: false,
-            cooperative_matrix: false,
+            wgpu_mesh_shader: false,
+            wgpu_ray_query: false,
+            wgpu_ray_query_vertex_return: false,
+            wgpu_cooperative_matrix: false,
         }
     }
 }
 
-impl Default for WgpuEnableExtensions {
+impl Default for NativeOnlyEnableExtensions {
     fn default() -> Self {
         Self::empty()
     }
 }
 
 /// An error returned by [`EnableExtensions::contains`].
 #[derive(Clone, Debug)]
-pub struct EnableExtensionNotAvailableError {
-    span: Span,
-    extension: ImplementedEnableExtension,
-    reason: EnableExtensionNotAvailableErrorReason,
+pub struct NativeOnlyEnableExtensionError {
+    pub span: Span,
+    pub extension: ImplementedEnableExtension,
+    pub reason: NativeOnlyEnableExtensionErrorReason,
 }
 
 /// An [`EnableExtensionNotAvailableError::reason`].
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub enum EnableExtensionNotAvailableErrorReason {
+pub enum NativeOnlyEnableExtensionErrorReason {
+    /// [`EnableExtensions::check`] was called, and only failed because the user didn't write
+    /// `enable <extension>;`.
     NotEnabled,
+    /// [`EnableExtensions::check`] or `[EnableExtensions::enable]` was called for an extension
+    /// not allowed in the current environment.
     NotAllowed { can_suggest_in_diagnostics: bool },
 }
 
diff --git a/naga/src/front/wgsl/parse/mod.rs b/naga/src/front/wgsl/parse/mod.rs
@@ -223,15 +223,9 @@ impl<'a> BindingParser<'a> {
                 self.invariant.set(true, name_span)?;
             }
             "blend_src" => {
-                if !lexer
+                lexer
                     .enable_extensions
-                    .check(ImplementedEnableExtension::DualSourceBlending)
-                {
-                    return Err(Box::new(Error::EnableExtensionNotEnabled {
-                        span: name_span,
-                        kind: ImplementedEnableExtension::DualSourceBlending.into(),
-                    }));
-                }
+                    .check(name_span, ImplementedEnableExtension::DualSourceBlending)?;
 
                 lexer.expect(Token::Paren('('))?;
                 self.blend_src
@@ -240,15 +234,9 @@ impl<'a> BindingParser<'a> {
                 lexer.expect(Token::Paren(')'))?;
             }
             "per_primitive" => {
-                if !lexer
+                lexer
                     .enable_extensions
-                    .check(ImplementedEnableExtension::WgpuMeshShader)
-                {
-                    return Err(Box::new(Error::EnableExtensionNotEnabled {
-                        span: name_span,
-                        kind: ImplementedEnableExtension::WgpuMeshShader.into(),
-                    }));
-                }
+                    .check(name_span, ImplementedEnableExtension::WgpuMeshShader)?;
                 self.per_primitive.set((), name_span)?;
             }
             _ => return Err(Box::new(Error::UnknownAttribute(name_span))),
@@ -899,12 +887,7 @@ impl Parser {
                 let num = res.map_err(|err| Error::BadNumber(span, err))?;
 
                 if let Some(enable_extension) = num.requires_enable_extension() {
-                    if !lexer.enable_extensions.check(enable_extension) {
-                        return Err(Box::new(Error::EnableExtensionNotEnabled {
-                            kind: enable_extension.into(),
-                            span,
-                        }));
-                    }
+                    lexer.enable_extensions.check(span, enable_extension)?
                 }
 
                 ast::Expression::Literal(ast::Literal::Number(num))
