Add back wrappers for walk_item

maxcabrajac · maxcabrajac · commit 94b756bb6305 · 2024-11-19T23:13:31.000-03:00
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -105,15 +105,15 @@ pub trait MutVisitor: Sized {
     }
 
     fn visit_foreign_item(&mut self, ni: &mut P<ForeignItem>) {
-        walk_item(self, ni, ());
+        walk_item(self, ni);
     }
 
     fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
         walk_flat_map_foreign_item(self, ni)
     }
 
     fn visit_item(&mut self, i: &mut P<Item>) {
-        walk_item(self, i, ());
+        walk_item(self, i);
     }
 
     fn flat_map_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {
@@ -133,7 +133,7 @@ pub trait MutVisitor: Sized {
     }
 
     fn visit_assoc_item(&mut self, i: &mut P<AssocItem>, ctxt: AssocCtxt) {
-        walk_item(self, i, ctxt)
+        walk_assoc_item(self, i, ctxt)
     }
 
     fn flat_map_assoc_item(
@@ -1395,7 +1395,15 @@ pub fn walk_crate<T: MutVisitor>(vis: &mut T, krate: &mut Crate) {
     vis.visit_span(inject_use_span);
 }
 
-pub fn walk_item<K: WalkItemKind>(
+pub fn walk_item(visitor: &mut impl MutVisitor, item: &mut P<Item<impl WalkItemKind<Ctxt = ()>>>) {
+    walk_item_ctxt(visitor, item, ())
+}
+
+pub fn walk_assoc_item(visitor: &mut impl MutVisitor, item: &mut P<AssocItem>, ctxt: AssocCtxt) {
+    walk_item_ctxt(visitor, item, ctxt)
+}
+
+fn walk_item_ctxt<K: WalkItemKind>(
     visitor: &mut impl MutVisitor,
     item: &mut P<Item<K>>,
     ctxt: K::Ctxt,
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -143,10 +143,10 @@ pub trait Visitor<'ast>: Sized {
         Self::Result::output()
     }
     fn visit_foreign_item(&mut self, i: &'ast ForeignItem) -> Self::Result {
-        walk_item(self, i, ())
+        walk_item(self, i)
     }
     fn visit_item(&mut self, i: &'ast Item) -> Self::Result {
-        walk_item(self, i, ())
+        walk_item(self, i)
     }
     fn visit_local(&mut self, l: &'ast Local) -> Self::Result {
         walk_local(self, l)
@@ -196,7 +196,7 @@ pub trait Visitor<'ast>: Sized {
         walk_fn(self, fk)
     }
     fn visit_assoc_item(&mut self, i: &'ast AssocItem, ctxt: AssocCtxt) -> Self::Result {
-        walk_item(self, i, ctxt)
+        walk_assoc_item(self, i, ctxt)
     }
     fn visit_trait_ref(&mut self, t: &'ast TraitRef) -> Self::Result {
         walk_trait_ref(self, t)
@@ -918,7 +918,22 @@ impl WalkItemKind for AssocItemKind {
     }
 }
 
-pub fn walk_item<'a, V: Visitor<'a>, K: WalkItemKind>(
+pub fn walk_item<'a, V: Visitor<'a>>(
+    visitor: &mut V,
+    item: &'a Item<impl WalkItemKind<Ctxt = ()>>,
+) -> V::Result {
+    walk_item_ctxt(visitor, item, ())
+}
+
+pub fn walk_assoc_item<'a, V: Visitor<'a>>(
+    visitor: &mut V,
+    item: &'a AssocItem,
+    ctxt: AssocCtxt,
+) -> V::Result {
+    walk_item_ctxt(visitor, item, ctxt)
+}
+
+fn walk_item_ctxt<'a, V: Visitor<'a>, K: WalkItemKind>(
     visitor: &mut V,
     item: &'a Item<K>,
     ctxt: K::Ctxt,
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -379,21 +379,21 @@ fn index_crate<'a>(
         fn visit_item(&mut self, item: &'a ast::Item) {
             let def_id = self.node_id_to_def_id[&item.id];
             *self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner) = AstOwner::Item(item);
-            visit::walk_item(self, item, ())
+            visit::walk_item(self, item)
         }
 
         fn visit_assoc_item(&mut self, item: &'a ast::AssocItem, ctxt: visit::AssocCtxt) {
             let def_id = self.node_id_to_def_id[&item.id];
             *self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner) =
                 AstOwner::AssocItem(item, ctxt);
-            visit::walk_item(self, item, ctxt);
+            visit::walk_assoc_item(self, item, ctxt);
         }
 
         fn visit_foreign_item(&mut self, item: &'a ast::ForeignItem) {
             let def_id = self.node_id_to_def_id[&item.id];
             *self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner) =
                 AstOwner::ForeignItem(item);
-            visit::walk_item(self, item, ());
+            visit::walk_item(self, item);
         }
     }
 }
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -977,7 +977,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     if abi.is_none() {
                         this.maybe_lint_missing_abi(*extern_span, item.id);
                     }
-                    visit::walk_item(this, item, ());
+                    visit::walk_item(this, item);
                     this.extern_mod = old_item;
                 });
                 return; // Avoid visiting again.
@@ -1112,7 +1112,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             _ => {}
         }
 
-        visit::walk_item(self, item, ());
+        visit::walk_item(self, item);
     }
 
     fn visit_foreign_item(&mut self, fi: &'a ForeignItem) {
@@ -1145,7 +1145,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             ForeignItemKind::MacCall(..) => {}
         }
 
-        visit::walk_item(self, fi, ())
+        visit::walk_item(self, fi)
     }
 
     // Mirrors `visit::walk_generic_args`, but tracks relevant state.
@@ -1491,10 +1491,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     None => TildeConstReason::InherentAssocTy { span: item.span },
                 });
                 self.with_tilde_const(disallowed, |this| {
-                    this.with_in_trait_impl(None, |this| visit::walk_item(this, item, ctxt))
+                    this.with_in_trait_impl(None, |this| visit::walk_assoc_item(this, item, ctxt))
                 })
             }
-            _ => self.with_in_trait_impl(None, |this| visit::walk_item(this, item, ctxt)),
+            _ => self.with_in_trait_impl(None, |this| visit::walk_assoc_item(this, item, ctxt)),
         }
     }
 }
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -299,7 +299,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             _ => {}
         }
 
-        visit::walk_item(self, i, ());
+        visit::walk_item(self, i);
     }
 
     fn visit_foreign_item(&mut self, i: &'a ast::ForeignItem) {
@@ -322,7 +322,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::ForeignItemKind::MacCall(..) => {}
         }
 
-        visit::walk_item(self, i, ())
+        visit::walk_item(self, i)
     }
 
     fn visit_ty(&mut self, ty: &'a ast::Ty) {
@@ -477,7 +477,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 "specialization is unstable"
             );
         }
-        visit::walk_item(self, i, ctxt)
+        visit::walk_assoc_item(self, i, ctxt)
     }
 }
 
diff --git a/compiler/rustc_ast_passes/src/node_count.rs b/compiler/rustc_ast_passes/src/node_count.rs
@@ -21,11 +21,11 @@ impl<'ast> Visitor<'ast> for NodeCounter {
     }
     fn visit_foreign_item(&mut self, i: &ForeignItem) {
         self.count += 1;
-        walk_item(self, i, ())
+        walk_item(self, i)
     }
     fn visit_item(&mut self, i: &Item) {
         self.count += 1;
-        walk_item(self, i, ())
+        walk_item(self, i)
     }
     fn visit_local(&mut self, l: &Local) {
         self.count += 1;
@@ -69,7 +69,7 @@ impl<'ast> Visitor<'ast> for NodeCounter {
     }
     fn visit_assoc_item(&mut self, ti: &AssocItem, ctxt: AssocCtxt) {
         self.count += 1;
-        walk_item(self, ti, ctxt);
+        walk_assoc_item(self, ti, ctxt);
     }
     fn visit_trait_ref(&mut self, t: &TraitRef) {
         self.count += 1;
diff --git a/compiler/rustc_builtin_macros/src/proc_macro_harness.rs b/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
@@ -210,7 +210,7 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> {
         let Some(attr) = found_attr else {
             self.check_not_pub_in_root(&item.vis, self.source_map.guess_head_span(item.span));
             let prev_in_root = mem::replace(&mut self.in_root, false);
-            visit::walk_item(self, item, ());
+            visit::walk_item(self, item);
             self.in_root = prev_in_root;
             return;
         };
@@ -248,7 +248,7 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> {
         };
 
         let prev_in_root = mem::replace(&mut self.in_root, false);
-        visit::walk_item(self, item, ());
+        visit::walk_item(self, item);
         self.in_root = prev_in_root;
     }
 }
diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -157,7 +157,7 @@ impl<'a> MutVisitor for TestHarnessGenerator<'a> {
             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.
-            walk_item(&mut InnerItemLinter { sess: self.cx.ext_cx.sess }, &item, ());
+            walk_item(&mut InnerItemLinter { sess: self.cx.ext_cx.sess }, &item);
         }
     }
 }
@@ -200,7 +200,7 @@ struct EntryPointCleaner<'a> {
 impl<'a> MutVisitor for EntryPointCleaner<'a> {
     fn visit_item(&mut self, item: &mut P<ast::Item>) {
         self.depth += 1;
-        ast::mut_visit::walk_item(self, item, ());
+        ast::mut_visit::walk_item(self, item);
         self.depth -= 1;
 
         // Remove any #[rustc_main] or #[start] from the AST so it doesn't
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
@@ -902,7 +902,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     _ => {}
                 }
 
-                visit::walk_item(self, item, ());
+                visit::walk_item(self, item);
             }
         }
 
diff --git a/compiler/rustc_lint/src/early.rs b/compiler/rustc_lint/src/early.rs
@@ -82,14 +82,14 @@ impl<'a, T: EarlyLintPass> ast_visit::Visitor<'a> for EarlyContextAndPass<'a, T>
     fn visit_item(&mut self, it: &'a ast::Item) {
         self.with_lint_attrs(it.id, &it.attrs, |cx| {
             lint_callback!(cx, check_item, it);
-            ast_visit::walk_item(cx, it, ());
+            ast_visit::walk_item(cx, it);
             lint_callback!(cx, check_item_post, it);
         })
     }
 
     fn visit_foreign_item(&mut self, it: &'a ast::ForeignItem) {
         self.with_lint_attrs(it.id, &it.attrs, |cx| {
-            ast_visit::walk_item(cx, it, ());
+            ast_visit::walk_item(cx, it);
         })
     }
 
@@ -239,7 +239,7 @@ impl<'a, T: EarlyLintPass> ast_visit::Visitor<'a> for EarlyContextAndPass<'a, T>
                     lint_callback!(cx, check_impl_item, item);
                 }
             }
-            ast_visit::walk_item(cx, item, ctxt);
+            ast_visit::walk_assoc_item(cx, item, ctxt);
         });
     }
 
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
@@ -1105,7 +1105,7 @@ fn global_allocator_spans(krate: &ast::Crate) -> Vec<Span> {
             {
                 self.spans.push(item.span);
             }
-            visit::walk_item(self, item, ())
+            visit::walk_item(self, item)
         }
     }
 
@@ -1127,7 +1127,7 @@ fn alloc_error_handler_spans(krate: &ast::Crate) -> Vec<Span> {
             {
                 self.spans.push(item.span);
             }
-            visit::walk_item(self, item, ())
+            visit::walk_item(self, item)
         }
     }
 
diff --git a/compiler/rustc_parse/src/parser/tests.rs b/compiler/rustc_parse/src/parser/tests.rs
@@ -2438,7 +2438,7 @@ fn get_spans_of_pat_idents(src: &str) -> Vec<Span> {
         }
     }
     let mut v = PatIdentVisitor { spans: Vec::new() };
-    visit::walk_item(&mut v, &item, ());
+    visit::walk_item(&mut v, &item);
     return v.spans;
 }
 
diff --git a/compiler/rustc_passes/src/hir_stats.rs b/compiler/rustc_passes/src/hir_stats.rs
@@ -477,7 +477,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
         record_variants!((self, i, i.kind, None, ast, ForeignItem, ForeignItemKind), [
             Static, Fn, TyAlias, MacCall
         ]);
-        ast_visit::walk_item(self, i, ())
+        ast_visit::walk_item(self, i)
     }
 
     fn visit_item(&mut self, i: &'v ast::Item) {
@@ -502,7 +502,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
             Delegation,
             DelegationMac
         ]);
-        ast_visit::walk_item(self, i, ())
+        ast_visit::walk_item(self, i)
     }
 
     fn visit_local(&mut self, l: &'v ast::Local) {
@@ -626,7 +626,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
             Delegation,
             DelegationMac
         ]);
-        ast_visit::walk_item(self, i, ctxt);
+        ast_visit::walk_assoc_item(self, i, ctxt);
     }
 
     fn visit_param_bound(&mut self, b: &'v ast::GenericBound, _ctxt: BoundKind) {
diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs
@@ -299,7 +299,7 @@ impl<'ast, 'tcx> visit::Visitor<'ast> for LanguageItemCollector<'ast, 'tcx> {
         );
 
         let parent_item = self.parent_item.replace(i);
-        visit::walk_item(self, i, ());
+        visit::walk_item(self, i);
         self.parent_item = parent_item;
     }
 
@@ -355,7 +355,7 @@ impl<'ast, 'tcx> visit::Visitor<'ast> for LanguageItemCollector<'ast, 'tcx> {
             generics,
         );
 
-        visit::walk_item(self, i, ctxt);
+        visit::walk_assoc_item(self, i, ctxt);
     }
 }
 
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -1311,7 +1311,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         self.parent_scope.macro_rules = match item.kind {
             ItemKind::MacroDef(..) => {
                 let macro_rules_scope = self.define_macro(item);
-                visit::walk_item(self, item, ());
+                visit::walk_item(self, item);
                 macro_rules_scope
             }
             ItemKind::MacCall(..) => self.visit_invoc_in_module(item.id),
@@ -1327,7 +1327,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                         item.kind.walk(item.span, item.id, &item.ident, &item.vis, (), self);
                         visit::walk_list!(self, visit_attribute, &item.attrs);
                     }
-                    _ => visit::walk_item(self, item, ()),
+                    _ => visit::walk_item(self, item),
                 }
                 match item.kind {
                     ItemKind::Mod(..) if self.contains_macro_use(&item.attrs) => {
@@ -1355,7 +1355,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         }
 
         self.build_reduced_graph_for_foreign_item(foreign_item);
-        visit::walk_item(self, foreign_item, ());
+        visit::walk_item(self, foreign_item);
     }
 
     fn visit_block(&mut self, block: &'a Block) {
@@ -1420,7 +1420,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             self.r.impl_binding_keys.entry(impl_def_id).or_default().insert(key);
         }
 
-        visit::walk_item(self, item, ctxt);
+        visit::walk_assoc_item(self, item, ctxt);
     }
 
     fn visit_attribute(&mut self, attr: &'a ast::Attribute) {
diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
@@ -235,7 +235,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for UnusedImportCheckVisitor<'a, 'ra, 'tcx> {
         }
 
         self.item_span = item.span_with_attributes();
-        visit::walk_item(self, item, ());
+        visit::walk_item(self, item);
     }
 
     fn visit_use_tree(&mut self, use_tree: &'a ast::UseTree, id: ast::NodeId, nested: bool) {
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
diff --git a/compiler/rustc_resolve/src/effective_visibilities.rs b/compiler/rustc_resolve/src/effective_visibilities.rs
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
diff --git a/src/tools/clippy/clippy_lints/src/excessive_nesting.rs b/src/tools/clippy/clippy_lints/src/excessive_nesting.rs

Original file line number	Diff line number	Diff line change
`@@ -105,15 +105,15 @@ pub trait MutVisitor: Sized {`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`fn visit_foreign_item(&mut self, ni: &mut P<ForeignItem>) {`
`108`		`- walk_item(self, ni, ());`
	`108`	`+ walk_item(self, ni);`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {`
`112`	`112`	`walk_flat_map_foreign_item(self, ni)`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`fn visit_item(&mut self, i: &mut P<Item>) {`
`116`		`- walk_item(self, i, ());`
	`116`	`+ walk_item(self, i);`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`fn flat_map_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {`
`@@ -133,7 +133,7 @@ pub trait MutVisitor: Sized {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`fn visit_assoc_item(&mut self, i: &mut P<AssocItem>, ctxt: AssocCtxt) {`
`136`		`- walk_item(self, i, ctxt)`
	`136`	`+ walk_assoc_item(self, i, ctxt)`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`fn flat_map_assoc_item(`
`@@ -1395,7 +1395,15 @@ pub fn walk_crate<T: MutVisitor>(vis: &mut T, krate: &mut Crate) {`
`1395`	`1395`	`vis.visit_span(inject_use_span);`
`1396`	`1396`	`}`
`1397`	`1397`
`1398`		`-pub fn walk_item<K: WalkItemKind>(`
	`1398`	`+pub fn walk_item(visitor: &mut impl MutVisitor, item: &mut P<Item<impl WalkItemKind<Ctxt = ()>>>) {`
	`1399`	`+ walk_item_ctxt(visitor, item, ())`
	`1400`	`+}`
	`1401`	`+`
	`1402`	`+pub fn walk_assoc_item(visitor: &mut impl MutVisitor, item: &mut P<AssocItem>, ctxt: AssocCtxt) {`
	`1403`	`+ walk_item_ctxt(visitor, item, ctxt)`
	`1404`	`+}`
	`1405`	`+`
	`1406`	`+fn walk_item_ctxt<K: WalkItemKind>(`
`1399`	`1407`	`visitor: &mut impl MutVisitor,`
`1400`	`1408`	`item: &mut P<Item<K>>,`
`1401`	`1409`	`ctxt: K::Ctxt,`
Original file line number	Diff line number	Diff line change
`@@ -379,21 +379,21 @@ fn index_crate<'a>(`
`379`	`379`	`fn visit_item(&mut self, item: &'a ast::Item) {`
`380`	`380`	`let def_id = self.node_id_to_def_id[&item.id];`
`381`	`381`	`*self.index.ensure_contains_elem(def_id, \|\| AstOwner::NonOwner) = AstOwner::Item(item);`
`382`		`- visit::walk_item(self, item, ())`
	`382`	`+ visit::walk_item(self, item)`
`383`	`383`	`}`
`384`	`384`
`385`	`385`	`fn visit_assoc_item(&mut self, item: &'a ast::AssocItem, ctxt: visit::AssocCtxt) {`
`386`	`386`	`let def_id = self.node_id_to_def_id[&item.id];`
`387`	`387`	`*self.index.ensure_contains_elem(def_id, \|\| AstOwner::NonOwner) =`
`388`	`388`	`AstOwner::AssocItem(item, ctxt);`
`389`		`- visit::walk_item(self, item, ctxt);`
	`389`	`+ visit::walk_assoc_item(self, item, ctxt);`
`390`	`390`	`}`
`391`	`391`
`392`	`392`	`fn visit_foreign_item(&mut self, item: &'a ast::ForeignItem) {`
`393`	`393`	`let def_id = self.node_id_to_def_id[&item.id];`
`394`	`394`	`*self.index.ensure_contains_elem(def_id, \|\| AstOwner::NonOwner) =`
`395`	`395`	`AstOwner::ForeignItem(item);`
`396`		`- visit::walk_item(self, item, ());`
	`396`	`+ visit::walk_item(self, item);`
`397`	`397`	`}`
`398`	`398`	`}`
`399`	`399`	`}`
Original file line number	Diff line number	Diff line change
`@@ -977,7 +977,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`977`	`977`	`if abi.is_none() {`
`978`	`978`	`this.maybe_lint_missing_abi(*extern_span, item.id);`
`979`	`979`	`}`
`980`		`- visit::walk_item(this, item, ());`
	`980`	`+ visit::walk_item(this, item);`
`981`	`981`	`this.extern_mod = old_item;`
`982`	`982`	`});`
`983`	`983`	`return; // Avoid visiting again.`
`@@ -1112,7 +1112,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`1112`	`1112`	`_ => {}`
`1113`	`1113`	`}`
`1114`	`1114`
`1115`		`- visit::walk_item(self, item, ());`
	`1115`	`+ visit::walk_item(self, item);`
`1116`	`1116`	`}`
`1117`	`1117`
`1118`	`1118`	`fn visit_foreign_item(&mut self, fi: &'a ForeignItem) {`
`@@ -1145,7 +1145,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`1145`	`1145`	`ForeignItemKind::MacCall(..) => {}`
`1146`	`1146`	`}`
`1147`	`1147`
`1148`		`- visit::walk_item(self, fi, ())`
	`1148`	`+ visit::walk_item(self, fi)`
`1149`	`1149`	`}`
`1150`	`1150`
`1151`	`1151`	// Mirrors `visit::walk_generic_args`, but tracks relevant state.
`@@ -1491,10 +1491,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`1491`	`1491`	`None => TildeConstReason::InherentAssocTy { span: item.span },`
`1492`	`1492`	`});`
`1493`	`1493`	`self.with_tilde_const(disallowed, \|this\| {`
`1494`		`- this.with_in_trait_impl(None, \|this\| visit::walk_item(this, item, ctxt))`
	`1494`	`+ this.with_in_trait_impl(None, \|this\| visit::walk_assoc_item(this, item, ctxt))`
`1495`	`1495`	`})`
`1496`	`1496`	`}`
`1497`		`- _ => self.with_in_trait_impl(None, \|this\| visit::walk_item(this, item, ctxt)),`
	`1497`	`+ _ => self.with_in_trait_impl(None, \|this\| visit::walk_assoc_item(this, item, ctxt)),`
`1498`	`1498`	`}`
`1499`	`1499`	`}`
`1500`	`1500`	`}`
Original file line number	Diff line number	Diff line change
`@@ -299,7 +299,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {`
`299`	`299`	`_ => {}`
`300`	`300`	`}`
`301`	`301`
`302`		`- visit::walk_item(self, i, ());`
	`302`	`+ visit::walk_item(self, i);`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`fn visit_foreign_item(&mut self, i: &'a ast::ForeignItem) {`
`@@ -322,7 +322,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {`
`322`	`322`	`ast::ForeignItemKind::MacCall(..) => {}`
`323`	`323`	`}`
`324`	`324`
`325`		`- visit::walk_item(self, i, ())`
	`325`	`+ visit::walk_item(self, i)`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`fn visit_ty(&mut self, ty: &'a ast::Ty) {`
`@@ -477,7 +477,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {`
`477`	`477`	`"specialization is unstable"`
`478`	`478`	`);`
`479`	`479`	`}`
`480`		`- visit::walk_item(self, i, ctxt)`
	`480`	`+ visit::walk_assoc_item(self, i, ctxt)`
`481`	`481`	`}`
`482`	`482`	`}`
`483`	`483`
Original file line number	Diff line number	Diff line change
`@@ -21,11 +21,11 @@ impl<'ast> Visitor<'ast> for NodeCounter {`
`21`	`21`	`}`
`22`	`22`	`fn visit_foreign_item(&mut self, i: &ForeignItem) {`
`23`	`23`	`self.count += 1;`
`24`		`- walk_item(self, i, ())`
	`24`	`+ walk_item(self, i)`
`25`	`25`	`}`
`26`	`26`	`fn visit_item(&mut self, i: &Item) {`
`27`	`27`	`self.count += 1;`
`28`		`- walk_item(self, i, ())`
	`28`	`+ walk_item(self, i)`
`29`	`29`	`}`
`30`	`30`	`fn visit_local(&mut self, l: &Local) {`
`31`	`31`	`self.count += 1;`
`@@ -69,7 +69,7 @@ impl<'ast> Visitor<'ast> for NodeCounter {`
`69`	`69`	`}`
`70`	`70`	`fn visit_assoc_item(&mut self, ti: &AssocItem, ctxt: AssocCtxt) {`
`71`	`71`	`self.count += 1;`
`72`		`- walk_item(self, ti, ctxt);`
	`72`	`+ walk_assoc_item(self, ti, ctxt);`
`73`	`73`	`}`
`74`	`74`	`fn visit_trait_ref(&mut self, t: &TraitRef) {`
`75`	`75`	`self.count += 1;`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ impl<'a> MutVisitor for TestHarnessGenerator<'a> {`
`157`	`157`	`self.add_test_cases(item.id, span, prev_tests);`
`158`	`158`	`} else {`
`159`	`159`	`// But in those cases, we emit a lint to warn the user of these missing tests.`
`160`		`- walk_item(&mut InnerItemLinter { sess: self.cx.ext_cx.sess }, &item, ());`
	`160`	`+ walk_item(&mut InnerItemLinter { sess: self.cx.ext_cx.sess }, &item);`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`}`
`@@ -200,7 +200,7 @@ struct EntryPointCleaner<'a> {`
`200`	`200`	`impl<'a> MutVisitor for EntryPointCleaner<'a> {`
`201`	`201`	`fn visit_item(&mut self, item: &mut P<ast::Item>) {`
`202`	`202`	`self.depth += 1;`
`203`		`- ast::mut_visit::walk_item(self, item, ());`
	`203`	`+ ast::mut_visit::walk_item(self, item);`
`204`	`204`	`self.depth -= 1;`
`205`	`205`
`206`	`206`	`// Remove any #[rustc_main] or #[start] from the AST so it doesn't`
Original file line number	Diff line number	Diff line change
`@@ -902,7 +902,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {`
`902`	`902`	`_ => {}`
`903`	`903`	`}`
`904`	`904`
`905`		`- visit::walk_item(self, item, ());`
	`905`	`+ visit::walk_item(self, item);`
`906`	`906`	`}`
`907`	`907`	`}`
`908`	`908`
Original file line number	Diff line number	Diff line change
`@@ -82,14 +82,14 @@ impl<'a, T: EarlyLintPass> ast_visit::Visitor<'a> for EarlyContextAndPass<'a, T>`
`82`	`82`	`fn visit_item(&mut self, it: &'a ast::Item) {`
`83`	`83`	`self.with_lint_attrs(it.id, &it.attrs, \|cx\| {`
`84`	`84`	`lint_callback!(cx, check_item, it);`
`85`		`- ast_visit::walk_item(cx, it, ());`
	`85`	`+ ast_visit::walk_item(cx, it);`
`86`	`86`	`lint_callback!(cx, check_item_post, it);`
`87`	`87`	`})`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`fn visit_foreign_item(&mut self, it: &'a ast::ForeignItem) {`
`91`	`91`	`self.with_lint_attrs(it.id, &it.attrs, \|cx\| {`
`92`		`- ast_visit::walk_item(cx, it, ());`
	`92`	`+ ast_visit::walk_item(cx, it);`
`93`	`93`	`})`
`94`	`94`	`}`
`95`	`95`
`@@ -239,7 +239,7 @@ impl<'a, T: EarlyLintPass> ast_visit::Visitor<'a> for EarlyContextAndPass<'a, T>`
`239`	`239`	`lint_callback!(cx, check_impl_item, item);`
`240`	`240`	`}`
`241`	`241`	`}`
`242`		`- ast_visit::walk_item(cx, item, ctxt);`
	`242`	`+ ast_visit::walk_assoc_item(cx, item, ctxt);`
`243`	`243`	`});`
`244`	`244`	`}`
`245`	`245`