[naga] constants aren't named expressions

naga/src/back/glsl/mod.rs

@@ -64,7 +64,7 @@ use thiserror::Error;
 use crate::{
     back::{self, Baked},
     common,
-    proc::{self, ExpressionKindTracker, NameKey},
+    proc::{self, NameKey},
     valid, Handle, ShaderStage, TypeInner,
 };
 use features::FeaturesManager;
@@ -1678,7 +1678,6 @@ impl<'a, W: Write> Writer<'a, W> {
             info,
             expressions: &func.expressions,
             named_expressions: &func.named_expressions,
-            expr_kind_tracker: ExpressionKindTracker::from_arena(&func.expressions),
         };
 
         self.named_expressions.clear();

naga/src/back/hlsl/writer.rs

@@ -17,7 +17,7 @@ use super::{
 use crate::{
     back::{self, Baked},
     common,
-    proc::{self, index, ExpressionKindTracker, NameKey},
+    proc::{self, index, NameKey},
     valid, Handle, Module, RayQueryFunction, Scalar, ScalarKind, ShaderStage, TypeInner,
 };
 
@@ -426,7 +426,6 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                 info,
                 expressions: &function.expressions,
                 named_expressions: &function.named_expressions,
-                expr_kind_tracker: ExpressionKindTracker::from_arena(&function.expressions),
             };
             let name = self.names[&NameKey::Function(handle)].clone();
 
@@ -467,7 +466,6 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                 info,
                 expressions: &ep.function.expressions,
                 named_expressions: &ep.function.named_expressions,
-                expr_kind_tracker: ExpressionKindTracker::from_arena(&ep.function.expressions),
             };
 
             self.write_wrapped_functions(module, &ctx)?;

naga/src/back/mod.rs

@@ -11,8 +11,6 @@ Backend functions that export shader [`Module`](super::Module)s into binary and
 
 use alloc::string::String;
 
-use crate::proc::ExpressionKindTracker;
-
 #[cfg(dot_out)]
 pub mod dot;
 #[cfg(glsl_out)]
@@ -128,8 +126,6 @@ pub struct FunctionCtx<'a> {
     pub expressions: &'a crate::Arena<crate::Expression>,
     /// Map of expressions that have associated variable names
     pub named_expressions: &'a crate::NamedExpressions,
-    /// For constness checks
-    pub expr_kind_tracker: ExpressionKindTracker,
 }
 
 impl FunctionCtx<'_> {

naga/src/back/msl/writer.rs

@@ -17,7 +17,7 @@ use crate::{
     arena::{Handle, HandleSet},
     back::{self, Baked},
     common,
-    proc::{self, index, ExpressionKindTracker, NameKey, TypeResolution},
+    proc::{self, index, NameKey, TypeResolution},
     valid, FastHashMap, FastHashSet,
 };
 
@@ -5572,7 +5572,6 @@ template <typename A>
                 info: &mod_info[fun_handle],
                 expressions: &fun.expressions,
                 named_expressions: &fun.named_expressions,
-                expr_kind_tracker: ExpressionKindTracker::from_arena(&fun.expressions),
             };
 
             writeln!(self.out)?;
@@ -5729,7 +5728,6 @@ template <typename A>
                 info: fun_info,
                 expressions: &fun.expressions,
                 named_expressions: &fun.named_expressions,
-                expr_kind_tracker: ExpressionKindTracker::from_arena(&fun.expressions),
             };
 
             self.write_wrapped_functions(module, &ctx)?;

naga/src/back/wgsl/writer.rs

@@ -16,7 +16,7 @@ use crate::{
         self,
         wgsl::{address_space_str, ToWgsl, TryToWgsl},
     },
-    proc::{self, ExpressionKindTracker, NameKey},
+    proc::{self, NameKey},
     valid, Handle, Module, ShaderStage, TypeInner,
 };
 
@@ -178,7 +178,6 @@ impl<W: Write> Writer<W> {
                 info: fun_info,
                 expressions: &function.expressions,
                 named_expressions: &function.named_expressions,
-                expr_kind_tracker: ExpressionKindTracker::from_arena(&function.expressions),
             };
 
             // Write the function
@@ -207,7 +206,6 @@ impl<W: Write> Writer<W> {
                 info: info.get_entry_point(index),
                 expressions: &ep.function.expressions,
                 named_expressions: &ep.function.named_expressions,
-                expr_kind_tracker: ExpressionKindTracker::from_arena(&ep.function.expressions),
             };
             self.write_function(module, &ep.function, &func_ctx)?;
 
@@ -1029,14 +1027,8 @@ impl<W: Write> Writer<W> {
         func_ctx: &back::FunctionCtx,
         name: &str,
     ) -> BackendResult {
-        // Some functions are marked as const, but are not yet implemented as constant expression
-        let quantifier = if func_ctx.expr_kind_tracker.is_impl_const(handle) {
-            "const"
-        } else {
-            "let"
-        };
         // Write variable name
-        write!(self.out, "{quantifier} {name}")?;
+        write!(self.out, "let {name}")?;
         if self.flags.contains(WriterFlags::EXPLICIT_TYPES) {
             write!(self.out, ": ")?;
             let ty = &func_ctx.info[handle].ty;

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

@@ -1604,7 +1604,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                         c.ty.map(|ast| self.resolve_ast_type(ast, &mut ectx.as_const()))
                             .transpose()?;
 
-                    let (ty, init) = self.type_and_init(
+                    let (_ty, init) = self.type_and_init(
                         c.name,
                         Some(c.init),
                         explicit_ty,
@@ -1616,13 +1616,6 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                     block.extend(emitter.finish(&ctx.function.expressions));
                     ctx.local_table
                         .insert(c.handle, Declared::Const(Typed::Plain(init)));
-                    // Only add constants of non-abstract types to the named expressions
-                    // to prevent abstract types ending up in the IR.
-                    let is_abstract = ctx.module.types[ty].inner.is_abstract(&ctx.module.types);
-                    if !is_abstract {
-                        ctx.named_expressions
-                            .insert(init, (c.name.name.to_string(), c.name.span));
-                    }
                     return Ok(());
                 }
             },

naga/src/proc/constant_evaluator.rs

@@ -363,8 +363,6 @@ struct FunctionLocalData<'a> {
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 pub enum ExpressionKind {
-    /// If const is also implemented as const
-    ImplConst,
     Const,
     Override,
     Runtime,
@@ -392,21 +390,13 @@ impl ExpressionKindTracker {
     }
 
     pub fn is_const(&self, h: Handle<Expression>) -> bool {
-        matches!(
-            self.type_of(h),
-            ExpressionKind::Const | ExpressionKind::ImplConst
-        )
-    }
-
-    /// Returns `true` if naga can also evaluate expression as const
-    pub fn is_impl_const(&self, h: Handle<Expression>) -> bool {
-        matches!(self.type_of(h), ExpressionKind::ImplConst)
+        matches!(self.type_of(h), ExpressionKind::Const)
     }
 
     pub fn is_const_or_override(&self, h: Handle<Expression>) -> bool {
         matches!(
             self.type_of(h),
-            ExpressionKind::Const | ExpressionKind::Override | ExpressionKind::ImplConst
+            ExpressionKind::Const | ExpressionKind::Override
         )
     }
 
@@ -427,14 +417,13 @@ impl ExpressionKindTracker {
     }
 
     fn type_of_with_expr(&self, expr: &Expression) -> ExpressionKind {
-        use crate::MathFunction as Mf;
         match *expr {
             Expression::Literal(_) | Expression::ZeroValue(_) | Expression::Constant(_) => {
-                ExpressionKind::ImplConst
+                ExpressionKind::Const
             }
             Expression::Override(_) => ExpressionKind::Override,
             Expression::Compose { ref components, .. } => {
-                let mut expr_type = ExpressionKind::ImplConst;
+                let mut expr_type = ExpressionKind::Const;
                 for component in components {
                     expr_type = expr_type.max(self.type_of(*component))
                 }
@@ -445,16 +434,13 @@ impl ExpressionKindTracker {
             Expression::Access { base, index } => self.type_of(base).max(self.type_of(index)),
             Expression::Swizzle { vector, .. } => self.type_of(vector),
             Expression::Unary { expr, .. } => self.type_of(expr),
-            Expression::Binary { left, right, .. } => self
-                .type_of(left)
-                .max(self.type_of(right))
-                .max(ExpressionKind::Const),
+            Expression::Binary { left, right, .. } => self.type_of(left).max(self.type_of(right)),
             Expression::Math {
-                fun,
                 arg,
                 arg1,
                 arg2,
                 arg3,
+                ..
             } => self
                 .type_of(arg)
                 .max(
@@ -468,42 +454,16 @@ impl ExpressionKindTracker {
                 .max(
                     arg3.map(|arg| self.type_of(arg))
                         .unwrap_or(ExpressionKind::Const),
-                )
-                .max(
-                    if matches!(
-                        fun,
-                        Mf::Dot
-                            | Mf::Outer
-                            | Mf::Distance
-                            | Mf::Length
-                            | Mf::Normalize
-                            | Mf::FaceForward
-                            | Mf::Reflect
-                            | Mf::Refract
-                            | Mf::Ldexp
-                            | Mf::Modf
-                            | Mf::Mix
-                            | Mf::Frexp
-                    ) {
-                        ExpressionKind::Const
-                    } else {
-                        ExpressionKind::ImplConst
-                    },
                 ),
-            Expression::As { convert, expr, .. } => self.type_of(expr).max(if convert.is_some() {
-                ExpressionKind::ImplConst
-            } else {
-                ExpressionKind::Const
-            }),
+            Expression::As { expr, .. } => self.type_of(expr),
             Expression::Select {
                 condition,
                 accept,
                 reject,
             } => self
                 .type_of(condition)
                 .max(self.type_of(accept))
-                .max(self.type_of(reject))
-                .max(ExpressionKind::Const),
+                .max(self.type_of(reject)),
             Expression::Relational { argument, .. } => self.type_of(argument),
             Expression::ArrayLength(expr) => self.type_of(expr),
             _ => ExpressionKind::Runtime,
@@ -797,7 +757,6 @@ impl<'a> ConstantEvaluator<'a> {
         span: Span,
     ) -> Result<Handle<Expression>, ConstantEvaluatorError> {
         match self.expression_kind_tracker.type_of_with_expr(&expr) {
-            ExpressionKind::ImplConst => self.try_eval_and_append_impl(&expr, span),
             ExpressionKind::Const => {
                 let eval_result = self.try_eval_and_append_impl(&expr, span);
                 // We should be able to evaluate `Const` expressions at this

naga/tests/out/glsl/image.texture_sample.Fragment.glsl

@@ -11,73 +11,73 @@ layout(location = 0) out vec4 _fs2p_location0;
 
 void main() {
     vec4 a = vec4(0.0);
-    vec2 tc = vec2(0.5);
-    vec3 tc3_ = vec3(0.5);
-    ivec2 offset = ivec2(3, 1);
+    vec2 _e1 = vec2(0.5);
+    vec3 _e3 = vec3(0.5);
+    ivec2 _e6 = ivec2(3, 1);
     vec4 _e11 = texture(_group_0_binding_0_fs, 0.5);
     vec4 _e12 = a;
     a = (_e12 + _e11);
-    vec4 _e16 = texture(_group_0_binding_1_fs, vec2(tc));
+    vec4 _e16 = texture(_group_0_binding_1_fs, vec2(_e1));
     vec4 _e17 = a;
     a = (_e17 + _e16);
-    vec4 _e24 = textureOffset(_group_0_binding_1_fs, vec2(tc), ivec2(3, 1));
+    vec4 _e24 = textureOffset(_group_0_binding_1_fs, vec2(_e1), ivec2(3, 1));
     vec4 _e25 = a;
     a = (_e25 + _e24);
-    vec4 _e29 = textureLod(_group_0_binding_1_fs, vec2(tc), 2.3);
+    vec4 _e29 = textureLod(_group_0_binding_1_fs, vec2(_e1), 2.3);
     vec4 _e30 = a;
     a = (_e30 + _e29);
-    vec4 _e34 = textureLodOffset(_group_0_binding_1_fs, vec2(tc), 2.3, ivec2(3, 1));
+    vec4 _e34 = textureLodOffset(_group_0_binding_1_fs, vec2(_e1), 2.3, ivec2(3, 1));
     vec4 _e35 = a;
     a = (_e35 + _e34);
-    vec4 _e40 = textureOffset(_group_0_binding_1_fs, vec2(tc), ivec2(3, 1), 2.0);
+    vec4 _e40 = textureOffset(_group_0_binding_1_fs, vec2(_e1), ivec2(3, 1), 2.0);
     vec4 _e41 = a;
     a = (_e41 + _e40);
-    vec4 _e46 = texture(_group_0_binding_4_fs, vec3(tc, 0u));
+    vec4 _e46 = texture(_group_0_binding_4_fs, vec3(_e1, 0u));
     vec4 _e47 = a;
     a = (_e47 + _e46);
-    vec4 _e52 = textureOffset(_group_0_binding_4_fs, vec3(tc, 0u), ivec2(3, 1));
+    vec4 _e52 = textureOffset(_group_0_binding_4_fs, vec3(_e1, 0u), ivec2(3, 1));
     vec4 _e53 = a;
     a = (_e53 + _e52);
-    vec4 _e58 = textureLod(_group_0_binding_4_fs, vec3(tc, 0u), 2.3);
+    vec4 _e58 = textureLod(_group_0_binding_4_fs, vec3(_e1, 0u), 2.3);
     vec4 _e59 = a;
     a = (_e59 + _e58);
-    vec4 _e64 = textureLodOffset(_group_0_binding_4_fs, vec3(tc, 0u), 2.3, ivec2(3, 1));
+    vec4 _e64 = textureLodOffset(_group_0_binding_4_fs, vec3(_e1, 0u), 2.3, ivec2(3, 1));
     vec4 _e65 = a;
     a = (_e65 + _e64);
-    vec4 _e71 = textureOffset(_group_0_binding_4_fs, vec3(tc, 0u), ivec2(3, 1), 2.0);
+    vec4 _e71 = textureOffset(_group_0_binding_4_fs, vec3(_e1, 0u), ivec2(3, 1), 2.0);
     vec4 _e72 = a;
     a = (_e72 + _e71);
-    vec4 _e77 = texture(_group_0_binding_4_fs, vec3(tc, 0));
+    vec4 _e77 = texture(_group_0_binding_4_fs, vec3(_e1, 0));
     vec4 _e78 = a;
     a = (_e78 + _e77);
-    vec4 _e83 = textureOffset(_group_0_binding_4_fs, vec3(tc, 0), ivec2(3, 1));
+    vec4 _e83 = textureOffset(_group_0_binding_4_fs, vec3(_e1, 0), ivec2(3, 1));
     vec4 _e84 = a;
     a = (_e84 + _e83);
-    vec4 _e89 = textureLod(_group_0_binding_4_fs, vec3(tc, 0), 2.3);
+    vec4 _e89 = textureLod(_group_0_binding_4_fs, vec3(_e1, 0), 2.3);
     vec4 _e90 = a;
     a = (_e90 + _e89);
-    vec4 _e95 = textureLodOffset(_group_0_binding_4_fs, vec3(tc, 0), 2.3, ivec2(3, 1));
+    vec4 _e95 = textureLodOffset(_group_0_binding_4_fs, vec3(_e1, 0), 2.3, ivec2(3, 1));
     vec4 _e96 = a;
     a = (_e96 + _e95);
-    vec4 _e102 = textureOffset(_group_0_binding_4_fs, vec3(tc, 0), ivec2(3, 1), 2.0);
+    vec4 _e102 = textureOffset(_group_0_binding_4_fs, vec3(_e1, 0), ivec2(3, 1), 2.0);
     vec4 _e103 = a;
     a = (_e103 + _e102);
-    vec4 _e108 = texture(_group_0_binding_6_fs, vec4(tc3_, 0u));
+    vec4 _e108 = texture(_group_0_binding_6_fs, vec4(_e3, 0u));
     vec4 _e109 = a;
     a = (_e109 + _e108);
-    vec4 _e114 = textureLod(_group_0_binding_6_fs, vec4(tc3_, 0u), 2.3);
+    vec4 _e114 = textureLod(_group_0_binding_6_fs, vec4(_e3, 0u), 2.3);
     vec4 _e115 = a;
     a = (_e115 + _e114);
-    vec4 _e121 = texture(_group_0_binding_6_fs, vec4(tc3_, 0u), 2.0);
+    vec4 _e121 = texture(_group_0_binding_6_fs, vec4(_e3, 0u), 2.0);
     vec4 _e122 = a;
     a = (_e122 + _e121);
-    vec4 _e127 = texture(_group_0_binding_6_fs, vec4(tc3_, 0));
+    vec4 _e127 = texture(_group_0_binding_6_fs, vec4(_e3, 0));
     vec4 _e128 = a;
     a = (_e128 + _e127);
-    vec4 _e133 = textureLod(_group_0_binding_6_fs, vec4(tc3_, 0), 2.3);
+    vec4 _e133 = textureLod(_group_0_binding_6_fs, vec4(_e3, 0), 2.3);
     vec4 _e134 = a;
     a = (_e134 + _e133);
-    vec4 _e140 = texture(_group_0_binding_6_fs, vec4(tc3_, 0), 2.0);
+    vec4 _e140 = texture(_group_0_binding_6_fs, vec4(_e3, 0), 2.0);
     vec4 _e141 = a;
     a = (_e141 + _e140);
     vec4 _e143 = a;