From 936d882d31340126bfb67725607c6ad4dbb8cf64 Mon Sep 17 00:00:00 2001 From: Jim Blandy Date: Wed, 5 Feb 2025 10:58:35 -0800 Subject: [PATCH] [naga] Use `r#override` instead of `override_`. Use the standard Rust reserved identifier syntax for `override`, rather than the non-standard trailing underscore. --- naga/src/back/pipeline_constants.rs | 18 +++++++++--------- naga/src/compact/mod.rs | 12 ++++++------ naga/src/valid/handles.rs | 20 ++++++++++---------- naga/src/valid/mod.rs | 4 ++-- 4 files changed, 27 insertions(+), 27 deletions(-) diff --git a/naga/src/back/pipeline_constants.rs b/naga/src/back/pipeline_constants.rs index bb9fb7f448..ef498b6554 100644 --- a/naga/src/back/pipeline_constants.rs +++ b/naga/src/back/pipeline_constants.rs @@ -305,7 +305,7 @@ fn process_workgroup_size_override( /// /// Add the new `Constant` to `override_map` and `adjusted_constant_initializers`. fn process_override( - (old_h, override_, span): (Handle, Override, Span), + (old_h, r#override, span): (Handle, Override, Span), pipeline_constants: &PipelineConstants, module: &mut Module, override_map: &mut HandleVec>, @@ -313,20 +313,20 @@ fn process_override( adjusted_constant_initializers: &mut HashSet>, global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker, ) -> Result, PipelineConstantError> { - // Determine which key to use for `override_` in `pipeline_constants`. - let key = if let Some(id) = override_.id { + // Determine which key to use for `r#override` in `pipeline_constants`. + let key = if let Some(id) = r#override.id { Cow::Owned(id.to_string()) - } else if let Some(ref name) = override_.name { + } else if let Some(ref name) = r#override.name { Cow::Borrowed(name) } else { unreachable!(); }; - // Generate a global expression for `override_`'s value, either + // Generate a global expression for `r#override`'s value, either // from the provided `pipeline_constants` table or its initializer // in the module. let init = if let Some(value) = pipeline_constants.get::(&key) { - let literal = match module.types[override_.ty].inner { + let literal = match module.types[r#override.ty].inner { TypeInner::Scalar(scalar) => map_value_to_literal(*value, scalar)?, _ => unreachable!(), }; @@ -335,7 +335,7 @@ fn process_override( .append(Expression::Literal(literal), Span::UNDEFINED); global_expression_kind_tracker.insert(expr, crate::proc::ExpressionKind::Const); expr - } else if let Some(init) = override_.init { + } else if let Some(init) = r#override.init { adjusted_global_expressions[init] } else { return Err(PipelineConstantError::MissingValue(key.to_string())); @@ -343,8 +343,8 @@ fn process_override( // Generate a new `Constant` to represent the override's value. let constant = Constant { - name: override_.name, - ty: override_.ty, + name: r#override.name, + ty: r#override.ty, init, }; let h = module.constants.append(constant, span); diff --git a/naga/src/compact/mod.rs b/naga/src/compact/mod.rs index 929888b7e5..cfa2e89a03 100644 --- a/naga/src/compact/mod.rs +++ b/naga/src/compact/mod.rs @@ -56,9 +56,9 @@ pub fn compact(module: &mut crate::Module) { } // We treat all overrides as used by definition. - for (_, override_) in module.overrides.iter() { - module_tracer.types_used.insert(override_.ty); - if let Some(init) = override_.init { + for (_, r#override) in module.overrides.iter() { + module_tracer.types_used.insert(r#override.ty); + if let Some(init) = r#override.init { module_tracer.global_expressions_used.insert(init); } } @@ -169,9 +169,9 @@ pub fn compact(module: &mut crate::Module) { // Adjust override types and initializers. log::trace!("adjusting overrides"); - for (_, override_) in module.overrides.iter_mut() { - module_map.types.adjust(&mut override_.ty); - if let Some(init) = override_.init.as_mut() { + for (_, r#override) in module.overrides.iter_mut() { + module_map.types.adjust(&mut r#override.ty); + if let Some(init) = r#override.init.as_mut() { module_map.global_expressions.adjust(init); } } diff --git a/naga/src/valid/handles.rs b/naga/src/valid/handles.rs index 260d442c79..f3b360f760 100644 --- a/naga/src/valid/handles.rs +++ b/naga/src/valid/handles.rs @@ -139,13 +139,13 @@ impl super::Validator { validate_const_expr(init)?; } - for (_handle, override_) in overrides.iter() { + for (_handle, r#override) in overrides.iter() { let &crate::Override { name: _, id: _, ty, init, - } = override_; + } = r#override; validate_type(ty)?; if let Some(init_expr) = init { validate_const_expr(init_expr)?; @@ -323,9 +323,9 @@ impl super::Validator { crate::PendingArraySize::Expression(expr) => Some(expr), crate::PendingArraySize::Override(h) => { Self::validate_override_handle(h, overrides)?; - let override_ = &overrides[h]; - handle.check_dep(override_.ty)?; - override_.init + let r#override = &overrides[h]; + handle.check_dep(r#override.ty)?; + r#override.init } }, crate::ArraySize::Constant(_) | crate::ArraySize::Dynamic => None, @@ -363,9 +363,9 @@ impl super::Validator { handle.check_dep(constants[constant].init)?; None } - crate::Expression::Override(override_) => { - validate_override(override_)?; - if let Some(init) = overrides[override_].init { + crate::Expression::Override(r#override) => { + validate_override(r#override)?; + if let Some(init) = overrides[r#override].init { handle.check_dep(init)?; } None @@ -416,8 +416,8 @@ impl super::Validator { crate::Expression::Constant(constant) => { validate_constant(constant)?; } - crate::Expression::Override(override_) => { - validate_override(override_)?; + crate::Expression::Override(r#override) => { + validate_override(r#override)?; } crate::Expression::ZeroValue(ty) => { validate_type(ty)?; diff --git a/naga/src/valid/mod.rs b/naga/src/valid/mod.rs index 906d449362..a6380cbe1e 100644 --- a/naga/src/valid/mod.rs +++ b/naga/src/valid/mod.rs @@ -686,12 +686,12 @@ impl Validator { })? } - for (handle, override_) in module.overrides.iter() { + for (handle, r#override) in module.overrides.iter() { self.validate_override(handle, module.to_ctx(), &mod_info) .map_err(|source| { ValidationError::Override { handle, - name: override_.name.clone().unwrap_or_default(), + name: r#override.name.clone().unwrap_or_default(), source, } .with_span_handle(handle, &module.overrides)