Always pass the visitor as the first argument to walk* functions

Author: oli-obk

compiler/rustc_ast/src/mut_visit.rs

@@ -212,72 +212,83 @@ impl MutVisitor for CfgEval<'_> {
     #[instrument(level = "trace", skip(self))]
     fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
         self.0.configure_expr(expr, false);
-        mut_visit::walk_expr(expr, self);
+        mut_visit::walk_expr(self, expr);
     }
 
     #[instrument(level = "trace", skip(self))]
     fn visit_method_receiver_expr(&mut self, expr: &mut P<ast::Expr>) {
         self.0.configure_expr(expr, true);
-        mut_visit::walk_expr(expr, self);
+        mut_visit::walk_expr(self, expr);
     }
 
     fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
         let mut expr = configure!(self, expr);
-        mut_visit::walk_expr(&mut expr, self);
+        mut_visit::walk_expr(self, &mut expr);
         Some(expr)
     }
 
     fn flat_map_generic_param(
         &mut self,
         param: ast::GenericParam,
     ) -> SmallVec<[ast::GenericParam; 1]> {
-        mut_visit::walk_generic_param(configure!(self, param), self)
+        let param = configure!(self, param);
+        mut_visit::walk_generic_param(self, param)
     }
 
     fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
-        mut_visit::walk_stmt(configure!(self, stmt), self)
+        let stmt = configure!(self, stmt);
+        mut_visit::walk_stmt(self, stmt)
     }
 
     fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
-        mut_visit::walk_item(configure!(self, item), None, self)
+        let item = configure!(self, item);
+        mut_visit::walk_item(self, item, None)
     }
 
     fn flat_map_assoc_item(
         &mut self,
         item: P<ast::AssocItem>,
         ctxt: AssocCtxt,
     ) -> SmallVec<[P<ast::AssocItem>; 1]> {
-        mut_visit::walk_item(configure!(self, item), Some(ctxt), self)
+        let item = configure!(self, item);
+        mut_visit::walk_item(self, item, Some(ctxt))
     }
 
     fn flat_map_foreign_item(
         &mut self,
         foreign_item: P<ast::ForeignItem>,
     ) -> SmallVec<[P<ast::ForeignItem>; 1]> {
-        mut_visit::walk_item(configure!(self, foreign_item), None, self)
+        let foreign_item = configure!(self, foreign_item);
+        mut_visit::walk_item(self, foreign_item, None)
     }
 
     fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
-        mut_visit::walk_arm(configure!(self, arm), self)
+        let arm = configure!(self, arm);
+        mut_visit::walk_arm(self, arm)
     }
 
     fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
-        mut_visit::walk_expr_field(configure!(self, field), self)
+        let field = configure!(self, field);
+        mut_visit::walk_expr_field(self, field)
     }
 
     fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
-        mut_visit::walk_pat_field(configure!(self, fp), self)
+        let fp = configure!(self, fp);
+        mut_visit::walk_pat_field(self, fp)
     }
 
     fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
-        mut_visit::walk_param(configure!(self, p), self)
+        let p = configure!(self, p);
+        mut_visit::walk_param(self, p)
     }
 
     fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
-        mut_visit::walk_field_def(configure!(self, sf), self)
+        let sf = configure!(self, sf);
+        mut_visit::walk_field_def(self, sf)
     }
 
     fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
-        mut_visit::walk_variant(configure!(self, variant), self)
+        let variant = configure!(self, variant);
+        mut_visit::walk_variant(self, variant)
     }
 }

compiler/rustc_builtin_macros/src/cfg_eval.rs

@@ -122,7 +122,7 @@ impl TestHarnessGenerator<'_> {
 impl<'a> MutVisitor for TestHarnessGenerator<'a> {
     fn visit_crate(&mut self, c: &mut ast::Crate) {
         let prev_tests = mem::take(&mut self.tests);
-        mut_visit::walk_crate(c, self);
+        mut_visit::walk_crate(self, c);
         self.add_test_cases(ast::CRATE_NODE_ID, c.spans.inner_span, prev_tests);
 
         // Create a main function to run our tests
@@ -192,7 +192,7 @@ struct EntryPointCleaner<'a> {
 impl<'a> MutVisitor for EntryPointCleaner<'a> {
     fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
         self.depth += 1;
-        let item = mut_visit::walk_item(i, None, self).expect_one("noop did something");
+        let item = mut_visit::walk_item(self, i, None).expect_one("noop did something");
         self.depth -= 1;
 
         // Remove any #[rustc_main] or #[start] from the AST so it doesn't

compiler/rustc_builtin_macros/src/test_harness.rs

@@ -1149,7 +1149,7 @@ impl InvocationCollectorNode for P<ast::Item> {
         fragment.make_items()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_item(self, None, visitor)
+        walk_item(visitor, self, None)
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.kind, ItemKind::MacCall(..))
@@ -1293,7 +1293,7 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::AssocItem>, TraitItemTag>
         fragment.make_trait_items()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_item(self.wrapped, Some(AssocCtxt::Trait), visitor)
+        walk_item(visitor, self.wrapped, Some(AssocCtxt::Trait))
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.wrapped.kind, AssocItemKind::MacCall(..))
@@ -1334,7 +1334,7 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::AssocItem>, ImplItemTag>
         fragment.make_impl_items()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_item(self.wrapped, Some(AssocCtxt::Impl), visitor)
+        walk_item(visitor, self.wrapped, Some(AssocCtxt::Impl))
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.wrapped.kind, AssocItemKind::MacCall(..))
@@ -1372,7 +1372,7 @@ impl InvocationCollectorNode for P<ast::ForeignItem> {
         fragment.make_foreign_items()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_item(self, None, visitor)
+        walk_item(visitor, self, None)
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.kind, ForeignItemKind::MacCall(..))
@@ -1395,7 +1395,7 @@ impl InvocationCollectorNode for ast::Variant {
         fragment.make_variants()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_variant(self, visitor)
+        walk_variant(visitor, self)
     }
 }
 
@@ -1408,7 +1408,7 @@ impl InvocationCollectorNode for ast::FieldDef {
         fragment.make_field_defs()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_field_def(self, visitor)
+        walk_field_def(visitor, self)
     }
 }
 
@@ -1421,7 +1421,7 @@ impl InvocationCollectorNode for ast::PatField {
         fragment.make_pat_fields()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_pat_field(self, visitor)
+        walk_pat_field(visitor, self)
     }
 }
 
@@ -1434,7 +1434,7 @@ impl InvocationCollectorNode for ast::ExprField {
         fragment.make_expr_fields()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_expr_field(self, visitor)
+        walk_expr_field(visitor, self)
     }
 }
 
@@ -1447,7 +1447,7 @@ impl InvocationCollectorNode for ast::Param {
         fragment.make_params()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_param(self, visitor)
+        walk_param(visitor, self)
     }
 }
 
@@ -1460,7 +1460,7 @@ impl InvocationCollectorNode for ast::GenericParam {
         fragment.make_generic_params()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_generic_param(self, visitor)
+        walk_generic_param(visitor, self)
     }
 }
 
@@ -1473,7 +1473,7 @@ impl InvocationCollectorNode for ast::Arm {
         fragment.make_arms()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_arm(self, visitor)
+        walk_arm(visitor, self)
     }
 }
 
@@ -1487,7 +1487,7 @@ impl InvocationCollectorNode for ast::Stmt {
         fragment.make_stmts()
     }
     fn walk_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_stmt(self, visitor)
+        walk_stmt(visitor, self)
     }
     fn is_mac_call(&self) -> bool {
         match &self.kind {
@@ -1561,7 +1561,7 @@ impl InvocationCollectorNode for ast::Crate {
         fragment.make_crate()
     }
     fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
-        walk_crate(self, visitor)
+        walk_crate(visitor, self)
     }
     fn expand_cfg_false(
         &mut self,
@@ -1587,7 +1587,7 @@ impl InvocationCollectorNode for P<ast::Ty> {
         fragment.make_ty()
     }
     fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
-        walk_ty(self, visitor)
+        walk_ty(visitor, self)
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.kind, ast::TyKind::MacCall(..))
@@ -1611,7 +1611,7 @@ impl InvocationCollectorNode for P<ast::Pat> {
         fragment.make_pat()
     }
     fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
-        walk_pat(self, visitor)
+        walk_pat(visitor, self)
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.kind, PatKind::MacCall(..))
@@ -1639,7 +1639,7 @@ impl InvocationCollectorNode for P<ast::Expr> {
         "an expression"
     }
     fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
-        walk_expr(self, visitor)
+        walk_expr(visitor, self)
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.kind, ExprKind::MacCall(..))
@@ -1665,7 +1665,7 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::Expr>, OptExprTag> {
         fragment.make_opt_expr()
     }
     fn walk_map<V: MutVisitor>(mut self, visitor: &mut V) -> Self::OutputTy {
-        walk_expr(&mut self.wrapped, visitor);
+        walk_expr(visitor, &mut self.wrapped);
         Some(self.wrapped)
     }
     fn is_mac_call(&self) -> bool {
@@ -1705,7 +1705,7 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::Expr>, MethodReceiverTag>
         AstNodeWrapper::new(fragment.make_method_receiver_expr(), MethodReceiverTag)
     }
     fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
-        mut_visit::walk_expr(&mut self.wrapped, visitor)
+        mut_visit::walk_expr(visitor, &mut self.wrapped)
     }
     fn is_mac_call(&self) -> bool {
         matches!(self.wrapped.kind, ast::ExprKind::MacCall(..))
@@ -2147,11 +2147,11 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
                     self.cx.current_expansion.is_trailing_mac = true;
                     // Don't use `assign_id` for this statement - it may get removed
                     // entirely due to a `#[cfg]` on the contained expression
-                    let res = walk_stmt(node, self);
+                    let res = walk_stmt(self, node);
                     self.cx.current_expansion.is_trailing_mac = false;
                     res
                 }
-                _ => walk_stmt(node, self),
+                _ => walk_stmt(self, node),
             };
         }
 
@@ -2195,7 +2195,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
             &mut self.cx.current_expansion.dir_ownership,
             DirOwnership::UnownedViaBlock,
         );
-        walk_block(node, self);
+        walk_block(self, node);
         self.cx.current_expansion.dir_ownership = orig_dir_ownership;
     }
 

compiler/rustc_expand/src/expand.rs

@@ -332,7 +332,7 @@ pub(super) fn transcribe<'a>(
             // jump back out of the Delimited, pop the result_stack and add the new results back to
             // the previous results (from outside the Delimited).
             mbe::TokenTree::Delimited(mut span, spacing, delimited) => {
-                mut_visit::visit_delim_span(&mut span, &mut marker);
+                mut_visit::visit_delim_span(&mut marker, &mut span);
                 stack.push(Frame::new_delimited(delimited, span, *spacing));
                 result_stack.push(mem::take(&mut result));
             }
@@ -341,7 +341,7 @@ pub(super) fn transcribe<'a>(
             // preserve syntax context.
             mbe::TokenTree::Token(token) => {
                 let mut token = token.clone();
-                mut_visit::visit_token(&mut token, &mut marker);
+                mut_visit::visit_token(&mut marker, &mut token);
                 let tt = TokenTree::Token(token, Spacing::Alone);
                 result.push(tt);
             }