tidy up things

jdonszelmann · jdonszelmann · commit d328f2502ddd · 2025-04-01T16:26:53.000+02:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -3502,7 +3502,7 @@ pub struct Fn {
     pub body: Option<P<Block>>,
 
     /// This fn implements some EII, pointed to by the `path`
-    pub eii_impl: ThinVec<(NodeId, MetaItem)>,
+    pub eii_impl: ThinVec<(NodeId, Path)>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -981,9 +981,9 @@ fn walk_fn<T: MutVisitor>(vis: &mut T, kind: FnKind<'_>) {
             // Identifier and visibility are visited as a part of the item.
             visit_defaultness(vis, defaultness);
 
-            for (node_id, mi) in eii_impl {
+            for (node_id, path) in eii_impl {
                 vis.visit_id(node_id);
-                vis.visit_path(&mut mi.path);
+                vis.visit_path(path);
             }
             vis.visit_fn_header(header);
             vis.visit_generics(generics);
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -935,8 +935,8 @@ pub fn walk_fn<'a, V: Visitor<'a>>(visitor: &mut V, kind: FnKind<'a>) -> V::Resu
         ) => {
             // Identifier and visibility are visited as a part of the item.
 
-            for (node_id, mi) in eii_impl {
-                try_visit!(visitor.visit_path(&mi.path, *node_id));
+            for (node_id, path) in eii_impl {
+                try_visit!(visitor.visit_path(path, *node_id));
             }
 
             try_visit!(visitor.visit_fn_header(header));
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -149,21 +149,57 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
+    fn generate_extra_attrs_for_item_kind(
+        &mut self,
+        id: NodeId,
+        i: &ItemKind,
+    ) -> Vec<hir::Attribute> {
+        match i {
+            ItemKind::Fn(box Fn { eii_impl, .. }) => {
+                let mut res = Vec::new();
+
+                for (id, path) in eii_impl {
+                    let did = self.lower_path_simple_eii(*id, path);
+                    res.push(hir::Attribute::Parsed(AttributeKind::EiiImpl { eii_macro: did }));
+                }
+
+                res
+            }
+            ItemKind::MacroDef(MacroDef { eii_macro_for: Some(path), .. }) => {
+                vec![hir::Attribute::Parsed(AttributeKind::EiiMacroFor {
+                    eii_extern_item: self.lower_path_simple_eii(id, path),
+                })]
+            }
+            ItemKind::ExternCrate(..)
+            | ItemKind::Use(..)
+            | ItemKind::Static(..)
+            | ItemKind::Const(..)
+            | ItemKind::Mod(..)
+            | ItemKind::ForeignMod(..)
+            | ItemKind::GlobalAsm(..)
+            | ItemKind::TyAlias(..)
+            | ItemKind::Enum(..)
+            | ItemKind::Struct(..)
+            | ItemKind::Union(..)
+            | ItemKind::Trait(..)
+            | ItemKind::TraitAlias(..)
+            | ItemKind::Impl(..)
+            | ItemKind::MacCall(..)
+            | ItemKind::MacroDef(..)
+            | ItemKind::Delegation(..)
+            | ItemKind::DelegationMac(..) => Vec::new(),
+        }
+    }
+
     fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {
         let vis_span = self.lower_span(i.vis.span);
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
 
-        let mut extra_hir_attributes = Vec::new();
-        if let ItemKind::Fn(f) = &i.kind {
-            extra_hir_attributes.extend(f.eii_impl.iter().map(|(id, mi)| {
-                let did = self.lower_path_simple_eii(*id, &mi.path);
-
-                hir::Attribute::Parsed(AttributeKind::EiiImpl { eii_macro: did })
-            }));
-        }
+        let extra_hir_attributes = self.generate_extra_attrs_for_item_kind(i.id, &i.kind);
 
         let attrs = self.lower_attrs(hir_id, &i.attrs, i.span, &extra_hir_attributes);
         let kind = self.lower_item_kind(i.span, i.id, hir_id, i.ident, attrs, vis_span, &i.kind);
+
         let item = hir::Item {
             owner_id: hir_id.expect_owner(),
             kind,
@@ -230,7 +266,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 body,
                 contract,
                 define_opaque,
-                eii_impl,
                 ..
             }) => {
                 debug_assert_ne!(ident.name, kw::Empty);
@@ -485,7 +520,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::ItemKind::TraitAlias(ident, generics, bounds)
             }
-            ItemKind::MacroDef(MacroDef { body, macro_rules, eii_macro_for }) => {
+            ItemKind::MacroDef(MacroDef { body, macro_rules, eii_macro_for: _ }) => {
                 debug_assert_ne!(ident.name, kw::Empty);
                 let ident = self.lower_ident(ident);
                 let body = P(self.lower_delim_args(body));
@@ -504,14 +539,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     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| self.lower_path_simple_eii(id, path)),
-                }
+                hir::ItemKind::Macro(ident, ast_macro_def, macro_kind)
             }
             ItemKind::Delegation(box delegation) => {
                 debug_assert_ne!(ident.name, kw::Empty);
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -930,8 +930,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             ) => {
                 self.check_defaultness(item.span, *defaultness);
 
-                for (id, mi) in eii_impl {
-                    self.visit_path(&mi.path, *id);
+                for (id, path) in eii_impl {
+                    self.visit_path(path, *id);
                 }
 
                 let is_intrinsic =
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -682,9 +682,9 @@ impl<'a> State<'a> {
 
         self.print_define_opaques(define_opaque.as_deref());
 
-        for (_, mi) in eii_impl {
+        for (_, path) in eii_impl {
             self.word("#[");
-            self.print_meta_item(mi);
+            self.print_path(path, false, 0);
             self.word("]");
             self.hardbreak();
         }
diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -194,6 +194,9 @@ pub enum AttributeKind {
     EiiImpl {
         eii_macro: DefId,
     },
+    EiiMacroFor {
+        eii_extern_item: DefId,
+    },
     MacroTransparency(Transparency),
     Repr(ThinVec<(ReprAttr, Span)>),
     RustcMacroEdition2021,
diff --git a/compiler/rustc_attr_parsing/src/attributes/eii.rs b/compiler/rustc_attr_parsing/src/attributes/eii.rs
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -27,7 +27,6 @@ pub(crate) mod allow_unstable;
 pub(crate) mod cfg;
 pub(crate) mod confusables;
 pub(crate) mod deprecation;
-pub(crate) mod eii;
 pub(crate) mod repr;
 pub(crate) mod rustc;
 pub(crate) mod stability;
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
@@ -14,7 +14,6 @@ use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
-use crate::attributes::eii::EiiParser;
 use crate::attributes::repr::ReprParser;
 use crate::attributes::rustc::RustcMacroEdition2021Parser;
 use crate::attributes::stability::{
@@ -78,7 +77,6 @@ attribute_groups!(
         // tidy-alphabetical-start
         Single<ConstStabilityIndirectParser>,
         Single<DeprecationParser>,
-        Single<EiiParser>,
         Single<RustcMacroEdition2021Parser>,
         Single<TransparencyParser>,
         // tidy-alphabetical-end
diff --git a/compiler/rustc_builtin_macros/src/eii.rs b/compiler/rustc_builtin_macros/src/eii.rs
@@ -31,7 +31,7 @@ pub(crate) fn eii_macro(
 
     assert!(meta_item.is_word());
 
-    f.eii_impl.push((DUMMY_NODE_ID, meta_item.clone()));
+    f.eii_impl.push((DUMMY_NODE_ID, meta_item.path.clone()));
 
     vec![item]
 }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -3992,7 +3992,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, Option<DefId>), ItemKind::Macro {name: ident, ast_macro_def, kind, eii_macro_for}, (*ident, ast_macro_def, *kind, *eii_macro_for);
+        expect_macro, (Ident, &ast::MacroDef, MacroKind), ItemKind::Macro(ident, def, mk), (*ident, def, *mk);
 
         expect_mod, (Ident, &'hir Mod<'hir>), ItemKind::Mod(ident, m), (*ident, m);
 
@@ -4169,7 +4169,7 @@ pub enum ItemKind<'hir> {
         has_body: bool,
     },
     /// A MBE macro definition (`macro_rules!` or `macro`).
-    Macro { name: Ident, ast_macro_def: &'hir ast::MacroDef, kind: MacroKind, eii_macro_for: Option<DefId> },
+    Macro(Ident, &'hir ast::MacroDef, MacroKind),
     /// A module.
     Mod(Ident, &'hir Mod<'hir>),
     /// An external module, e.g. `extern { .. }`.
@@ -4269,7 +4269,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
@@ -66,7 +66,6 @@
 
 use rustc_ast::Label;
 use rustc_ast::visit::{VisitorResult, try_visit, visit_opt, walk_list};
-use rustc_attr_data_structures::find_attr;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Ident, Span, Symbol};
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -631,9 +631,8 @@ impl<'a> State<'a> {
                 self.end(); // need to close a box
                 self.ann.nested(self, Nested::Body(body));
             }
-            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::Macro(ident, macro_def, _) => {
+                self.print_mac_def(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 { kind: MacroKind::Bang, .. }
+            ItemKind::Macro(_, _macro, MacroKind::Bang)
                 if cx.tcx.has_attr(item.owner_id.def_id, sym::macro_export) =>
             {
                 cx.emit_span_lint(
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1835,18 +1835,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     fn encode_info_for_macro(&mut self, def_id: LocalDefId) {
         let tcx = self.tcx;
 
-        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);
+        let hir::ItemKind::Macro(_, macro_def, _) = tcx.hir_expect_item(def_id).kind else { bug!() };
+        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);
     }
 
     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
@@ -405,7 +405,6 @@ 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_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -2323,8 +2323,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
         } else {
             // special case when `#[macro_export]` is applied to a macro 2.0
-            let (_, macro_definition, _, _eii_macro_for) =
-                self.tcx.hir_node(hir_id).expect_item().expect_macro();
+            let (_, macro_definition, _) = self.tcx.hir_node(hir_id).expect_item().expect_macro();
             let is_decl_macro = !macro_definition.macro_rules;
 
             if is_decl_macro {
@@ -2655,7 +2654,7 @@ 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 { name: _, ast_macro_def, kind: _, eii_macro_for: _ } = item.kind {
+        if let ItemKind::Macro(_, ast_macro_def, _) = item.kind {
             let def_id = item.owner_id.to_def_id();
             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_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -577,12 +577,8 @@ 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 {
-                    ast_macro_def: MacroDef { macro_rules: false, .. },
-                    ..
-                } = item.kind
-                {
+                let item = self.tcx.hir_expect_item(def_id);
+                if let hir::ItemKind::Macro(_, MacroDef { macro_rules: false, .. }, _) = item.kind {
                     if vis.is_accessible_from(module, self.tcx) {
                         self.update(def_id, macro_ev, Level::Reachable);
                     }
@@ -661,14 +657,9 @@ 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 { ast_macro_def, .. } => {
-                // TODO: consider EII for reachability
+            hir::ItemKind::Macro(_, macro_def, _) => {
                 if let Some(item_ev) = item_ev {
-                    self.update_reachability_from_macro(
-                        item.owner_id.def_id,
-                        ast_macro_def,
-                        item_ev,
-                    );
+                    self.update_reachability_from_macro(item.owner_id.def_id, macro_def, item_ev);
                 }
             }
             hir::ItemKind::Const(..)
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs

Original file line number	Diff line number	Diff line change
`@@ -3502,7 +3502,7 @@ pub struct Fn {`
`3502`	`3502`	`pub body: Option<P<Block>>,`
`3503`	`3503`
`3504`	`3504`	/// This fn implements some EII, pointed to by the `path`
`3505`		`- pub eii_impl: ThinVec<(NodeId, MetaItem)>,`
	`3505`	`+ pub eii_impl: ThinVec<(NodeId, Path)>,`
`3506`	`3506`	`}`
`3507`	`3507`
`3508`	`3508`	`#[derive(Clone, Encodable, Decodable, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -935,8 +935,8 @@ pub fn walk_fn<'a, V: Visitor<'a>>(visitor: &mut V, kind: FnKind<'a>) -> V::Resu`
`935`	`935`	`) => {`
`936`	`936`	`// Identifier and visibility are visited as a part of the item.`
`937`	`937`
`938`		`- for (node_id, mi) in eii_impl {`
`939`		`- try_visit!(visitor.visit_path(&mi.path, *node_id));`
	`938`	`+ for (node_id, path) in eii_impl {`
	`939`	`+ try_visit!(visitor.visit_path(path, *node_id));`
`940`	`940`	`}`
`941`	`941`
`942`	`942`	`try_visit!(visitor.visit_fn_header(header));`
Original file line number	Diff line number	Diff line change
`@@ -930,8 +930,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`930`	`930`	`) => {`
`931`	`931`	`self.check_defaultness(item.span, *defaultness);`
`932`	`932`
`933`		`- for (id, mi) in eii_impl {`
`934`		`- self.visit_path(&mi.path, *id);`
	`933`	`+ for (id, path) in eii_impl {`
	`934`	`+ self.visit_path(path, *id);`
`935`	`935`	`}`
`936`	`936`
`937`	`937`	`let is_intrinsic =`