diff --git a/naga/src/back/pipeline_constants.rs b/naga/src/back/pipeline_constants.rs
index 6b2792dd28..79c44f5e9f 100644
--- a/naga/src/back/pipeline_constants.rs
+++ b/naga/src/back/pipeline_constants.rs
@@ -36,7 +36,7 @@ pub(super) fn process_overrides<'a>(
     let mut adjusted_const_expressions = Vec::with_capacity(module.const_expressions.len());
     let mut adjusted_constant_initializers = HashSet::with_capacity(module.constants.len());
 
-    let mut global_expression_kind_tracker = crate::proc::ExpressionConstnessTracker::new();
+    let mut global_expression_kind_tracker = crate::proc::ExpressionKindTracker::new();
 
     let mut override_iter = module.overrides.drain();
 
@@ -123,7 +123,7 @@ fn process_override(
     override_map: &mut Vec<Handle<Constant>>,
     adjusted_const_expressions: &[Handle<Expression>],
     adjusted_constant_initializers: &mut HashSet<Handle<Constant>>,
-    global_expression_kind_tracker: &mut crate::proc::ExpressionConstnessTracker,
+    global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker,
 ) -> Result<Handle<Constant>, PipelineConstantError> {
     let key = if let Some(id) = override_.id {
         Cow::Owned(id.to_string())
diff --git a/naga/src/front/glsl/context.rs b/naga/src/front/glsl/context.rs
index 0c370cd5e5..ec844597d6 100644
--- a/naga/src/front/glsl/context.rs
+++ b/naga/src/front/glsl/context.rs
@@ -78,9 +78,9 @@ pub struct Context<'a> {
     pub module: &'a mut crate::Module,
     pub is_const: bool,
     /// Tracks the expression kind of `Expression`s residing in `self.expressions`
-    pub local_expression_kind_tracker: crate::proc::ExpressionConstnessTracker,
+    pub local_expression_kind_tracker: crate::proc::ExpressionKindTracker,
     /// Tracks the expression kind of `Expression`s residing in `self.module.const_expressions`
-    pub global_expression_kind_tracker: &'a mut crate::proc::ExpressionConstnessTracker,
+    pub global_expression_kind_tracker: &'a mut crate::proc::ExpressionKindTracker,
 }
 
 impl<'a> Context<'a> {
@@ -88,7 +88,7 @@ impl<'a> Context<'a> {
         frontend: &Frontend,
         module: &'a mut crate::Module,
         is_const: bool,
-        global_expression_kind_tracker: &'a mut crate::proc::ExpressionConstnessTracker,
+        global_expression_kind_tracker: &'a mut crate::proc::ExpressionKindTracker,
     ) -> Result<Self> {
         let mut this = Context {
             expressions: Arena::new(),
@@ -108,7 +108,7 @@ impl<'a> Context<'a> {
             body: Block::new(),
             module,
             is_const: false,
-            local_expression_kind_tracker: crate::proc::ExpressionConstnessTracker::new(),
+            local_expression_kind_tracker: crate::proc::ExpressionKindTracker::new(),
             global_expression_kind_tracker,
         };
 
diff --git a/naga/src/front/glsl/parser.rs b/naga/src/front/glsl/parser.rs
index d4eb39b39b..28e0808063 100644
--- a/naga/src/front/glsl/parser.rs
+++ b/naga/src/front/glsl/parser.rs
@@ -164,7 +164,7 @@ impl<'source> ParsingContext<'source> {
 
     pub fn parse(&mut self, frontend: &mut Frontend) -> Result<Module> {
         let mut module = Module::default();
-        let mut global_expression_kind_tracker = crate::proc::ExpressionConstnessTracker::new();
+        let mut global_expression_kind_tracker = crate::proc::ExpressionKindTracker::new();
 
         // Body and expression arena for global initialization
         let mut ctx = Context::new(
@@ -229,7 +229,7 @@ impl<'source> ParsingContext<'source> {
         &mut self,
         frontend: &mut Frontend,
         module: &mut Module,
-        global_expression_kind_tracker: &mut crate::proc::ExpressionConstnessTracker,
+        global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker,
     ) -> Result<(Handle<Expression>, Span)> {
         let mut ctx = Context::new(frontend, module, true, global_expression_kind_tracker)?;
 
diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs
index 662e318f8b..e689dda53a 100644
--- a/naga/src/front/wgsl/lower/mod.rs
+++ b/naga/src/front/wgsl/lower/mod.rs
@@ -87,7 +87,7 @@ pub struct GlobalContext<'source, 'temp, 'out> {
 
     const_typifier: &'temp mut Typifier,
 
-    global_expression_kind_tracker: &'temp mut crate::proc::ExpressionConstnessTracker,
+    global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
 }
 
 impl<'source> GlobalContext<'source, '_, '_> {
@@ -179,8 +179,8 @@ pub struct StatementContext<'source, 'temp, 'out> {
     /// with the form of the expressions; it is also tracking whether WGSL says
     /// we should consider them to be const. See the use of `force_non_const` in
     /// the code for lowering `let` bindings.
-    expression_constness: &'temp mut crate::proc::ExpressionConstnessTracker,
-    global_expression_kind_tracker: &'temp mut crate::proc::ExpressionConstnessTracker,
+    local_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
+    global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
 }
 
 impl<'a, 'temp> StatementContext<'a, 'temp, '_> {
@@ -205,7 +205,7 @@ impl<'a, 'temp> StatementContext<'a, 'temp, '_> {
                 block,
                 emitter,
                 typifier: self.typifier,
-                expression_constness: self.expression_constness,
+                local_expression_kind_tracker: self.local_expression_kind_tracker,
             }),
         }
     }
@@ -250,8 +250,8 @@ pub struct RuntimeExpressionContext<'temp, 'out> {
     /// Which `Expression`s in `self.naga_expressions` are const expressions, in
     /// the WGSL sense.
     ///
-    /// See [`StatementContext::expression_constness`] for details.
-    expression_constness: &'temp mut crate::proc::ExpressionConstnessTracker,
+    /// See [`StatementContext::local_expression_kind_tracker`] for details.
+    local_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
 }
 
 /// The type of Naga IR expression we are lowering an [`ast::Expression`] to.
@@ -337,7 +337,7 @@ pub struct ExpressionContext<'source, 'temp, 'out> {
     ///
     /// [`module::const_expressions`]: crate::Module::const_expressions
     const_typifier: &'temp mut Typifier,
-    global_expression_kind_tracker: &'temp mut crate::proc::ExpressionConstnessTracker,
+    global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
 
     /// Whether we are lowering a constant expression or a general
     /// runtime expression, and the data needed in each case.
@@ -373,7 +373,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
             ExpressionContextType::Runtime(ref mut rctx) => ConstantEvaluator::for_wgsl_function(
                 self.module,
                 &mut rctx.function.expressions,
-                rctx.expression_constness,
+                rctx.local_expression_kind_tracker,
                 rctx.emitter,
                 rctx.block,
             ),
@@ -403,7 +403,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
     fn const_access(&self, handle: Handle<crate::Expression>) -> Option<u32> {
         match self.expr_type {
             ExpressionContextType::Runtime(ref ctx) => {
-                if !ctx.expression_constness.is_const(handle) {
+                if !ctx.local_expression_kind_tracker.is_const(handle) {
                     return None;
                 }
 
@@ -455,7 +455,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
     ) -> Result<crate::SwizzleComponent, Error<'source>> {
         match self.expr_type {
             ExpressionContextType::Runtime(ref rctx) => {
-                if !rctx.expression_constness.is_const(expr) {
+                if !rctx.local_expression_kind_tracker.is_const(expr) {
                     return Err(Error::ExpectedConstExprConcreteIntegerScalar(
                         component_span,
                     ));
@@ -899,7 +899,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
             types: &tu.types,
             module: &mut module,
             const_typifier: &mut Typifier::new(),
-            global_expression_kind_tracker: &mut crate::proc::ExpressionConstnessTracker::new(),
+            global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker::new(),
         };
 
         for decl_handle in self.index.visit_ordered() {
@@ -1097,7 +1097,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
         let mut local_table = FastHashMap::default();
         let mut expressions = Arena::new();
         let mut named_expressions = FastIndexMap::default();
-        let mut local_expression_kind_tracker = crate::proc::ExpressionConstnessTracker::new();
+        let mut local_expression_kind_tracker = crate::proc::ExpressionKindTracker::new();
 
         let arguments = f
             .arguments
@@ -1152,7 +1152,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
             named_expressions: &mut named_expressions,
             types: ctx.types,
             module: ctx.module,
-            expression_constness: &mut local_expression_kind_tracker,
+            local_expression_kind_tracker: &mut local_expression_kind_tracker,
             global_expression_kind_tracker: ctx.global_expression_kind_tracker,
         };
         let mut body = self.block(&f.body, false, &mut stmt_ctx)?;
@@ -1232,7 +1232,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                     // affects when errors must be reported, so we can't even
                     // treat suitable `let` bindings as constant as an
                     // optimization.
-                    ctx.expression_constness.force_non_const(value);
+                    ctx.local_expression_kind_tracker.force_non_const(value);
 
                     let explicit_ty =
                         l.ty.map(|ty| self.resolve_ast_type(ty, &mut ctx.as_global()))
@@ -1316,7 +1316,9 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                                 // - the initialization is not a constant
                                 //   expression, so its value depends on the
                                 //   state at the point of initialization.
-                                if is_inside_loop || !ctx.expression_constness.is_const(init) {
+                                if is_inside_loop
+                                    || !ctx.local_expression_kind_tracker.is_const(init)
+                                {
                                     (None, Some(init))
                                 } else {
                                     (Some(init), None)
@@ -1569,9 +1571,9 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                     .function
                     .expressions
                     .append(crate::Expression::Binary { op, left, right }, stmt.span);
-                rctx.expression_constness
+                rctx.local_expression_kind_tracker
                     .insert(left, crate::proc::ExpressionKind::Runtime);
-                rctx.expression_constness
+                rctx.local_expression_kind_tracker
                     .insert(value, crate::proc::ExpressionKind::Runtime);
 
                 block.extend(emitter.finish(&ctx.function.expressions));
@@ -1950,7 +1952,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                         .function
                         .expressions
                         .append(crate::Expression::CallResult(function), span);
-                    rctx.expression_constness
+                    rctx.local_expression_kind_tracker
                         .insert(result, crate::proc::ExpressionKind::Runtime);
                     result
                 });
diff --git a/naga/src/proc/constant_evaluator.rs b/naga/src/proc/constant_evaluator.rs
index 6318a57c00..6f09ec5444 100644
--- a/naga/src/proc/constant_evaluator.rs
+++ b/naga/src/proc/constant_evaluator.rs
@@ -298,7 +298,7 @@ pub struct ConstantEvaluator<'a> {
     expressions: &'a mut Arena<Expression>,
 
     /// Tracks the constness of expressions residing in [`Self::expressions`]
-    expression_kind_tracker: &'a mut ExpressionConstnessTracker,
+    expression_kind_tracker: &'a mut ExpressionKindTracker,
 }
 
 #[derive(Debug)]
@@ -340,11 +340,11 @@ pub enum ExpressionKind {
 }
 
 #[derive(Debug)]
-pub struct ExpressionConstnessTracker {
+pub struct ExpressionKindTracker {
     inner: Vec<ExpressionKind>,
 }
 
-impl ExpressionConstnessTracker {
+impl ExpressionKindTracker {
     pub const fn new() -> Self {
         Self { inner: Vec::new() }
     }
@@ -531,7 +531,7 @@ impl<'a> ConstantEvaluator<'a> {
     /// Report errors according to WGSL's rules for constant evaluation.
     pub fn for_wgsl_module(
         module: &'a mut crate::Module,
-        global_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
+        global_expression_kind_tracker: &'a mut ExpressionKindTracker,
         in_override_ctx: bool,
     ) -> Self {
         Self::for_module(
@@ -551,7 +551,7 @@ impl<'a> ConstantEvaluator<'a> {
     /// Report errors according to GLSL's rules for constant evaluation.
     pub fn for_glsl_module(
         module: &'a mut crate::Module,
-        global_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
+        global_expression_kind_tracker: &'a mut ExpressionKindTracker,
     ) -> Self {
         Self::for_module(
             Behavior::Glsl(GlslRestrictions::Const),
@@ -563,7 +563,7 @@ impl<'a> ConstantEvaluator<'a> {
     fn for_module(
         behavior: Behavior<'a>,
         module: &'a mut crate::Module,
-        global_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
+        global_expression_kind_tracker: &'a mut ExpressionKindTracker,
     ) -> Self {
         Self {
             behavior,
@@ -582,7 +582,7 @@ impl<'a> ConstantEvaluator<'a> {
     pub fn for_wgsl_function(
         module: &'a mut crate::Module,
         expressions: &'a mut Arena<Expression>,
-        local_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
+        local_expression_kind_tracker: &'a mut ExpressionKindTracker,
         emitter: &'a mut super::Emitter,
         block: &'a mut crate::Block,
     ) -> Self {
@@ -607,7 +607,7 @@ impl<'a> ConstantEvaluator<'a> {
     pub fn for_glsl_function(
         module: &'a mut crate::Module,
         expressions: &'a mut Arena<Expression>,
-        local_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
+        local_expression_kind_tracker: &'a mut ExpressionKindTracker,
         emitter: &'a mut super::Emitter,
         block: &'a mut crate::Block,
     ) -> Self {
@@ -2195,7 +2195,7 @@ mod tests {
         UniqueArena, VectorSize,
     };
 
-    use super::{Behavior, ConstantEvaluator, ExpressionConstnessTracker, WgslRestrictions};
+    use super::{Behavior, ConstantEvaluator, ExpressionKindTracker, WgslRestrictions};
 
     #[test]
     fn unary_op() {
@@ -2276,8 +2276,7 @@ mod tests {
             expr: expr1,
         };
 
-        let expression_kind_tracker =
-            &mut ExpressionConstnessTracker::from_arena(&const_expressions);
+        let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
         let mut solver = ConstantEvaluator {
             behavior: Behavior::Wgsl(WgslRestrictions::Const),
             types: &mut types,
@@ -2363,8 +2362,7 @@ mod tests {
             convert: Some(crate::BOOL_WIDTH),
         };
 
-        let expression_kind_tracker =
-            &mut ExpressionConstnessTracker::from_arena(&const_expressions);
+        let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
         let mut solver = ConstantEvaluator {
             behavior: Behavior::Wgsl(WgslRestrictions::Const),
             types: &mut types,
@@ -2482,8 +2480,7 @@ mod tests {
 
         let base = const_expressions.append(Expression::Constant(h), Default::default());
 
-        let expression_kind_tracker =
-            &mut ExpressionConstnessTracker::from_arena(&const_expressions);
+        let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
         let mut solver = ConstantEvaluator {
             behavior: Behavior::Wgsl(WgslRestrictions::Const),
             types: &mut types,
@@ -2576,8 +2573,7 @@ mod tests {
 
         let h_expr = const_expressions.append(Expression::Constant(h), Default::default());
 
-        let expression_kind_tracker =
-            &mut ExpressionConstnessTracker::from_arena(&const_expressions);
+        let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
         let mut solver = ConstantEvaluator {
             behavior: Behavior::Wgsl(WgslRestrictions::Const),
             types: &mut types,
@@ -2659,8 +2655,7 @@ mod tests {
 
         let h_expr = const_expressions.append(Expression::Constant(h), Default::default());
 
-        let expression_kind_tracker =
-            &mut ExpressionConstnessTracker::from_arena(&const_expressions);
+        let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
         let mut solver = ConstantEvaluator {
             behavior: Behavior::Wgsl(WgslRestrictions::Const),
             types: &mut types,
diff --git a/naga/src/proc/mod.rs b/naga/src/proc/mod.rs
index 2db956ee0e..eda732978a 100644
--- a/naga/src/proc/mod.rs
+++ b/naga/src/proc/mod.rs
@@ -11,7 +11,7 @@ mod terminator;
 mod typifier;
 
 pub use constant_evaluator::{
-    ConstantEvaluator, ConstantEvaluatorError, ExpressionConstnessTracker, ExpressionKind,
+    ConstantEvaluator, ConstantEvaluatorError, ExpressionKind, ExpressionKindTracker,
 };
 pub use emitter::Emitter;
 pub use index::{BoundsCheckPolicies, BoundsCheckPolicy, IndexableLength, IndexableLengthError};
diff --git a/naga/src/valid/expression.rs b/naga/src/valid/expression.rs
index 79180a0711..4a1020cb78 100644
--- a/naga/src/valid/expression.rs
+++ b/naga/src/valid/expression.rs
@@ -187,7 +187,7 @@ impl super::Validator {
         handle: Handle<crate::Expression>,
         gctx: crate::proc::GlobalCtx,
         mod_info: &ModuleInfo,
-        global_expr_kind: &crate::proc::ExpressionConstnessTracker,
+        global_expr_kind: &crate::proc::ExpressionKindTracker,
     ) -> Result<(), ConstExpressionError> {
         use crate::Expression as E;
 
@@ -227,7 +227,7 @@ impl super::Validator {
         module: &crate::Module,
         info: &FunctionInfo,
         mod_info: &ModuleInfo,
-        global_expr_kind: &crate::proc::ExpressionConstnessTracker,
+        global_expr_kind: &crate::proc::ExpressionKindTracker,
     ) -> Result<ShaderStages, ExpressionError> {
         use crate::{Expression as E, Scalar as Sc, ScalarKind as Sk, TypeInner as Ti};
 
diff --git a/naga/src/valid/function.rs b/naga/src/valid/function.rs
index dfb7fbc6ee..b8ad63cc6d 100644
--- a/naga/src/valid/function.rs
+++ b/naga/src/valid/function.rs
@@ -927,7 +927,7 @@ impl super::Validator {
         var: &crate::LocalVariable,
         gctx: crate::proc::GlobalCtx,
         fun_info: &FunctionInfo,
-        local_expr_kind: &crate::proc::ExpressionConstnessTracker,
+        local_expr_kind: &crate::proc::ExpressionKindTracker,
     ) -> Result<(), LocalVariableError> {
         log::debug!("var {:?}", var);
         let type_info = self
@@ -959,11 +959,11 @@ impl super::Validator {
         module: &crate::Module,
         mod_info: &ModuleInfo,
         entry_point: bool,
-        global_expr_kind: &crate::proc::ExpressionConstnessTracker,
+        global_expr_kind: &crate::proc::ExpressionKindTracker,
     ) -> Result<FunctionInfo, WithSpan<FunctionError>> {
         let mut info = mod_info.process_function(fun, module, self.flags, self.capabilities)?;
 
-        let local_expr_kind = crate::proc::ExpressionConstnessTracker::from_arena(&fun.expressions);
+        let local_expr_kind = crate::proc::ExpressionKindTracker::from_arena(&fun.expressions);
 
         for (var_handle, var) in fun.local_variables.iter() {
             self.validate_local_var(var, module.to_ctx(), &info, &local_expr_kind)
diff --git a/naga/src/valid/interface.rs b/naga/src/valid/interface.rs
index 945af946bb..0e42075de1 100644
--- a/naga/src/valid/interface.rs
+++ b/naga/src/valid/interface.rs
@@ -400,7 +400,7 @@ impl super::Validator {
         var: &crate::GlobalVariable,
         gctx: crate::proc::GlobalCtx,
         mod_info: &ModuleInfo,
-        global_expr_kind: &crate::proc::ExpressionConstnessTracker,
+        global_expr_kind: &crate::proc::ExpressionKindTracker,
     ) -> Result<(), GlobalVariableError> {
         use super::TypeFlags;
 
@@ -548,7 +548,7 @@ impl super::Validator {
         ep: &crate::EntryPoint,
         module: &crate::Module,
         mod_info: &ModuleInfo,
-        global_expr_kind: &crate::proc::ExpressionConstnessTracker,
+        global_expr_kind: &crate::proc::ExpressionKindTracker,
     ) -> Result<FunctionInfo, WithSpan<EntryPointError>> {
         if ep.early_depth_test.is_some() {
             let required = Capabilities::EARLY_DEPTH_TEST;
diff --git a/naga/src/valid/mod.rs b/naga/src/valid/mod.rs
index b4b2063775..72da6377d9 100644
--- a/naga/src/valid/mod.rs
+++ b/naga/src/valid/mod.rs
@@ -12,7 +12,7 @@ mod r#type;
 
 use crate::{
     arena::Handle,
-    proc::{ExpressionConstnessTracker, LayoutError, Layouter, TypeResolution},
+    proc::{ExpressionKindTracker, LayoutError, Layouter, TypeResolution},
     FastHashSet,
 };
 use bit_set::BitSet;
@@ -342,7 +342,7 @@ impl Validator {
         handle: Handle<crate::Constant>,
         gctx: crate::proc::GlobalCtx,
         mod_info: &ModuleInfo,
-        global_expr_kind: &ExpressionConstnessTracker,
+        global_expr_kind: &ExpressionKindTracker,
     ) -> Result<(), ConstantError> {
         let con = &gctx.constants[handle];
 
@@ -467,7 +467,7 @@ impl Validator {
             }
         }
 
-        let global_expr_kind = ExpressionConstnessTracker::from_arena(&module.const_expressions);
+        let global_expr_kind = ExpressionKindTracker::from_arena(&module.const_expressions);
 
         if self.flags.contains(ValidationFlags::CONSTANTS) {
             for (handle, _) in module.const_expressions.iter() {