From e9eb703941b2cf394e4ccdef4b5fcd757e39fc21 Mon Sep 17 00:00:00 2001 From: teoxoy <28601907+teoxoy@users.noreply.github.com> Date: Wed, 14 Feb 2024 15:25:23 +0100 Subject: [PATCH] rename `const_expressions` to `global_expressions` --- naga/src/back/glsl/mod.rs | 2 +- naga/src/back/hlsl/writer.rs | 4 +- naga/src/back/msl/writer.rs | 2 +- naga/src/back/pipeline_constants.rs | 26 +++--- naga/src/back/spv/writer.rs | 8 +- naga/src/back/wgsl/writer.rs | 2 +- naga/src/compact/expressions.rs | 14 +-- naga/src/compact/functions.rs | 4 +- naga/src/compact/mod.rs | 34 ++++---- naga/src/front/glsl/context.rs | 4 +- naga/src/front/glsl/parser/functions.rs | 2 +- naga/src/front/glsl/parser_tests.rs | 4 +- naga/src/front/glsl/types.rs | 10 ++- naga/src/front/spv/function.rs | 4 +- naga/src/front/spv/image.rs | 2 +- naga/src/front/spv/mod.rs | 22 ++--- naga/src/front/spv/null.rs | 8 +- naga/src/front/wgsl/lower/mod.rs | 8 +- naga/src/front/wgsl/to_wgsl.rs | 2 +- naga/src/lib.rs | 10 +-- naga/src/proc/constant_evaluator.rs | 108 ++++++++++++------------ naga/src/proc/mod.rs | 12 +-- naga/src/valid/analyzer.rs | 2 +- naga/src/valid/expression.rs | 4 +- naga/src/valid/handles.rs | 12 +-- naga/src/valid/mod.rs | 12 +-- naga/tests/out/ir/access.compact.ron | 2 +- naga/tests/out/ir/access.ron | 2 +- naga/tests/out/ir/collatz.compact.ron | 2 +- naga/tests/out/ir/collatz.ron | 2 +- naga/tests/out/ir/overrides.compact.ron | 2 +- naga/tests/out/ir/overrides.ron | 2 +- naga/tests/out/ir/shadow.compact.ron | 2 +- naga/tests/out/ir/shadow.ron | 2 +- 34 files changed, 170 insertions(+), 168 deletions(-) diff --git a/naga/src/back/glsl/mod.rs b/naga/src/back/glsl/mod.rs index 736a3b57b7..13811a2df0 100644 --- a/naga/src/back/glsl/mod.rs +++ b/naga/src/back/glsl/mod.rs @@ -2410,7 +2410,7 @@ impl<'a, W: Write> Writer<'a, W> { fn write_const_expr(&mut self, expr: Handle) -> BackendResult { self.write_possibly_const_expr( expr, - &self.module.const_expressions, + &self.module.global_expressions, |expr| &self.info[expr], |writer, expr| writer.write_const_expr(expr), ) diff --git a/naga/src/back/hlsl/writer.rs b/naga/src/back/hlsl/writer.rs index 1abc6ceca0..4bde1f6486 100644 --- a/naga/src/back/hlsl/writer.rs +++ b/naga/src/back/hlsl/writer.rs @@ -243,7 +243,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> { self.write_special_functions(module)?; - self.write_wrapped_compose_functions(module, &module.const_expressions)?; + self.write_wrapped_compose_functions(module, &module.global_expressions)?; // Write all named constants let mut constants = module @@ -2007,7 +2007,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> { self.write_possibly_const_expression( module, expr, - &module.const_expressions, + &module.global_expressions, |writer, expr| writer.write_const_expression(module, expr), ) } diff --git a/naga/src/back/msl/writer.rs b/naga/src/back/msl/writer.rs index 3c2a741cd4..7797bc658f 100644 --- a/naga/src/back/msl/writer.rs +++ b/naga/src/back/msl/writer.rs @@ -1248,7 +1248,7 @@ impl Writer { ) -> BackendResult { self.put_possibly_const_expression( expr_handle, - &module.const_expressions, + &module.global_expressions, module, mod_info, &(module, mod_info), diff --git a/naga/src/back/pipeline_constants.rs b/naga/src/back/pipeline_constants.rs index 79c44f5e9f..a301b4ff3d 100644 --- a/naga/src/back/pipeline_constants.rs +++ b/naga/src/back/pipeline_constants.rs @@ -33,14 +33,14 @@ pub(super) fn process_overrides<'a>( let mut module = module.clone(); let mut override_map = Vec::with_capacity(module.overrides.len()); - let mut adjusted_const_expressions = Vec::with_capacity(module.const_expressions.len()); + let mut adjusted_global_expressions = Vec::with_capacity(module.global_expressions.len()); let mut adjusted_constant_initializers = HashSet::with_capacity(module.constants.len()); let mut global_expression_kind_tracker = crate::proc::ExpressionKindTracker::new(); let mut override_iter = module.overrides.drain(); - for (old_h, expr, span) in module.const_expressions.drain() { + for (old_h, expr, span) in module.global_expressions.drain() { let mut expr = match expr { Expression::Override(h) => { let c_h = if let Some(new_h) = override_map.get(h.index()) { @@ -54,7 +54,7 @@ pub(super) fn process_overrides<'a>( pipeline_constants, &mut module, &mut override_map, - &adjusted_const_expressions, + &adjusted_global_expressions, &mut adjusted_constant_initializers, &mut global_expression_kind_tracker, )?); @@ -68,7 +68,7 @@ pub(super) fn process_overrides<'a>( } Expression::Constant(c_h) => { adjusted_constant_initializers.insert(c_h); - module.constants[c_h].init = adjusted_const_expressions[c_h.index()]; + module.constants[c_h].init = adjusted_global_expressions[c_h.index()]; expr } expr => expr, @@ -78,10 +78,10 @@ pub(super) fn process_overrides<'a>( &mut global_expression_kind_tracker, false, ); - adjust_expr(&adjusted_const_expressions, &mut expr); + adjust_expr(&adjusted_global_expressions, &mut expr); let h = evaluator.try_eval_and_append(expr, span)?; - debug_assert_eq!(old_h.index(), adjusted_const_expressions.len()); - adjusted_const_expressions.push(h); + debug_assert_eq!(old_h.index(), adjusted_global_expressions.len()); + adjusted_global_expressions.push(h); } for entry in override_iter { @@ -90,7 +90,7 @@ pub(super) fn process_overrides<'a>( pipeline_constants, &mut module, &mut override_map, - &adjusted_const_expressions, + &adjusted_global_expressions, &mut adjusted_constant_initializers, &mut global_expression_kind_tracker, )?; @@ -101,12 +101,12 @@ pub(super) fn process_overrides<'a>( .iter_mut() .filter(|&(c_h, _)| !adjusted_constant_initializers.contains(&c_h)) { - c.init = adjusted_const_expressions[c.init.index()]; + c.init = adjusted_global_expressions[c.init.index()]; } for (_, v) in module.global_variables.iter_mut() { if let Some(ref mut init) = v.init { - *init = adjusted_const_expressions[init.index()]; + *init = adjusted_global_expressions[init.index()]; } } @@ -121,7 +121,7 @@ fn process_override( pipeline_constants: &PipelineConstants, module: &mut Module, override_map: &mut Vec>, - adjusted_const_expressions: &[Handle], + adjusted_global_expressions: &[Handle], adjusted_constant_initializers: &mut HashSet>, global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker, ) -> Result, PipelineConstantError> { @@ -138,12 +138,12 @@ fn process_override( _ => unreachable!(), }; let expr = module - .const_expressions + .global_expressions .append(Expression::Literal(literal), Span::UNDEFINED); global_expression_kind_tracker.insert(expr, crate::proc::ExpressionKind::Const); expr } else if let Some(init) = override_.init { - adjusted_const_expressions[init.index()] + adjusted_global_expressions[init.index()] } else { return Err(PipelineConstantError::MissingValue(key.to_string())); }; diff --git a/naga/src/back/spv/writer.rs b/naga/src/back/spv/writer.rs index 868fad7fa2..0fc0227fb7 100644 --- a/naga/src/back/spv/writer.rs +++ b/naga/src/back/spv/writer.rs @@ -1258,7 +1258,7 @@ impl Writer { ir_module: &crate::Module, mod_info: &ModuleInfo, ) -> Result { - let id = match ir_module.const_expressions[handle] { + let id = match ir_module.global_expressions[handle] { crate::Expression::Literal(literal) => self.get_constant_scalar(literal), crate::Expression::Constant(constant) => { let constant = &ir_module.constants[constant]; @@ -1272,7 +1272,7 @@ impl Writer { let component_ids: Vec<_> = crate::proc::flatten_compose( ty, components, - &ir_module.const_expressions, + &ir_module.global_expressions, &ir_module.types, ) .map(|component| self.constant_ids[component.index()]) @@ -1914,8 +1914,8 @@ impl Writer { // write all const-expressions as constants self.constant_ids - .resize(ir_module.const_expressions.len(), 0); - for (handle, _) in ir_module.const_expressions.iter() { + .resize(ir_module.global_expressions.len(), 0); + for (handle, _) in ir_module.global_expressions.iter() { self.write_constant_expr(handle, ir_module, mod_info)?; } debug_assert!(self.constant_ids.iter().all(|&id| id != 0)); diff --git a/naga/src/back/wgsl/writer.rs b/naga/src/back/wgsl/writer.rs index 7ca689f482..8005a27617 100644 --- a/naga/src/back/wgsl/writer.rs +++ b/naga/src/back/wgsl/writer.rs @@ -1076,7 +1076,7 @@ impl Writer { self.write_possibly_const_expression( module, expr, - &module.const_expressions, + &module.global_expressions, |writer, expr| writer.write_const_expression(module, expr), ) } diff --git a/naga/src/compact/expressions.rs b/naga/src/compact/expressions.rs index 21c4c9cdc2..0f2d8b1a02 100644 --- a/naga/src/compact/expressions.rs +++ b/naga/src/compact/expressions.rs @@ -21,11 +21,11 @@ pub struct ExpressionTracer<'tracer> { /// the module's constant expression arena. pub expressions_used: &'tracer mut HandleSet, - /// The used set for the module's `const_expressions` arena. + /// The used set for the module's `global_expressions` arena. /// /// If `None`, we are already tracing the constant expressions, /// and `expressions_used` already refers to their handle set. - pub const_expressions_used: Option<&'tracer mut HandleSet>, + pub global_expressions_used: Option<&'tracer mut HandleSet>, } impl<'tracer> ExpressionTracer<'tracer> { @@ -40,11 +40,11 @@ impl<'tracer> ExpressionTracer<'tracer> { /// marked. /// /// [fe]: crate::Function::expressions - /// [ce]: crate::Module::const_expressions + /// [ce]: crate::Module::global_expressions pub fn trace_expressions(&mut self) { log::trace!( "entering trace_expression of {}", - if self.const_expressions_used.is_some() { + if self.global_expressions_used.is_some() { "function expressions" } else { "const expressions" @@ -84,7 +84,7 @@ impl<'tracer> ExpressionTracer<'tracer> { // and the constant refers to the initializer, it must // precede `expr` in the arena. let init = self.constants[handle].init; - match self.const_expressions_used { + match self.global_expressions_used { Some(ref mut used) => used.insert(init), None => self.expressions_used.insert(init), } @@ -122,7 +122,7 @@ impl<'tracer> ExpressionTracer<'tracer> { self.expressions_used .insert_iter([image, sampler, coordinate]); self.expressions_used.insert_iter(array_index); - match self.const_expressions_used { + match self.global_expressions_used { Some(ref mut used) => used.insert_iter(offset), None => self.expressions_used.insert_iter(offset), } @@ -276,7 +276,7 @@ impl ModuleMap { adjust(coordinate); operand_map.adjust_option(array_index); if let Some(ref mut offset) = *offset { - self.const_expressions.adjust(offset); + self.global_expressions.adjust(offset); } self.adjust_sample_level(level, operand_map); operand_map.adjust_option(depth_ref); diff --git a/naga/src/compact/functions.rs b/naga/src/compact/functions.rs index 98a23acee0..4ac2223eb7 100644 --- a/naga/src/compact/functions.rs +++ b/naga/src/compact/functions.rs @@ -8,7 +8,7 @@ pub struct FunctionTracer<'a> { pub types_used: &'a mut HandleSet, pub constants_used: &'a mut HandleSet, - pub const_expressions_used: &'a mut HandleSet, + pub global_expressions_used: &'a mut HandleSet, /// Function-local expressions used. pub expressions_used: HandleSet, @@ -54,7 +54,7 @@ impl<'a> FunctionTracer<'a> { types_used: self.types_used, constants_used: self.constants_used, expressions_used: &mut self.expressions_used, - const_expressions_used: Some(&mut self.const_expressions_used), + global_expressions_used: Some(&mut self.global_expressions_used), } } } diff --git a/naga/src/compact/mod.rs b/naga/src/compact/mod.rs index 2b49d34995..0d7a37b579 100644 --- a/naga/src/compact/mod.rs +++ b/naga/src/compact/mod.rs @@ -38,7 +38,7 @@ pub fn compact(module: &mut crate::Module) { log::trace!("tracing global {:?}", global.name); module_tracer.types_used.insert(global.ty); if let Some(init) = global.init { - module_tracer.const_expressions_used.insert(init); + module_tracer.global_expressions_used.insert(init); } } } @@ -50,7 +50,7 @@ pub fn compact(module: &mut crate::Module) { for (handle, constant) in module.constants.iter() { if constant.name.is_some() { module_tracer.constants_used.insert(handle); - module_tracer.const_expressions_used.insert(constant.init); + module_tracer.global_expressions_used.insert(constant.init); } } @@ -58,7 +58,7 @@ pub fn compact(module: &mut crate::Module) { for (_, override_) in module.overrides.iter() { module_tracer.types_used.insert(override_.ty); if let Some(init) = override_.init { - module_tracer.const_expressions_used.insert(init); + module_tracer.global_expressions_used.insert(init); } } @@ -145,9 +145,9 @@ pub fn compact(module: &mut crate::Module) { // Drop unused constant expressions, reusing existing storage. log::trace!("adjusting constant expressions"); - module.const_expressions.retain_mut(|handle, expr| { - if module_map.const_expressions.used(handle) { - module_map.adjust_expression(expr, &module_map.const_expressions); + module.global_expressions.retain_mut(|handle, expr| { + if module_map.global_expressions.used(handle) { + module_map.adjust_expression(expr, &module_map.global_expressions); true } else { false @@ -159,7 +159,7 @@ pub fn compact(module: &mut crate::Module) { module.constants.retain_mut(|handle, constant| { if module_map.constants.used(handle) { module_map.types.adjust(&mut constant.ty); - module_map.const_expressions.adjust(&mut constant.init); + module_map.global_expressions.adjust(&mut constant.init); true } else { false @@ -171,7 +171,7 @@ pub fn compact(module: &mut crate::Module) { for (_, override_) in module.overrides.iter_mut() { module_map.types.adjust(&mut override_.ty); if let Some(init) = override_.init.as_mut() { - module_map.const_expressions.adjust(init); + module_map.global_expressions.adjust(init); } } @@ -181,7 +181,7 @@ pub fn compact(module: &mut crate::Module) { log::trace!("adjusting global {:?}", global.name); module_map.types.adjust(&mut global.ty); if let Some(ref mut init) = global.init { - module_map.const_expressions.adjust(init); + module_map.global_expressions.adjust(init); } } @@ -210,7 +210,7 @@ struct ModuleTracer<'module> { module: &'module crate::Module, types_used: HandleSet, constants_used: HandleSet, - const_expressions_used: HandleSet, + global_expressions_used: HandleSet, } impl<'module> ModuleTracer<'module> { @@ -219,7 +219,7 @@ impl<'module> ModuleTracer<'module> { module, types_used: HandleSet::for_arena(&module.types), constants_used: HandleSet::for_arena(&module.constants), - const_expressions_used: HandleSet::for_arena(&module.const_expressions), + global_expressions_used: HandleSet::for_arena(&module.global_expressions), } } @@ -250,13 +250,13 @@ impl<'module> ModuleTracer<'module> { fn as_const_expression(&mut self) -> expressions::ExpressionTracer { expressions::ExpressionTracer { - expressions: &self.module.const_expressions, + expressions: &self.module.global_expressions, constants: &self.module.constants, overrides: &self.module.overrides, types_used: &mut self.types_used, constants_used: &mut self.constants_used, - expressions_used: &mut self.const_expressions_used, - const_expressions_used: None, + expressions_used: &mut self.global_expressions_used, + global_expressions_used: None, } } @@ -270,7 +270,7 @@ impl<'module> ModuleTracer<'module> { overrides: &self.module.overrides, types_used: &mut self.types_used, constants_used: &mut self.constants_used, - const_expressions_used: &mut self.const_expressions_used, + global_expressions_used: &mut self.global_expressions_used, expressions_used: HandleSet::for_arena(&function.expressions), } } @@ -279,7 +279,7 @@ impl<'module> ModuleTracer<'module> { struct ModuleMap { types: HandleMap, constants: HandleMap, - const_expressions: HandleMap, + global_expressions: HandleMap, } impl From> for ModuleMap { @@ -287,7 +287,7 @@ impl From> for ModuleMap { ModuleMap { types: HandleMap::from_set(used.types_used), constants: HandleMap::from_set(used.constants_used), - const_expressions: HandleMap::from_set(used.const_expressions_used), + global_expressions: HandleMap::from_set(used.global_expressions_used), } } } diff --git a/naga/src/front/glsl/context.rs b/naga/src/front/glsl/context.rs index ec844597d6..6ba7df593a 100644 --- a/naga/src/front/glsl/context.rs +++ b/naga/src/front/glsl/context.rs @@ -79,7 +79,7 @@ pub struct Context<'a> { pub is_const: bool, /// Tracks the expression kind of `Expression`s residing in `self.expressions` pub local_expression_kind_tracker: crate::proc::ExpressionKindTracker, - /// Tracks the expression kind of `Expression`s residing in `self.module.const_expressions` + /// Tracks the expression kind of `Expression`s residing in `self.module.global_expressions` pub global_expression_kind_tracker: &'a mut crate::proc::ExpressionKindTracker, } @@ -1471,7 +1471,7 @@ impl Index> for Context<'_> { fn index(&self, index: Handle) -> &Self::Output { if self.is_const { - &self.module.const_expressions[index] + &self.module.global_expressions[index] } else { &self.expressions[index] } diff --git a/naga/src/front/glsl/parser/functions.rs b/naga/src/front/glsl/parser/functions.rs index 6d3b9d7ba4..d0c889e4d3 100644 --- a/naga/src/front/glsl/parser/functions.rs +++ b/naga/src/front/glsl/parser/functions.rs @@ -198,7 +198,7 @@ impl<'source> ParsingContext<'source> { ctx.global_expression_kind_tracker, )?; - match ctx.module.const_expressions[const_expr] { + match ctx.module.global_expressions[const_expr] { Expression::Literal(Literal::I32(value)) => match uint { // This unchecked cast isn't good, but since // we only reach this code when the selector diff --git a/naga/src/front/glsl/parser_tests.rs b/naga/src/front/glsl/parser_tests.rs index e6e2b2c853..c065dc15d6 100644 --- a/naga/src/front/glsl/parser_tests.rs +++ b/naga/src/front/glsl/parser_tests.rs @@ -539,7 +539,7 @@ fn constants() { let mut types = module.types.iter(); let mut constants = module.constants.iter(); - let mut const_expressions = module.const_expressions.iter(); + let mut global_expressions = module.global_expressions.iter(); let (ty_handle, ty) = types.next().unwrap(); assert_eq!( @@ -550,7 +550,7 @@ fn constants() { } ); - let (init_handle, init) = const_expressions.next().unwrap(); + let (init_handle, init) = global_expressions.next().unwrap(); assert_eq!(init, &Expression::Literal(crate::Literal::F32(1.0))); assert_eq!( diff --git a/naga/src/front/glsl/types.rs b/naga/src/front/glsl/types.rs index 8a04b23839..f6836169c0 100644 --- a/naga/src/front/glsl/types.rs +++ b/naga/src/front/glsl/types.rs @@ -233,7 +233,7 @@ impl Context<'_> { }; let expressions = if self.is_const { - &self.module.const_expressions + &self.module.global_expressions } else { &self.expressions }; @@ -333,20 +333,22 @@ impl Context<'_> { let h = match self.expressions[expr] { ref expr @ (Expression::Literal(_) | Expression::Constant(_) - | Expression::ZeroValue(_)) => self.module.const_expressions.append(expr.clone(), meta), + | Expression::ZeroValue(_)) => { + self.module.global_expressions.append(expr.clone(), meta) + } Expression::Compose { ty, ref components } => { let mut components = components.clone(); for component in &mut components { *component = self.lift_up_const_expression(*component)?; } self.module - .const_expressions + .global_expressions .append(Expression::Compose { ty, components }, meta) } Expression::Splat { size, value } => { let value = self.lift_up_const_expression(value)?; self.module - .const_expressions + .global_expressions .append(Expression::Splat { size, value }, meta) } _ => { diff --git a/naga/src/front/spv/function.rs b/naga/src/front/spv/function.rs index 7fefef02a2..5f8dd09608 100644 --- a/naga/src/front/spv/function.rs +++ b/naga/src/front/spv/function.rs @@ -129,7 +129,7 @@ impl> super::Frontend { local_arena: &mut fun.local_variables, const_arena: &mut module.constants, overrides: &mut module.overrides, - const_expressions: &mut module.const_expressions, + global_expressions: &mut module.global_expressions, type_arena: &module.types, global_arena: &module.global_variables, arguments: &fun.arguments, @@ -583,7 +583,7 @@ impl<'function> BlockContext<'function> { types: self.type_arena, constants: self.const_arena, overrides: self.overrides, - const_expressions: self.const_expressions, + global_expressions: self.global_expressions, } } diff --git a/naga/src/front/spv/image.rs b/naga/src/front/spv/image.rs index 0f25dd626b..21fff3f4af 100644 --- a/naga/src/front/spv/image.rs +++ b/naga/src/front/spv/image.rs @@ -508,7 +508,7 @@ impl> super::Frontend { spirv::ImageOperands::CONST_OFFSET => { let offset_constant = self.next()?; let offset_handle = self.lookup_constant.lookup(offset_constant)?.handle; - let offset_handle = ctx.const_expressions.append( + let offset_handle = ctx.global_expressions.append( crate::Expression::Constant(offset_handle), Default::default(), ); diff --git a/naga/src/front/spv/mod.rs b/naga/src/front/spv/mod.rs index 697cbb7b4e..24053cf26b 100644 --- a/naga/src/front/spv/mod.rs +++ b/naga/src/front/spv/mod.rs @@ -532,7 +532,7 @@ struct BlockContext<'function> { /// Constants arena of the module being processed const_arena: &'function mut Arena, overrides: &'function mut Arena, - const_expressions: &'function mut Arena, + global_expressions: &'function mut Arena, /// Type arena of the module being processed type_arena: &'function UniqueArena, /// Global arena of the module being processed @@ -4916,7 +4916,7 @@ impl> Frontend { let span = self.span_from_with_op(start); let init = module - .const_expressions + .global_expressions .append(crate::Expression::Literal(literal), span); self.lookup_constant.insert( id, @@ -4956,7 +4956,7 @@ impl> Frontend { let span = self.span_from_with_op(start); let constant = self.lookup_constant.lookup(component_id)?; let expr = module - .const_expressions + .global_expressions .append(crate::Expression::Constant(constant.handle), span); components.push(expr); } @@ -4966,7 +4966,7 @@ impl> Frontend { let span = self.span_from_with_op(start); let init = module - .const_expressions + .global_expressions .append(crate::Expression::Compose { ty, components }, span); self.lookup_constant.insert( id, @@ -5003,7 +5003,7 @@ impl> Frontend { let decor = self.future_decor.remove(&id).unwrap_or_default(); let init = module - .const_expressions + .global_expressions .append(crate::Expression::ZeroValue(ty), span); let handle = module.constants.append( crate::Constant { @@ -5036,7 +5036,7 @@ impl> Frontend { let decor = self.future_decor.remove(&id).unwrap_or_default(); - let init = module.const_expressions.append( + let init = module.global_expressions.append( crate::Expression::Literal(crate::Literal::Bool(value)), span, ); @@ -5075,7 +5075,7 @@ impl> Frontend { let span = self.span_from_with_op(start); let lconst = self.lookup_constant.lookup(init_id)?; let expr = module - .const_expressions + .global_expressions .append(crate::Expression::Constant(lconst.handle), span); Some(expr) } else { @@ -5197,7 +5197,7 @@ impl> Frontend { match null::generate_default_built_in( Some(built_in), ty, - &mut module.const_expressions, + &mut module.global_expressions, span, ) { Ok(handle) => Some(handle), @@ -5219,14 +5219,14 @@ impl> Frontend { let handle = null::generate_default_built_in( built_in, member.ty, - &mut module.const_expressions, + &mut module.global_expressions, span, )?; components.push(handle); } Some( module - .const_expressions + .global_expressions .append(crate::Expression::Compose { ty, components }, span), ) } @@ -5295,7 +5295,7 @@ fn resolve_constant( gctx: crate::proc::GlobalCtx, constant: Handle, ) -> Option { - match gctx.const_expressions[gctx.constants[constant].init] { + match gctx.global_expressions[gctx.constants[constant].init] { crate::Expression::Literal(crate::Literal::U32(id)) => Some(id), crate::Expression::Literal(crate::Literal::I32(id)) => Some(id as u32), _ => None, diff --git a/naga/src/front/spv/null.rs b/naga/src/front/spv/null.rs index 42cccca80a..c7d3776841 100644 --- a/naga/src/front/spv/null.rs +++ b/naga/src/front/spv/null.rs @@ -5,14 +5,14 @@ use crate::arena::{Arena, Handle}; pub fn generate_default_built_in( built_in: Option, ty: Handle, - const_expressions: &mut Arena, + global_expressions: &mut Arena, span: crate::Span, ) -> Result, Error> { let expr = match built_in { Some(crate::BuiltIn::Position { .. }) => { - let zero = const_expressions + let zero = global_expressions .append(crate::Expression::Literal(crate::Literal::F32(0.0)), span); - let one = const_expressions + let one = global_expressions .append(crate::Expression::Literal(crate::Literal::F32(1.0)), span); crate::Expression::Compose { ty, @@ -27,5 +27,5 @@ pub fn generate_default_built_in( // Note: `crate::BuiltIn::ClipDistance` is intentionally left for the default path _ => crate::Expression::ZeroValue(ty), }; - Ok(const_expressions.append(expr, span)) + Ok(global_expressions.append(expr, span)) } diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs index e689dda53a..1a8b75811b 100644 --- a/naga/src/front/wgsl/lower/mod.rs +++ b/naga/src/front/wgsl/lower/mod.rs @@ -333,9 +333,9 @@ pub struct ExpressionContext<'source, 'temp, 'out> { /// [`Module`]: crate::Module module: &'out mut crate::Module, - /// Type judgments for [`module::const_expressions`]. + /// Type judgments for [`module::global_expressions`]. /// - /// [`module::const_expressions`]: crate::Module::const_expressions + /// [`module::global_expressions`]: crate::Module::global_expressions const_typifier: &'temp mut Typifier, global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker, @@ -421,7 +421,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> { match self.expr_type { ExpressionContextType::Runtime(ref ctx) => ctx.function.expressions.get_span(handle), ExpressionContextType::Constant | ExpressionContextType::Override => { - self.module.const_expressions.get_span(handle) + self.module.global_expressions.get_span(handle) } } } @@ -554,7 +554,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> { ExpressionContextType::Constant | ExpressionContextType::Override => { resolve_ctx = ResolveContext::with_locals(self.module, &empty_arena, &[]); typifier = self.const_typifier; - expressions = &self.module.const_expressions; + expressions = &self.module.global_expressions; } }; typifier diff --git a/naga/src/front/wgsl/to_wgsl.rs b/naga/src/front/wgsl/to_wgsl.rs index ba6063ab46..63bc9f7317 100644 --- a/naga/src/front/wgsl/to_wgsl.rs +++ b/naga/src/front/wgsl/to_wgsl.rs @@ -227,7 +227,7 @@ mod tests { types: &types, constants: &crate::Arena::new(), overrides: &crate::Arena::new(), - const_expressions: &crate::Arena::new(), + global_expressions: &crate::Arena::new(), }; let array = crate::TypeInner::Array { base: mytype1, diff --git a/naga/src/lib.rs b/naga/src/lib.rs index 671fcc97c6..4b421b08fd 100644 --- a/naga/src/lib.rs +++ b/naga/src/lib.rs @@ -897,7 +897,7 @@ pub struct Override { /// The default value of the pipeline-overridable constant. /// - /// This [`Handle`] refers to [`Module::const_expressions`], not + /// This [`Handle`] refers to [`Module::global_expressions`], not /// any [`Function::expressions`] arena. pub init: Option>, } @@ -913,7 +913,7 @@ pub struct Constant { /// The value of the constant. /// - /// This [`Handle`] refers to [`Module::const_expressions`], not + /// This [`Handle`] refers to [`Module::global_expressions`], not /// any [`Function::expressions`] arena. pub init: Handle, } @@ -980,7 +980,7 @@ pub struct GlobalVariable { pub ty: Handle, /// Initial value for this variable. /// - /// Expression handle lives in const_expressions + /// Expression handle lives in global_expressions pub init: Option>, } @@ -1430,7 +1430,7 @@ pub enum Expression { gather: Option, coordinate: Handle, array_index: Option>, - /// Expression handle lives in const_expressions + /// Expression handle lives in global_expressions offset: Option>, level: SampleLevel, depth_ref: Option>, @@ -2065,7 +2065,7 @@ pub struct Module { /// /// [Constant expressions]: index.html#constant-expressions /// [override expressions]: index.html#override-expressions - pub const_expressions: Arena, + pub global_expressions: Arena, /// Arena for the functions defined in this module. /// /// Each function must appear in this arena strictly before all its callers. diff --git a/naga/src/proc/constant_evaluator.rs b/naga/src/proc/constant_evaluator.rs index 6f09ec5444..532f364532 100644 --- a/naga/src/proc/constant_evaluator.rs +++ b/naga/src/proc/constant_evaluator.rs @@ -327,7 +327,7 @@ enum GlslRestrictions<'a> { #[derive(Debug)] struct FunctionLocalData<'a> { /// Global constant expressions - const_expressions: &'a Arena, + global_expressions: &'a Arena, emitter: &'a mut super::Emitter, block: &'a mut crate::Block, } @@ -570,7 +570,7 @@ impl<'a> ConstantEvaluator<'a> { types: &mut module.types, constants: &module.constants, overrides: &module.overrides, - expressions: &mut module.const_expressions, + expressions: &mut module.global_expressions, expression_kind_tracker: global_expression_kind_tracker, } } @@ -588,7 +588,7 @@ impl<'a> ConstantEvaluator<'a> { ) -> Self { Self { behavior: Behavior::Wgsl(WgslRestrictions::Runtime(FunctionLocalData { - const_expressions: &module.const_expressions, + global_expressions: &module.global_expressions, emitter, block, })), @@ -613,7 +613,7 @@ impl<'a> ConstantEvaluator<'a> { ) -> Self { Self { behavior: Behavior::Glsl(GlslRestrictions::Runtime(FunctionLocalData { - const_expressions: &module.const_expressions, + global_expressions: &module.global_expressions, emitter, block, })), @@ -630,8 +630,8 @@ impl<'a> ConstantEvaluator<'a> { types: self.types, constants: self.constants, overrides: self.overrides, - const_expressions: match self.function_local_data() { - Some(data) => data.const_expressions, + global_expressions: match self.function_local_data() { + Some(data) => data.global_expressions, None => self.expressions, }, } @@ -657,7 +657,7 @@ impl<'a> ConstantEvaluator<'a> { // Deep-copy the constant's value into our arena. self.copy_from( self.constants[c].init, - function_local_data.const_expressions, + function_local_data.global_expressions, ) } else { // "See through" the constant and use its initializer. @@ -2202,7 +2202,7 @@ mod tests { let mut types = UniqueArena::new(); let mut constants = Arena::new(); let overrides = Arena::new(); - let mut const_expressions = Arena::new(); + let mut global_expressions = Arena::new(); let scalar_ty = types.insert( Type { @@ -2227,7 +2227,7 @@ mod tests { Constant { name: None, ty: scalar_ty, - init: const_expressions + init: global_expressions .append(Expression::Literal(Literal::I32(4)), Default::default()), }, Default::default(), @@ -2237,7 +2237,7 @@ mod tests { Constant { name: None, ty: scalar_ty, - init: const_expressions + init: global_expressions .append(Expression::Literal(Literal::I32(8)), Default::default()), }, Default::default(), @@ -2247,7 +2247,7 @@ mod tests { Constant { name: None, ty: vec_ty, - init: const_expressions.append( + init: global_expressions.append( Expression::Compose { ty: vec_ty, components: vec![constants[h].init, constants[h1].init], @@ -2258,8 +2258,8 @@ mod tests { Default::default(), ); - let expr = const_expressions.append(Expression::Constant(h), Default::default()); - let expr1 = const_expressions.append(Expression::Constant(vec_h), Default::default()); + let expr = global_expressions.append(Expression::Constant(h), Default::default()); + let expr1 = global_expressions.append(Expression::Constant(vec_h), Default::default()); let expr2 = Expression::Unary { op: UnaryOperator::Negate, @@ -2276,13 +2276,13 @@ mod tests { expr: expr1, }; - let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions); + let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions); let mut solver = ConstantEvaluator { behavior: Behavior::Wgsl(WgslRestrictions::Const), types: &mut types, constants: &constants, overrides: &overrides, - expressions: &mut const_expressions, + expressions: &mut global_expressions, expression_kind_tracker, }; @@ -2297,16 +2297,16 @@ mod tests { .unwrap(); assert_eq!( - const_expressions[res1], + global_expressions[res1], Expression::Literal(Literal::I32(-4)) ); assert_eq!( - const_expressions[res2], + global_expressions[res2], Expression::Literal(Literal::I32(!4)) ); - let res3_inner = &const_expressions[res3]; + let res3_inner = &global_expressions[res3]; match *res3_inner { Expression::Compose { @@ -2316,11 +2316,11 @@ mod tests { assert_eq!(*ty, vec_ty); let mut components_iter = components.iter().copied(); assert_eq!( - const_expressions[components_iter.next().unwrap()], + global_expressions[components_iter.next().unwrap()], Expression::Literal(Literal::I32(!4)) ); assert_eq!( - const_expressions[components_iter.next().unwrap()], + global_expressions[components_iter.next().unwrap()], Expression::Literal(Literal::I32(!8)) ); assert!(components_iter.next().is_none()); @@ -2334,7 +2334,7 @@ mod tests { let mut types = UniqueArena::new(); let mut constants = Arena::new(); let overrides = Arena::new(); - let mut const_expressions = Arena::new(); + let mut global_expressions = Arena::new(); let scalar_ty = types.insert( Type { @@ -2348,13 +2348,13 @@ mod tests { Constant { name: None, ty: scalar_ty, - init: const_expressions + init: global_expressions .append(Expression::Literal(Literal::I32(4)), Default::default()), }, Default::default(), ); - let expr = const_expressions.append(Expression::Constant(h), Default::default()); + let expr = global_expressions.append(Expression::Constant(h), Default::default()); let root = Expression::As { expr, @@ -2362,13 +2362,13 @@ mod tests { convert: Some(crate::BOOL_WIDTH), }; - let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions); + let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions); let mut solver = ConstantEvaluator { behavior: Behavior::Wgsl(WgslRestrictions::Const), types: &mut types, constants: &constants, overrides: &overrides, - expressions: &mut const_expressions, + expressions: &mut global_expressions, expression_kind_tracker, }; @@ -2377,7 +2377,7 @@ mod tests { .unwrap(); assert_eq!( - const_expressions[res], + global_expressions[res], Expression::Literal(Literal::Bool(true)) ); } @@ -2387,7 +2387,7 @@ mod tests { let mut types = UniqueArena::new(); let mut constants = Arena::new(); let overrides = Arena::new(); - let mut const_expressions = Arena::new(); + let mut global_expressions = Arena::new(); let matrix_ty = types.insert( Type { @@ -2416,7 +2416,7 @@ mod tests { let mut vec2_components = Vec::with_capacity(3); for i in 0..3 { - let h = const_expressions.append( + let h = global_expressions.append( Expression::Literal(Literal::F32(i as f32)), Default::default(), ); @@ -2425,7 +2425,7 @@ mod tests { } for i in 3..6 { - let h = const_expressions.append( + let h = global_expressions.append( Expression::Literal(Literal::F32(i as f32)), Default::default(), ); @@ -2437,7 +2437,7 @@ mod tests { Constant { name: None, ty: vec_ty, - init: const_expressions.append( + init: global_expressions.append( Expression::Compose { ty: vec_ty, components: vec1_components, @@ -2452,7 +2452,7 @@ mod tests { Constant { name: None, ty: vec_ty, - init: const_expressions.append( + init: global_expressions.append( Expression::Compose { ty: vec_ty, components: vec2_components, @@ -2467,7 +2467,7 @@ mod tests { Constant { name: None, ty: matrix_ty, - init: const_expressions.append( + init: global_expressions.append( Expression::Compose { ty: matrix_ty, components: vec![constants[vec1].init, constants[vec2].init], @@ -2478,15 +2478,15 @@ mod tests { Default::default(), ); - let base = const_expressions.append(Expression::Constant(h), Default::default()); + let base = global_expressions.append(Expression::Constant(h), Default::default()); - let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions); + let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions); let mut solver = ConstantEvaluator { behavior: Behavior::Wgsl(WgslRestrictions::Const), types: &mut types, constants: &constants, overrides: &overrides, - expressions: &mut const_expressions, + expressions: &mut global_expressions, expression_kind_tracker, }; @@ -2505,7 +2505,7 @@ mod tests { .try_eval_and_append(root2, Default::default()) .unwrap(); - match const_expressions[res1] { + match global_expressions[res1] { Expression::Compose { ref ty, ref components, @@ -2513,15 +2513,15 @@ mod tests { assert_eq!(*ty, vec_ty); let mut components_iter = components.iter().copied(); assert_eq!( - const_expressions[components_iter.next().unwrap()], + global_expressions[components_iter.next().unwrap()], Expression::Literal(Literal::F32(3.)) ); assert_eq!( - const_expressions[components_iter.next().unwrap()], + global_expressions[components_iter.next().unwrap()], Expression::Literal(Literal::F32(4.)) ); assert_eq!( - const_expressions[components_iter.next().unwrap()], + global_expressions[components_iter.next().unwrap()], Expression::Literal(Literal::F32(5.)) ); assert!(components_iter.next().is_none()); @@ -2530,7 +2530,7 @@ mod tests { } assert_eq!( - const_expressions[res2], + global_expressions[res2], Expression::Literal(Literal::F32(5.)) ); } @@ -2540,7 +2540,7 @@ mod tests { let mut types = UniqueArena::new(); let mut constants = Arena::new(); let overrides = Arena::new(); - let mut const_expressions = Arena::new(); + let mut global_expressions = Arena::new(); let i32_ty = types.insert( Type { @@ -2565,21 +2565,21 @@ mod tests { Constant { name: None, ty: i32_ty, - init: const_expressions + init: global_expressions .append(Expression::Literal(Literal::I32(4)), Default::default()), }, Default::default(), ); - let h_expr = const_expressions.append(Expression::Constant(h), Default::default()); + let h_expr = global_expressions.append(Expression::Constant(h), Default::default()); - let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions); + let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions); let mut solver = ConstantEvaluator { behavior: Behavior::Wgsl(WgslRestrictions::Const), types: &mut types, constants: &constants, overrides: &overrides, - expressions: &mut const_expressions, + expressions: &mut global_expressions, expression_kind_tracker, }; @@ -2602,11 +2602,11 @@ mod tests { ) .unwrap(); - let pass = match const_expressions[solved_negate] { + let pass = match global_expressions[solved_negate] { Expression::Compose { ty, ref components } => { ty == vec2_i32_ty && components.iter().all(|&component| { - let component = &const_expressions[component]; + let component = &global_expressions[component]; matches!(*component, Expression::Literal(Literal::I32(-4))) }) } @@ -2622,7 +2622,7 @@ mod tests { let mut types = UniqueArena::new(); let mut constants = Arena::new(); let overrides = Arena::new(); - let mut const_expressions = Arena::new(); + let mut global_expressions = Arena::new(); let i32_ty = types.insert( Type { @@ -2647,21 +2647,21 @@ mod tests { Constant { name: None, ty: i32_ty, - init: const_expressions + init: global_expressions .append(Expression::Literal(Literal::I32(4)), Default::default()), }, Default::default(), ); - let h_expr = const_expressions.append(Expression::Constant(h), Default::default()); + let h_expr = global_expressions.append(Expression::Constant(h), Default::default()); - let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions); + let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions); let mut solver = ConstantEvaluator { behavior: Behavior::Wgsl(WgslRestrictions::Const), types: &mut types, constants: &constants, overrides: &overrides, - expressions: &mut const_expressions, + expressions: &mut global_expressions, expression_kind_tracker, }; @@ -2684,11 +2684,11 @@ mod tests { ) .unwrap(); - let pass = match const_expressions[solved_negate] { + let pass = match global_expressions[solved_negate] { Expression::Compose { ty, ref components } => { ty == vec2_i32_ty && components.iter().all(|&component| { - let component = &const_expressions[component]; + let component = &global_expressions[component]; matches!(*component, Expression::Literal(Literal::I32(-4))) }) } diff --git a/naga/src/proc/mod.rs b/naga/src/proc/mod.rs index eda732978a..0e89f29032 100644 --- a/naga/src/proc/mod.rs +++ b/naga/src/proc/mod.rs @@ -649,7 +649,7 @@ impl crate::Module { types: &self.types, constants: &self.constants, overrides: &self.overrides, - const_expressions: &self.const_expressions, + global_expressions: &self.global_expressions, } } } @@ -665,17 +665,17 @@ pub struct GlobalCtx<'a> { pub types: &'a crate::UniqueArena, pub constants: &'a crate::Arena, pub overrides: &'a crate::Arena, - pub const_expressions: &'a crate::Arena, + pub global_expressions: &'a crate::Arena, } impl GlobalCtx<'_> { - /// Try to evaluate the expression in `self.const_expressions` using its `handle` and return it as a `u32`. + /// Try to evaluate the expression in `self.global_expressions` using its `handle` and return it as a `u32`. #[allow(dead_code)] pub(super) fn eval_expr_to_u32( &self, handle: crate::Handle, ) -> Result { - self.eval_expr_to_u32_from(handle, self.const_expressions) + self.eval_expr_to_u32_from(handle, self.global_expressions) } /// Try to evaluate the expression in the `arena` using its `handle` and return it as a `u32`. @@ -698,7 +698,7 @@ impl GlobalCtx<'_> { &self, handle: crate::Handle, ) -> Option { - self.eval_expr_to_literal_from(handle, self.const_expressions) + self.eval_expr_to_literal_from(handle, self.global_expressions) } fn eval_expr_to_literal_from( @@ -722,7 +722,7 @@ impl GlobalCtx<'_> { } match arena[handle] { crate::Expression::Constant(c) => { - get(*self, self.constants[c].init, self.const_expressions) + get(*self, self.constants[c].init, self.global_expressions) } _ => get(*self, handle, arena), } diff --git a/naga/src/valid/analyzer.rs b/naga/src/valid/analyzer.rs index fbb4461e38..d45c25c62e 100644 --- a/naga/src/valid/analyzer.rs +++ b/naga/src/valid/analyzer.rs @@ -1047,7 +1047,7 @@ impl ModuleInfo { gctx: crate::proc::GlobalCtx, ) -> Result<(), super::ConstExpressionError> { self.const_expression_types[handle.index()] = - resolve_context.resolve(&gctx.const_expressions[handle], |h| Ok(&self[h]))?; + resolve_context.resolve(&gctx.global_expressions[handle], |h| Ok(&self[h]))?; Ok(()) } diff --git a/naga/src/valid/expression.rs b/naga/src/valid/expression.rs index 4a1020cb78..289eb02011 100644 --- a/naga/src/valid/expression.rs +++ b/naga/src/valid/expression.rs @@ -195,7 +195,7 @@ impl super::Validator { return Err(super::ConstExpressionError::NonConstOrOverride); } - match gctx.const_expressions[handle] { + match gctx.global_expressions[handle] { E::Literal(literal) => { self.validate_literal(literal)?; } @@ -1729,7 +1729,7 @@ fn validate_with_const_expression( use crate::span::Span; let mut module = crate::Module::default(); - module.const_expressions.append(expr, Span::default()); + module.global_expressions.append(expr, Span::default()); let mut validator = super::Validator::new(super::ValidationFlags::CONSTANTS, caps); diff --git a/naga/src/valid/handles.rs b/naga/src/valid/handles.rs index bcda98b294..5d3087a28f 100644 --- a/naga/src/valid/handles.rs +++ b/naga/src/valid/handles.rs @@ -37,7 +37,7 @@ impl super::Validator { ref global_variables, ref types, ref special_types, - ref const_expressions, + ref global_expressions, } = module; // NOTE: Types being first is important. All other forms of validation depend on this. @@ -68,13 +68,13 @@ impl super::Validator { } } - for handle_and_expr in const_expressions.iter() { + for handle_and_expr in global_expressions.iter() { Self::validate_const_expression_handles(handle_and_expr, constants, overrides, types)?; } let validate_type = |handle| Self::validate_type_handle(handle, types); let validate_const_expr = - |handle| Self::validate_expression_handle(handle, const_expressions); + |handle| Self::validate_expression_handle(handle, global_expressions); for (_handle, constant) in constants.iter() { let &crate::Constant { name: _, ty, init } = constant; @@ -150,7 +150,7 @@ impl super::Validator { handle_and_expr, constants, overrides, - const_expressions, + global_expressions, types, local_variables, global_variables, @@ -256,7 +256,7 @@ impl super::Validator { (handle, expression): (Handle, &crate::Expression), constants: &Arena, overrides: &Arena, - const_expressions: &Arena, + global_expressions: &Arena, types: &UniqueArena, local_variables: &Arena, global_variables: &Arena, @@ -267,7 +267,7 @@ impl super::Validator { let validate_constant = |handle| Self::validate_constant_handle(handle, constants); let validate_override = |handle| Self::validate_override_handle(handle, overrides); let validate_const_expr = - |handle| Self::validate_expression_handle(handle, const_expressions); + |handle| Self::validate_expression_handle(handle, global_expressions); let validate_type = |handle| Self::validate_type_handle(handle, types); match *expression { diff --git a/naga/src/valid/mod.rs b/naga/src/valid/mod.rs index 72da6377d9..b9730c1f3d 100644 --- a/naga/src/valid/mod.rs +++ b/naga/src/valid/mod.rs @@ -435,7 +435,7 @@ impl Validator { type_flags: Vec::with_capacity(module.types.len()), functions: Vec::with_capacity(module.functions.len()), entry_points: Vec::with_capacity(module.entry_points.len()), - const_expression_types: vec![placeholder; module.const_expressions.len()] + const_expression_types: vec![placeholder; module.global_expressions.len()] .into_boxed_slice(), }; @@ -457,20 +457,20 @@ impl Validator { { let t = crate::Arena::new(); let resolve_context = crate::proc::ResolveContext::with_locals(module, &t, &[]); - for (handle, _) in module.const_expressions.iter() { + for (handle, _) in module.global_expressions.iter() { mod_info .process_const_expression(handle, &resolve_context, module.to_ctx()) .map_err(|source| { ValidationError::ConstExpression { handle, source } - .with_span_handle(handle, &module.const_expressions) + .with_span_handle(handle, &module.global_expressions) })? } } - let global_expr_kind = ExpressionKindTracker::from_arena(&module.const_expressions); + let global_expr_kind = ExpressionKindTracker::from_arena(&module.global_expressions); if self.flags.contains(ValidationFlags::CONSTANTS) { - for (handle, _) in module.const_expressions.iter() { + for (handle, _) in module.global_expressions.iter() { self.validate_const_expression( handle, module.to_ctx(), @@ -479,7 +479,7 @@ impl Validator { ) .map_err(|source| { ValidationError::ConstExpression { handle, source } - .with_span_handle(handle, &module.const_expressions) + .with_span_handle(handle, &module.global_expressions) })? } diff --git a/naga/tests/out/ir/access.compact.ron b/naga/tests/out/ir/access.compact.ron index 37ace5283f..4bae535e64 100644 --- a/naga/tests/out/ir/access.compact.ron +++ b/naga/tests/out/ir/access.compact.ron @@ -378,7 +378,7 @@ init: None, ), ], - const_expressions: [ + global_expressions: [ Literal(U32(0)), Literal(U32(0)), Literal(U32(0)), diff --git a/naga/tests/out/ir/access.ron b/naga/tests/out/ir/access.ron index 37ace5283f..4bae535e64 100644 --- a/naga/tests/out/ir/access.ron +++ b/naga/tests/out/ir/access.ron @@ -378,7 +378,7 @@ init: None, ), ], - const_expressions: [ + global_expressions: [ Literal(U32(0)), Literal(U32(0)), Literal(U32(0)), diff --git a/naga/tests/out/ir/collatz.compact.ron b/naga/tests/out/ir/collatz.compact.ron index fe4af55c1b..3312ddbf77 100644 --- a/naga/tests/out/ir/collatz.compact.ron +++ b/naga/tests/out/ir/collatz.compact.ron @@ -61,7 +61,7 @@ init: None, ), ], - const_expressions: [], + global_expressions: [], functions: [ ( name: Some("collatz_iterations"), diff --git a/naga/tests/out/ir/collatz.ron b/naga/tests/out/ir/collatz.ron index fe4af55c1b..3312ddbf77 100644 --- a/naga/tests/out/ir/collatz.ron +++ b/naga/tests/out/ir/collatz.ron @@ -61,7 +61,7 @@ init: None, ), ], - const_expressions: [], + global_expressions: [], functions: [ ( name: Some("collatz_iterations"), diff --git a/naga/tests/out/ir/overrides.compact.ron b/naga/tests/out/ir/overrides.compact.ron index d15abbd033..7a60f14239 100644 --- a/naga/tests/out/ir/overrides.compact.ron +++ b/naga/tests/out/ir/overrides.compact.ron @@ -66,7 +66,7 @@ ), ], global_variables: [], - const_expressions: [ + global_expressions: [ Literal(Bool(true)), Literal(F32(2.3)), Literal(F32(0.0)), diff --git a/naga/tests/out/ir/overrides.ron b/naga/tests/out/ir/overrides.ron index d15abbd033..7a60f14239 100644 --- a/naga/tests/out/ir/overrides.ron +++ b/naga/tests/out/ir/overrides.ron @@ -66,7 +66,7 @@ ), ], global_variables: [], - const_expressions: [ + global_expressions: [ Literal(Bool(true)), Literal(F32(2.3)), Literal(F32(0.0)), diff --git a/naga/tests/out/ir/shadow.compact.ron b/naga/tests/out/ir/shadow.compact.ron index fab0f1e2f6..45d819b9e0 100644 --- a/naga/tests/out/ir/shadow.compact.ron +++ b/naga/tests/out/ir/shadow.compact.ron @@ -319,7 +319,7 @@ init: None, ), ], - const_expressions: [ + global_expressions: [ Literal(F32(0.0)), Literal(F32(1.0)), Literal(F32(0.5)), diff --git a/naga/tests/out/ir/shadow.ron b/naga/tests/out/ir/shadow.ron index 9acbbdaadd..523c6d4192 100644 --- a/naga/tests/out/ir/shadow.ron +++ b/naga/tests/out/ir/shadow.ron @@ -522,7 +522,7 @@ init: None, ), ], - const_expressions: [ + global_expressions: [ Literal(F32(0.0)), Literal(F32(1.0)), Literal(F32(0.5)),