[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

@@ -305,28 +305,28 @@ 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>, Override, Span),
+    (old_h, r#override, span): (Handle<Override>, Override, Span),
     pipeline_constants: &PipelineConstants,
     module: &mut Module,
     override_map: &mut HandleVec<Override, Handle<Constant>>,
     adjusted_global_expressions: &HandleVec<Expression, Handle<Expression>>,
     adjusted_constant_initializers: &mut HashSet<Handle<Constant>>,
     global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker,
 ) -> Result<Handle<Constant>, 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::<str>(&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,16 +335,16 @@ 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()));
     };
 
     // 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);

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);
         }
     }

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)?;

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)