tidy up things

jdonszelmann · jdonszelmann · commit 95bfa31e876d · 2025-03-31T18:44:27.000+02:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -3472,7 +3472,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
@@ -977,9 +977,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
@@ -908,8 +908,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
@@ -155,21 +155,55 @@ 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 mut ident = i.ident;
         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 attrs = self.lower_attrs(hir_id, &i.attrs, i.span, &extra_hir_attributes);
+        let extra_attributes = self.generate_extra_attrs_for_item_kind(i.id, &i.kind);
+        let attrs = self.lower_attrs(hir_id, &i.attrs, i.span, &extra_attributes);
         let kind = self.lower_item_kind(i.span, i.id, hir_id, &mut ident, attrs, vis_span, &i.kind);
         let item = hir::Item {
             owner_id: hir_id.expect_owner(),
@@ -221,7 +255,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 body,
                 contract,
                 define_opaque,
-                eii_impl,
                 ..
             }) => {
                 self.with_new_scopes(*fn_sig_span, |this| {
@@ -446,7 +479,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::ItemKind::TraitAlias(generics, bounds)
             }
-            ItemKind::MacroDef(MacroDef { body, macro_rules, eii_macro_for }) => {
+            ItemKind::MacroDef(MacroDef { body, macro_rules, eii_macro_for: _ }) => {
                 let body = P(self.lower_delim_args(body));
                 let def_id = self.local_def_id(id);
                 let def_kind = self.tcx.def_kind(def_id);
@@ -456,19 +489,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         def_kind.descr(def_id.to_def_id())
                     );
                 };
-                let ast_macro_def = self.arena.alloc(ast::MacroDef {
+
+                let macro_def = self.arena.alloc(ast::MacroDef {
                     body,
                     macro_rules: *macro_rules,
                     eii_macro_for: None,
                 });
-
-                hir::ItemKind::Macro {
-                    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(macro_def, macro_kind)
             }
             ItemKind::Delegation(box delegation) => {
                 let delegation_results = self.lower_delegation(delegation, id);
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
@@ -660,9 +660,9 @@ impl<'a> State<'a> {
             }
         }
 
-        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)>),
     Stability {
diff --git a/compiler/rustc_attr_parsing/src/attributes/eii.rs b/compiler/rustc_attr_parsing/src/attributes/eii.rs
@@ -1,7 +1,5 @@
-use rustc_ast::LitKind;
 use rustc_attr_data_structures::AttributeKind;
 use rustc_feature::{AttributeTemplate, template};
-use rustc_middle::bug;
 use rustc_span::sym;
 
 use super::{AcceptContext, AttributeOrder, OnDuplicate};
@@ -21,42 +19,3 @@ impl<S: Stage> SingleAttributeParser<S> for EiiParser {
         Some(AttributeKind::Eii(cx.attr_span))
     }
 }
-
-// pub(crate) struct EiiImplParser;
-//
-// impl<S: Stage> SingleAttributeParser<S> for EiiImplParser {
-//     const PATH: &'static [rustc_span::Symbol] = &[sym::eii_impl];
-//     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
-//     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
-//     const TEMPLATE: AttributeTemplate = template!(List: "<eii_id>, /*opt*/ default");
-//
-//     fn convert(cx: &AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
-//         let Some(l) = args.list() else {
-//             cx.expected_list(cx.attr_span);
-//             return None;
-//         };
-//
-//         let mut args = l.mixed();
-//
-//         let id = args.next().unwrap();
-//         let is_default = args.next();
-//         assert!(args.next().is_none());
-//
-//         let Some(id) = id.lit().and_then(|i| if let LitKind::Int(i, _) = i.kind {
-//             Some(i)
-//         } else {
-//             None
-//         }) else {
-//             bug!("expected integer");
-//         };
-//
-//         let Ok(id) = u32::try_from(id.get()) else {
-//             bug!("too large");
-//         };
-//         let id = EiiId::from(id);
-//
-//         // AttributeKind::EiiImpl { eii: (), is_default: () }
-//         todo!()
-//     }
-// }
-//
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::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
@@ -77,7 +76,6 @@ attribute_groups!(
         // tidy-alphabetical-start
         Single<ConstStabilityIndirectParser>,
         Single<DeprecationParser>,
-        Single<EiiParser>,
         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
@@ -3947,7 +3947,7 @@ impl<'hir> Item<'hir> {
         expect_fn, (&FnSig<'hir>, &'hir Generics<'hir>, BodyId),
             ItemKind::Fn { sig, generics, body, .. }, (sig, generics, *body);
 
-        expect_macro, (&ast::MacroDef, MacroKind, Option<DefId>), ItemKind::Macro {ast_macro_def, kind, eii_macro_for}, (ast_macro_def, *kind, *eii_macro_for);
+        expect_macro, (&ast::MacroDef, MacroKind), ItemKind::Macro(def, mk), (def, *mk);
 
         expect_mod, &'hir Mod<'hir>, ItemKind::Mod(m), m;
 
@@ -4115,7 +4115,7 @@ pub enum ItemKind<'hir> {
         has_body: bool,
     },
     /// A MBE macro definition (`macro_rules!` or `macro`).
-    Macro { ast_macro_def: &'hir ast::MacroDef, kind: MacroKind, eii_macro_for: Option<DefId> },
+    Macro(&'hir ast::MacroDef, MacroKind),
     /// A module.
     Mod(&'hir Mod<'hir>),
     /// An external module, e.g. `extern { .. }`.
@@ -4192,7 +4192,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};
 
@@ -560,7 +559,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
                 item.owner_id.def_id,
             ));
         }
-        ItemKind::Macro { .. } => {}
+        ItemKind::Macro(..) => {}
         ItemKind::Mod(ref module) => {
             try_visit!(visitor.visit_mod(module, item.span, item.hir_id()));
         }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -638,9 +638,8 @@ impl<'a> State<'a> {
                 self.end(); // need to close a box
                 self.ann.nested(self, Nested::Body(body));
             }
-            hir::ItemKind::Macro { ast_macro_def, kind: _, eii_macro_for: _ } => {
-                // TODO: print macro for as comment
-                self.print_mac_def(ast_macro_def, &item.ident, item.span, |_| {});
+            hir::ItemKind::Macro(macro_def, _) => {
+                self.print_mac_def(macro_def, &item.ident, item.span, |_| {});
             }
             hir::ItemKind::Mod(_mod) => {
                 self.head("mod");
diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs
@@ -238,7 +238,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
@@ -1839,18 +1839,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
@@ -404,7 +404,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
@@ -2308,8 +2308,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 {
@@ -2640,7 +2639,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 { 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
@@ -575,11 +575,7 @@ impl<'tcx> EmbargoVisitor<'tcx> {
             // 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
-                {
+                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);
                     }
@@ -658,14 +654,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
`@@ -3472,7 +3472,7 @@ pub struct Fn {`
`3472`	`3472`	`pub body: Option<P<Block>>,`
`3473`	`3473`
`3474`	`3474`	/// This fn implements some EII, pointed to by the `path`
`3475`		`- pub eii_impl: ThinVec<(NodeId, MetaItem)>,`
	`3475`	`+ pub eii_impl: ThinVec<(NodeId, Path)>,`
`3476`	`3476`	`}`
`3477`	`3477`
`3478`	`3478`	`#[derive(Clone, Encodable, Decodable, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -908,8 +908,8 @@ pub fn walk_fn<'a, V: Visitor<'a>>(visitor: &mut V, kind: FnKind<'a>) -> V::Resu`
`908`	`908`	`) => {`
`909`	`909`	`// Identifier and visibility are visited as a part of the item.`
`910`	`910`
`911`		`- for (node_id, mi) in eii_impl {`
`912`		`- try_visit!(visitor.visit_path(&mi.path, *node_id));`
	`911`	`+ for (node_id, path) in eii_impl {`
	`912`	`+ try_visit!(visitor.visit_path(path, *node_id));`
`913`	`913`	`}`
`914`	`914`
`915`	`915`	`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 =`
Original file line number	Diff line number	Diff line change
`@@ -660,9 +660,9 @@ impl<'a> State<'a> {`
`660`	`660`	`}`
`661`	`661`	`}`
`662`	`662`
`663`		`- for (_, mi) in eii_impl {`
	`663`	`+ for (_, path) in eii_impl {`
`664`	`664`	`self.word("#[");`
`665`		`- self.print_meta_item(mi);`
	`665`	`+ self.print_path(path, false, 0);`
`666`	`666`	`self.word("]");`
`667`	`667`	`self.hardbreak();`
`668`	`668`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ pub(crate) fn eii_macro(`
`31`	`31`
`32`	`32`	`assert!(meta_item.is_word());`
`33`	`33`
`34`		`- f.eii_impl.push((DUMMY_NODE_ID, meta_item.clone()));`
	`34`	`+ f.eii_impl.push((DUMMY_NODE_ID, meta_item.path.clone()));`
`35`	`35`
`36`	`36`	`vec![item]`
`37`	`37`	`}`