Make mut_visit::WalkItemKind the same as visit::WalkItemKind

Author: maxcabrajac

compiler/rustc_ast/src/visitors.rs

@@ -1788,8 +1788,8 @@ pub mod mut_visit {
         }
     }
 
-    pub trait WalkItemKind {
-        fn walk(&mut self, span: Span, id: NodeId, visitor: &mut impl MutVisitor);
+    pub trait WalkItemKind: Sized {
+        fn walk(item: &mut Item<Self>, visitor: &mut impl MutVisitor);
     }
 
     make_ast_visitor!(MutVisitor, mut);
@@ -2279,69 +2279,65 @@ pub mod mut_visit {
         }
     }
 
-    pub fn walk_item_kind(
-        kind: &mut impl WalkItemKind,
-        span: Span,
-        id: NodeId,
-        vis: &mut impl MutVisitor,
-    ) {
-        kind.walk(span, id, vis)
-    }
-
     impl WalkItemKind for ItemKind {
-        fn walk(&mut self, span: Span, id: NodeId, vis: &mut impl MutVisitor) {
-            match self {
+        fn walk(item: &mut Item<Self>, visitor: &mut impl MutVisitor) {
+            let Item { attrs, id, span, vis, ident, kind, tokens } = item;
+            visitor.visit_id(id);
+            visit_attrs(visitor, attrs);
+            visitor.visit_vis(vis);
+            visitor.visit_ident(ident);
+            match kind {
                 ItemKind::ExternCrate(_orig_name) => {}
-                ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree, id, false),
+                ItemKind::Use(use_tree) => visitor.visit_use_tree(use_tree, *id, false),
                 ItemKind::Static(box StaticItem { ty, safety: _, mutability: _, expr }) => {
-                    vis.visit_ty(ty);
-                    visit_opt(expr, |expr| vis.visit_expr(expr));
+                    visitor.visit_ty(ty);
+                    visit_opt(expr, |expr| visitor.visit_expr(expr));
                 }
                 ItemKind::Const(item) => {
-                    visit_const_item(item, vis);
+                    visit_const_item(item, visitor);
                 }
                 ItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
-                    visit_defaultness(vis, defaultness);
-                    vis.visit_fn(FnKind::Fn(sig, generics, body), span, id);
+                    visit_defaultness(visitor, defaultness);
+                    visitor.visit_fn(FnKind::Fn(sig, generics, body), *span, *id);
                 }
                 ItemKind::Mod(safety, mod_kind) => {
-                    visit_safety(vis, safety);
+                    visit_safety(visitor, safety);
                     match mod_kind {
                         ModKind::Loaded(
                             items,
                             _inline,
                             ModSpans { inner_span, inject_use_span },
                         ) => {
-                            items.flat_map_in_place(|item| vis.flat_map_item(item));
-                            vis.visit_span(inner_span);
-                            vis.visit_span(inject_use_span);
+                            items.flat_map_in_place(|item| visitor.flat_map_item(item));
+                            visitor.visit_span(inner_span);
+                            visitor.visit_span(inject_use_span);
                         }
                         ModKind::Unloaded => {}
                     }
                 }
-                ItemKind::ForeignMod(nm) => vis.visit_foreign_mod(nm),
-                ItemKind::GlobalAsm(asm) => vis.visit_inline_asm(asm),
+                ItemKind::ForeignMod(nm) => visitor.visit_foreign_mod(nm),
+                ItemKind::GlobalAsm(asm) => visitor.visit_inline_asm(asm),
                 ItemKind::TyAlias(box TyAlias {
                     defaultness,
                     generics,
                     where_clauses,
                     bounds,
                     ty,
                 }) => {
-                    visit_defaultness(vis, defaultness);
-                    vis.visit_generics(generics);
-                    visit_bounds(vis, bounds, BoundKind::Bound);
-                    visit_opt(ty, |ty| vis.visit_ty(ty));
-                    walk_ty_alias_where_clauses(vis, where_clauses);
+                    visit_defaultness(visitor, defaultness);
+                    visitor.visit_generics(generics);
+                    visit_bounds(visitor, bounds, BoundKind::Bound);
+                    visit_opt(ty, |ty| visitor.visit_ty(ty));
+                    walk_ty_alias_where_clauses(visitor, where_clauses);
                 }
                 ItemKind::Enum(enum_def, generics) => {
-                    vis.visit_generics(generics);
-                    vis.visit_enum_def(enum_def);
+                    visitor.visit_generics(generics);
+                    visitor.visit_enum_def(enum_def);
                 }
                 ItemKind::Struct(variant_data, generics)
                 | ItemKind::Union(variant_data, generics) => {
-                    vis.visit_generics(generics);
-                    vis.visit_variant_data(variant_data);
+                    visitor.visit_generics(generics);
+                    visitor.visit_variant_data(variant_data);
                 }
                 ItemKind::Impl(box Impl {
                     defaultness,
@@ -2353,27 +2349,27 @@ pub mod mut_visit {
                     self_ty,
                     items,
                 }) => {
-                    visit_defaultness(vis, defaultness);
-                    visit_safety(vis, safety);
-                    vis.visit_generics(generics);
-                    visit_constness(vis, constness);
-                    visit_polarity(vis, polarity);
-                    visit_opt(of_trait, |trait_ref| vis.visit_trait_ref(trait_ref));
-                    vis.visit_ty(self_ty);
-                    items.flat_map_in_place(|item| vis.flat_map_assoc_item(item, AssocCtxt::Impl));
+                    visit_defaultness(visitor, defaultness);
+                    visit_safety(visitor, safety);
+                    visitor.visit_generics(generics);
+                    visit_constness(visitor, constness);
+                    visit_polarity(visitor, polarity);
+                    visit_opt(of_trait, |trait_ref| visitor.visit_trait_ref(trait_ref));
+                    visitor.visit_ty(self_ty);
+                    items.flat_map_in_place(|item| visitor.flat_map_assoc_item(item, AssocCtxt::Impl));
                 }
                 ItemKind::Trait(box Trait { safety, is_auto: _, generics, bounds, items }) => {
-                    visit_safety(vis, safety);
-                    vis.visit_generics(generics);
-                    visit_bounds(vis, bounds, BoundKind::Bound);
-                    items.flat_map_in_place(|item| vis.flat_map_assoc_item(item, AssocCtxt::Trait));
+                    visit_safety(visitor, safety);
+                    visitor.visit_generics(generics);
+                    visit_bounds(visitor, bounds, BoundKind::Bound);
+                    items.flat_map_in_place(|item| visitor.flat_map_assoc_item(item, AssocCtxt::Trait));
                 }
                 ItemKind::TraitAlias(generics, bounds) => {
-                    vis.visit_generics(generics);
-                    visit_bounds(vis, bounds, BoundKind::Bound);
+                    visitor.visit_generics(generics);
+                    visit_bounds(visitor, bounds, BoundKind::Bound);
                 }
-                ItemKind::MacCall(m) => vis.visit_mac_call(m),
-                ItemKind::MacroDef(def) => vis.visit_macro_def(def),
+                ItemKind::MacCall(m) => visitor.visit_mac_call(m),
+                ItemKind::MacroDef(def) => visitor.visit_macro_def(def),
                 ItemKind::Delegation(box Delegation {
                     id,
                     qself,
@@ -2382,44 +2378,51 @@ pub mod mut_visit {
                     body,
                     from_glob: _,
                 }) => {
-                    vis.visit_id(id);
-                    vis.visit_qself(qself);
-                    vis.visit_path(path, *id);
+                    visitor.visit_id(id);
+                    visitor.visit_qself(qself);
+                    visitor.visit_path(path, *id);
                     if let Some(rename) = rename {
-                        vis.visit_ident(rename);
+                        visitor.visit_ident(rename);
                     }
                     if let Some(body) = body {
-                        vis.visit_block(body);
+                        visitor.visit_block(body);
                     }
                 }
                 ItemKind::DelegationMac(box DelegationMac { qself, prefix, suffixes, body }) => {
-                    vis.visit_qself(qself);
-                    vis.visit_path(prefix, id);
+                    visitor.visit_qself(qself);
+                    visitor.visit_path(prefix, *id);
                     if let Some(suffixes) = suffixes {
                         for (ident, rename) in suffixes {
-                            vis.visit_ident(ident);
+                            visitor.visit_ident(ident);
                             if let Some(rename) = rename {
-                                vis.visit_ident(rename);
+                                visitor.visit_ident(rename);
                             }
                         }
                     }
                     if let Some(body) = body {
-                        vis.visit_block(body);
+                        visitor.visit_block(body);
                     }
                 }
             }
+            visit_lazy_tts(visitor, tokens);
+            visitor.visit_span(span);
         }
     }
 
     impl WalkItemKind for AssocItemKind {
-        fn walk(&mut self, span: Span, id: NodeId, visitor: &mut impl MutVisitor) {
-            match self {
+        fn walk(item: &mut Item<Self>, visitor: &mut impl MutVisitor) {
+            let Item { attrs, id, span, vis, ident, kind, tokens } = item;
+            visitor.visit_id(id);
+            visit_attrs(visitor, attrs);
+            visitor.visit_vis(vis);
+            visitor.visit_ident(ident);
+            match kind {
                 AssocItemKind::Const(item) => {
                     visit_const_item(item, visitor);
                 }
                 AssocItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
                     visit_defaultness(visitor, defaultness);
-                    visitor.visit_fn(FnKind::Fn(sig, generics, body), span, id);
+                    visitor.visit_fn(FnKind::Fn(sig, generics, body), *span, *id);
                 }
                 AssocItemKind::Type(box TyAlias {
                     defaultness,
@@ -2460,7 +2463,7 @@ pub mod mut_visit {
                     body,
                 }) => {
                     visitor.visit_qself(qself);
-                    visitor.visit_path(prefix, id);
+                    visitor.visit_path(prefix, *id);
                     if let Some(suffixes) = suffixes {
                         for (ident, rename) in suffixes {
                             visitor.visit_ident(ident);
@@ -2474,6 +2477,8 @@ pub mod mut_visit {
                     }
                 }
             }
+            visit_lazy_tts(visitor, tokens);
+            visitor.visit_span(span);
         }
     }
 
@@ -2494,32 +2499,33 @@ pub mod mut_visit {
         visit_safety(vis, safety);
     }
 
+    pub fn walk_item<K: WalkItemKind>(visitor: &mut impl MutVisitor, item: &mut Item<K>) {
+        K::walk(item, visitor);
+    }
     /// Mutates one item, returning the item again.
     pub fn walk_flat_map_item<K: WalkItemKind>(
         visitor: &mut impl MutVisitor,
         mut item: P<Item<K>>,
     ) -> SmallVec<[P<Item<K>>; 1]> {
-        let Item { ident, attrs, id, kind, vis, span, tokens } = item.deref_mut();
-        visitor.visit_id(id);
-        visit_attrs(visitor, attrs);
-        visitor.visit_vis(vis);
-        visitor.visit_ident(ident);
-        kind.walk(*span, *id, visitor);
-        visit_lazy_tts(visitor, tokens);
-        visitor.visit_span(span);
+        walk_item(visitor, item.deref_mut());
         smallvec![item]
     }
 
     impl WalkItemKind for ForeignItemKind {
-        fn walk(&mut self, span: Span, id: NodeId, visitor: &mut impl MutVisitor) {
-            match self {
+        fn walk(item: &mut Item<Self>, visitor: &mut impl MutVisitor) {
+            let Item { attrs, id, span, vis, ident, kind, tokens } = item;
+            visitor.visit_id(id);
+            visit_attrs(visitor, attrs);
+            visitor.visit_vis(vis);
+            visitor.visit_ident(ident);
+            match kind {
                 ForeignItemKind::Static(box StaticItem { ty, mutability: _, expr, safety: _ }) => {
                     visitor.visit_ty(ty);
                     visit_opt(expr, |expr| visitor.visit_expr(expr));
                 }
                 ForeignItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
                     visit_defaultness(visitor, defaultness);
-                    visitor.visit_fn(FnKind::Fn(sig, generics, body), span, id);
+                    visitor.visit_fn(FnKind::Fn(sig, generics, body), *span, *id);
                 }
                 ForeignItemKind::TyAlias(box TyAlias {
                     defaultness,
@@ -2536,6 +2542,8 @@ pub mod mut_visit {
                 }
                 ForeignItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
             }
+            visit_lazy_tts(visitor, tokens);
+            visitor.visit_span(span);
         }
     }
 

compiler/rustc_builtin_macros/src/test_harness.rs

@@ -4,7 +4,7 @@ use std::{iter, mem};
 
 use rustc_ast as ast;
 use rustc_ast::entry::EntryPointType;
-use rustc_ast::mut_visit::*;
+use rustc_ast::mut_visit::{self, *};
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{walk_item, Visitor};
 use rustc_ast::{attr, ModKind};
@@ -144,7 +144,7 @@ impl<'a> MutVisitor for TestHarnessGenerator<'a> {
             item.kind
         {
             let prev_tests = mem::take(&mut self.tests);
-            walk_item_kind(&mut item.kind, item.span, item.id, self);
+            mut_visit::walk_item(self, item);
             self.add_test_cases(item.id, span, prev_tests);
         } else {
             // But in those cases, we emit a lint to warn the user of these missing tests.