eii_macro_for

jdonszelmann · jdonszelmann · commit 5d8303f71818 · 2025-04-18T15:39:14.000+02:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -1960,6 +1960,8 @@ pub struct MacroDef {
     pub body: P<DelimArgs>,
     /// `true` if macro was defined with `macro_rules`.
     pub macro_rules: bool,
+
+    pub eii_macro_for: Option<Path>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)]
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -750,7 +750,10 @@ fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {
 }
 
 fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {
-    let MacroDef { body, macro_rules: _ } = macro_def;
+    let MacroDef { body, macro_rules: _, eii_macro_for } = macro_def;
+    if let Some(path) = eii_macro_for {
+        vis.visit_path(path);
+    }
     visit_delim_args(vis, body);
 }
 
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -47,7 +47,6 @@ pub enum BoundKind {
     /// Trait bounds in trait object type.
     /// E.g., `dyn Bound1 + Bound2 + Bound3`.
     TraitObject,
-
     /// Super traits of a trait.
     /// E.g., `trait A: B`
     SuperTraits,
@@ -479,7 +478,10 @@ impl WalkItemKind for ItemKind {
             ItemKind::MacCall(mac) => try_visit!(visitor.visit_mac_call(mac)),
             ItemKind::MacroDef(ident, ts) => {
                 try_visit!(visitor.visit_ident(ident));
-                try_visit!(visitor.visit_mac_def(ts, id))
+                try_visit!(visitor.visit_mac_def(ts, id));
+                if let Some(i) = &ts.eii_macro_for {
+                    try_visit!(visitor.visit_path(i, id));
+                }
             }
             ItemKind::Delegation(box Delegation {
                 id,
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -22,6 +22,7 @@ use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
     ResolverAstLoweringExt,
 };
+use crate::GenericArgsMode;
 
 pub(super) struct ItemLowerer<'a, 'hir> {
     pub(super) tcx: TyCtxt<'hir>,
@@ -462,7 +463,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::ItemKind::TraitAlias(ident, generics, bounds)
             }
-            ItemKind::MacroDef(ident, MacroDef { body, macro_rules }) => {
+            ItemKind::MacroDef(ident, MacroDef { body, macro_rules, eii_macro_for }) => {
                 let ident = self.lower_ident(*ident);
                 let body = P(self.lower_delim_args(body));
                 let def_id = self.local_def_id(id);
@@ -473,8 +474,35 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         def_kind.descr(def_id.to_def_id())
                     );
                 };
-                let macro_def = self.arena.alloc(ast::MacroDef { body, macro_rules: *macro_rules });
-                hir::ItemKind::Macro(ident, macro_def, macro_kind)
+
+                let ast_macro_def = self.arena.alloc(ast::MacroDef {
+                    body,
+                    macro_rules: *macro_rules,
+                    eii_macro_for: None,
+                });
+
+                hir::ItemKind::Macro {
+                    name: ident,
+                    ast_macro_def,
+                    kind: macro_kind,
+                    eii_macro_for: eii_macro_for.as_ref().map(|path| {
+                        let lowered = self.lower_qpath(
+                            id,
+                            &None,
+                            path,
+                            ParamMode::Explicit,
+                            crate::AllowReturnTypeNotation::No,
+                            ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            None,
+                        );
+
+                        let QPath::Resolved(None, path) = lowered else {
+                            panic!("{lowered:?}");
+                        };
+
+                        path.res.def_id()
+                    }),
+                }
             }
             ItemKind::Delegation(box delegation) => {
                 let delegation_results = self.lower_delegation(delegation, id, false);
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
@@ -44,6 +44,7 @@ mod define_opaque;
 mod derive;
 mod deriving;
 mod edition_panic;
+mod eii;
 mod env;
 mod errors;
 mod format;
@@ -122,6 +123,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         global_allocator: global_allocator::expand,
         test: test::expand_test,
         test_case: test::expand_test_case,
+        eii_macro_for: eii::eii_macro_for,
     }
 
     register_derive! {
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -1056,6 +1056,21 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         "#[rustc_force_inline] forces a free function to be inlined"
     ),
 
+    gated!(
+        eii, Normal, template!(Word),
+        ErrorPreceding, EncodeCrossCrate::No,
+        eii_internals, "internally used to implement EII"
+    ),
+    gated!(
+        eii_impl, Normal, template!(List: "/*opt*/ default"),
+        ErrorPreceding, EncodeCrossCrate::No,
+        eii_internals, "internally used to implement EII"
+    ),
+    gated!(
+        eii_macro_for, Normal, template!(List: "path"),
+        ErrorPreceding, EncodeCrossCrate::No,
+        eii_internals, "internally used to implement EII"
+    ),
     // ==========================================================================
     // Internal attributes, Testing:
     // ==========================================================================
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -3998,8 +3998,7 @@ impl<'hir> Item<'hir> {
         expect_fn, (Ident, &FnSig<'hir>, &'hir Generics<'hir>, BodyId),
             ItemKind::Fn { ident, sig, generics, body, .. }, (*ident, sig, generics, *body);
 
-        expect_macro, (Ident, &ast::MacroDef, MacroKind),
-            ItemKind::Macro(ident, def, mk), (*ident, def, *mk);
+        expect_macro, (Ident, &ast::MacroDef, MacroKind, Option<DefId>), ItemKind::Macro {name: ident, ast_macro_def, kind, eii_macro_for}, (*ident, ast_macro_def, *kind, *eii_macro_for);
 
         expect_mod, (Ident, &'hir Mod<'hir>), ItemKind::Mod(ident, m), (*ident, m);
 
@@ -4176,7 +4175,7 @@ pub enum ItemKind<'hir> {
         has_body: bool,
     },
     /// A MBE macro definition (`macro_rules!` or `macro`).
-    Macro(Ident, &'hir ast::MacroDef, MacroKind),
+    Macro { name: Ident, ast_macro_def: &'hir ast::MacroDef, kind: MacroKind, eii_macro_for: Option<DefId> },
     /// A module.
     Mod(Ident, &'hir Mod<'hir>),
     /// An external module, e.g. `extern { .. }`.
@@ -4276,7 +4275,7 @@ impl ItemKind<'_> {
             ItemKind::Static(..) => "static item",
             ItemKind::Const(..) => "constant item",
             ItemKind::Fn { .. } => "function",
-            ItemKind::Macro(..) => "macro",
+            ItemKind::Macro { .. } => "macro",
             ItemKind::Mod(..) => "module",
             ItemKind::ForeignMod { .. } => "extern block",
             ItemKind::GlobalAsm { .. } => "global asm item",
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -566,8 +566,8 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
                 item.owner_id.def_id,
             ));
         }
-        ItemKind::Macro(ident, _def, _kind) => {
-            try_visit!(visitor.visit_ident(ident));
+        ItemKind::Macro(name, _def, _kind) => {
+            try_visit!(visitor.visit_ident(name));
         }
         ItemKind::Mod(ident, ref module) => {
             try_visit!(visitor.visit_ident(ident));
diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
@@ -109,7 +109,7 @@ impl Target {
             ItemKind::Static { .. } => Target::Static,
             ItemKind::Const(..) => Target::Const,
             ItemKind::Fn { .. } => Target::Fn,
-            ItemKind::Macro(..) => Target::MacroDef,
+            ItemKind::Macro { .. } => Target::MacroDef,
             ItemKind::Mod(..) => Target::Mod,
             ItemKind::ForeignMod { .. } => Target::ForeignMod,
             ItemKind::GlobalAsm { .. } => Target::GlobalAsm,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -676,7 +676,7 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
         // These don't define types.
         hir::ItemKind::ExternCrate(..)
         | hir::ItemKind::Use(..)
-        | hir::ItemKind::Macro(..)
+        | hir::ItemKind::Macro { .. }
         | hir::ItemKind::Mod(..)
         | hir::ItemKind::GlobalAsm { .. } => {}
         hir::ItemKind::ForeignMod { items, .. } => {
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -619,7 +619,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
 
             hir::ItemKind::ExternCrate(..)
             | hir::ItemKind::Use(..)
-            | hir::ItemKind::Macro(..)
+            | hir::ItemKind::Macro { .. }
             | hir::ItemKind::Mod(..)
             | hir::ItemKind::ForeignMod { .. }
             | hir::ItemKind::Static(..)
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -254,7 +254,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
             ItemKind::GlobalAsm { .. } => tcx.typeck(def_id).node_type(hir_id),
             ItemKind::Trait(..)
             | ItemKind::TraitAlias(..)
-            | ItemKind::Macro(..)
+            | ItemKind::Macro { .. }
             | ItemKind::Mod(..)
             | ItemKind::ForeignMod { .. }
             | ItemKind::ExternCrate(..)
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -631,8 +631,9 @@ impl<'a> State<'a> {
                 self.end(); // need to close a box
                 self.ann.nested(self, Nested::Body(body));
             }
-            hir::ItemKind::Macro(ident, macro_def, _) => {
-                self.print_mac_def(macro_def, &ident, item.span, |_| {});
+            hir::ItemKind::Macro { name: ident, ast_macro_def, kind: _, eii_macro_for: _ } => {
+                // TODO: print macro for as comment
+                self.print_mac_def(ast_macro_def, &ident, item.span, |_| {});
             }
             hir::ItemKind::Mod(ident, mod_) => {
                 self.head("mod");
diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs
@@ -240,7 +240,7 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                     },
                 )
             }
-            ItemKind::Macro(_, _macro, MacroKind::Bang)
+            ItemKind::Macro { kind: MacroKind::Bang, .. }
                 if cx.tcx.has_attr(item.owner_id.def_id, sym::macro_export) =>
             {
                 cx.emit_span_lint(
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
@@ -1720,7 +1720,7 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
             | hir::ItemKind::GlobalAsm { .. }
             | hir::ItemKind::ForeignMod { .. }
             | hir::ItemKind::Mod(..)
-            | hir::ItemKind::Macro(..)
+            | hir::ItemKind::Macro { .. }
             | hir::ItemKind::Use(..)
             | hir::ItemKind::ExternCrate(..) => {}
         }
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1502,7 +1502,7 @@ impl<'a> CrateMetadataRef<'a> {
                 let macro_rules = self.root.tables.is_macro_rules.get(self, id);
                 let body =
                     self.root.tables.macro_definition.get(self, id).unwrap().decode((self, sess));
-                ast::MacroDef { macro_rules, body: ast::ptr::P(body) }
+                ast::MacroDef { macro_rules, body: ast::ptr::P(body), eii_macro_for: None }
             }
             _ => bug!(),
         }
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1844,9 +1844,18 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     fn encode_info_for_macro(&mut self, def_id: LocalDefId) {
         let tcx = self.tcx;
 
-        let (_, macro_def, _) = tcx.hir_expect_item(def_id).expect_macro();
-        self.tables.is_macro_rules.set(def_id.local_def_index, macro_def.macro_rules);
-        record!(self.tables.macro_definition[def_id.to_def_id()] <- &*macro_def.body);
+        let hir::ItemKind::Macro { ast_macro_def, kind: _, eii_macro_for } =
+            tcx.hir().expect_item(def_id).kind
+        else {
+            bug!()
+        };
+        self.tables.is_macro_rules.set(def_id.local_def_index, ast_macro_def.macro_rules);
+
+        if let Some(did) = eii_macro_for {
+            record!(self.tables.eii_macro_for[def_id.to_def_id()] <- did.index);
+        }
+
+        record!(self.tables.macro_definition[def_id.to_def_id()] <- &*ast_macro_def.body);
     }
 
     fn encode_native_libraries(&mut self) -> LazyArray<NativeLib> {
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -411,6 +411,7 @@ define_tables! {
 
 - optional:
     attributes: Table<DefIndex, LazyArray<hir::Attribute>>,
+    eii_macro_for: Table<DefIndex, LazyValue<DefIndex>>,
     // For non-reexported names in a module every name is associated with a separate `DefId`,
     // so we can take their names, visibilities etc from other encoded tables.
     module_children_non_reexports: Table<DefIndex, LazyArray<DefIndex>>,
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -48,7 +48,7 @@ use rustc_serialize::{Decodable, Encodable};
 use rustc_session::lint::LintBuffer;
 pub use rustc_session::lint::RegisteredTools;
 use rustc_span::hygiene::MacroKind;
-use rustc_span::{EiiId, DUMMY_SP, ExpnId, ExpnKind, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, ExpnId, ExpnKind, Ident, Span, Symbol, kw, sym};
 pub use rustc_type_ir::relate::VarianceDiagInfo;
 pub use rustc_type_ir::*;
 use tracing::{debug, instrument};
@@ -215,9 +215,6 @@ pub struct ResolverAstLowering {
 
     /// Information about functions signatures for delegation items expansion
     pub delegation_fn_sigs: LocalDefIdMap<DelegationFnSig>,
-
-    /// Map of defids for all items marked with #[eii(<eii id>)].
-    pub eii: FxHashMap<EiiId, LocalDefId>,
 }
 
 #[derive(Debug)]
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -2197,7 +2197,9 @@ impl<'a> Parser<'a> {
         };
 
         self.psess.gated_spans.gate(sym::decl_macro, lo.to(self.prev_token.span));
-        Ok(ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: false }))
+        Ok(
+            ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: false, eii_macro_for: None }),
+        )
     }
 
     /// Is this a possibly malformed start of a `macro_rules! foo` item definition?
@@ -2244,7 +2246,9 @@ impl<'a> Parser<'a> {
         self.eat_semi_for_macro_if_needed(&body);
         self.complain_if_pub_macro(vis, true);
 
-        Ok(ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: true }))
+        Ok(
+            ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: true, eii_macro_for: None }),
+        )
     }
 
     /// Item macro invocations or `macro_rules!` definitions need inherited visibility.
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -295,7 +295,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::lang
                             | sym::needs_allocator
                             | sym::default_lib_allocator
-                            | sym::custom_mir,
+                            | sym::custom_mir
+                            | sym::eii_macro_for, // TODO: remove
                             ..
                         ] => {}
                         [name, ..] => {
@@ -2355,7 +2356,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
         } else {
             // special case when `#[macro_export]` is applied to a macro 2.0
-            let (_, macro_definition, _) = self.tcx.hir_node(hir_id).expect_item().expect_macro();
+            let (_, macro_definition, _, _eii_macro_for) =
+                self.tcx.hir_node(hir_id).expect_item().expect_macro();
             let is_decl_macro = !macro_definition.macro_rules;
 
             if is_decl_macro {
@@ -2686,9 +2688,9 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
         // Historically we've run more checks on non-exported than exported macros,
         // so this lets us continue to run them while maintaining backwards compatibility.
         // In the long run, the checks should be harmonized.
-        if let ItemKind::Macro(_, macro_def, _) = item.kind {
+        if let ItemKind::Macro { name: _, ast_macro_def, kind: _, eii_macro_for: _ } = item.kind {
             let def_id = item.owner_id.to_def_id();
-            if macro_def.macro_rules && !self.tcx.has_attr(def_id, sym::macro_export) {
+            if ast_macro_def.macro_rules && !self.tcx.has_attr(def_id, sym::macro_export) {
                 check_non_exported_macro_for_invalid_attrs(self.tcx, item);
             }
         }
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
@@ -235,7 +235,7 @@ impl<'tcx> ReachableContext<'tcx> {
                     hir::ItemKind::ExternCrate(..)
                     | hir::ItemKind::Use(..)
                     | hir::ItemKind::TyAlias(..)
-                    | hir::ItemKind::Macro(..)
+                    | hir::ItemKind::Macro { .. }
                     | hir::ItemKind::Mod(..)
                     | hir::ItemKind::ForeignMod { .. }
                     | hir::ItemKind::Impl { .. }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -576,8 +576,12 @@ impl<'tcx> EmbargoVisitor<'tcx> {
             // have normal hygiene, so we can treat them like other items without type
             // privacy and mark them reachable.
             DefKind::Macro(_) => {
-                let item = self.tcx.hir_expect_item(def_id);
-                if let hir::ItemKind::Macro(_, MacroDef { macro_rules: false, .. }, _) = item.kind {
+                let item = self.tcx.hir().expect_item(def_id);
+                if let hir::ItemKind::Macro {
+                    ast_macro_def: MacroDef { macro_rules: false, .. },
+                    ..
+                } = item.kind
+                {
                     if vis.is_accessible_from(module, self.tcx) {
                         self.update(def_id, macro_ev, Level::Reachable);
                     }
@@ -656,9 +660,14 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
             | hir::ItemKind::GlobalAsm { .. } => {}
             // The interface is empty, and all nested items are processed by `visit_item`.
             hir::ItemKind::Mod(..) => {}
-            hir::ItemKind::Macro(_, macro_def, _) => {
+            hir::ItemKind::Macro { ast_macro_def, .. } => {
+                // TODO: consider EII for reachability
                 if let Some(item_ev) = item_ev {
-                    self.update_reachability_from_macro(item.owner_id.def_id, macro_def, item_ev);
+                    self.update_reachability_from_macro(
+                        item.owner_id.def_id,
+                        ast_macro_def,
+                        item_ev,
+                    );
                 }
             }
             hir::ItemKind::Const(..)
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/late.rs b/compiler/rustc_resolve/src/late.rs
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -1960,6 +1960,8 @@ pub struct MacroDef {`
`1960`	`1960`	`pub body: P<DelimArgs>,`
`1961`	`1961`	/// `true` if macro was defined with `macro_rules`.
`1962`	`1962`	`pub macro_rules: bool,`
	`1963`	`+`
	`1964`	`+ pub eii_macro_for: Option<Path>,`
`1963`	`1965`	`}`
`1964`	`1966`
`1965`	`1967`	`#[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)]`
Original file line number	Diff line number	Diff line change
`@@ -750,7 +750,10 @@ fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {`
`750`	`750`	`}`
`751`	`751`
`752`	`752`	`fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {`
`753`		`- let MacroDef { body, macro_rules: _ } = macro_def;`
	`753`	`+ let MacroDef { body, macro_rules: _, eii_macro_for } = macro_def;`
	`754`	`+ if let Some(path) = eii_macro_for {`
	`755`	`+ vis.visit_path(path);`
	`756`	`+ }`
`754`	`757`	`visit_delim_args(vis, body);`
`755`	`758`	`}`
`756`	`759`
Original file line number	Diff line number	Diff line change
`@@ -566,8 +566,8 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::`
`566`	`566`	`item.owner_id.def_id,`
`567`	`567`	`));`
`568`	`568`	`}`
`569`		`- ItemKind::Macro(ident, _def, _kind) => {`
`570`		`- try_visit!(visitor.visit_ident(ident));`
	`569`	`+ ItemKind::Macro(name, _def, _kind) => {`
	`570`	`+ try_visit!(visitor.visit_ident(name));`
`571`	`571`	`}`
`572`	`572`	`ItemKind::Mod(ident, ref module) => {`
`573`	`573`	`try_visit!(visitor.visit_ident(ident));`