tidy up things

jdonszelmann · jdonszelmann · commit da12aaa62871 · 2025-04-18T17:33:47.000+02:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -3589,7 +3589,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
@@ -946,9 +946,9 @@ fn walk_fn<T: MutVisitor>(vis: &mut T, kind: FnKind<'_>) {
             visit_defaultness(vis, defaultness);
             vis.visit_ident(ident);
 
-            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
@@ -961,8 +961,8 @@ pub fn walk_fn<'a, V: Visitor<'a>>(visitor: &mut V, kind: FnKind<'a>) -> V::Resu
             try_visit!(visitor.visit_ident(ident));
 
             // 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
@@ -148,21 +148,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, attrs, vis_span, &i.kind);
+
         let item = hir::Item {
             owner_id: hir_id.expect_owner(),
             kind,
@@ -233,7 +269,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 body,
                 contract,
                 define_opaque,
-                eii_impl,
                 ..
             }) => {
                 self.with_new_scopes(*fn_sig_span, |this| {
@@ -475,7 +510,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::ItemKind::TraitAlias(ident, generics, bounds)
             }
-            ItemKind::MacroDef(ident, MacroDef { body, macro_rules, eii_macro_for }) => {
+            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);
@@ -493,14 +528,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) => {
                 let delegation_results = self.lower_delegation(delegation, id, false);
@@ -680,6 +708,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self.lower_generics(generics, i.id, itctx, |this| {
                         (
                             // Disallow `impl Trait` in foreign items.
+                            this.lower_fn_decl(fdec, i.id, sig.span, FnDeclKind::ExternFn, None),
                             this.lower_fn_params_to_idents(fdec),
                         )
                     });
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -948,8 +948,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 self.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);
                 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> {
         let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque, eii_impl } = func;
         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
@@ -9,7 +9,7 @@ pub(crate) fn eii_macro_for(
     mut item: Annotatable,
 ) -> Vec<Annotatable> {
     let Annotatable::Item(i) = &mut item else { panic!("expected item") };
-    let ItemKind::MacroDef(d) = &mut i.kind else { panic!("expected macro def") };
+    let ItemKind::MacroDef(_, d) = &mut i.kind else { panic!("expected macro def") };
 
     let Some(list) = meta_item.meta_item_list() else { panic!("expected list") };
 
@@ -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
@@ -3998,7 +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, 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);
 
@@ -4175,7 +4175,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 { .. }`.
@@ -4275,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
@@ -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
@@ -1844,18 +1844,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
@@ -411,7 +411,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
@@ -2356,8 +2356,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 {
@@ -2688,7 +2687,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
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
`@@ -3589,7 +3589,7 @@ pub struct Fn {`
`3589`	`3589`	`pub body: Option<P<Block>>,`
`3590`	`3590`
`3591`	`3591`	/// This fn implements some EII, pointed to by the `path`
`3592`		`- pub eii_impl: ThinVec<(NodeId, MetaItem)>,`
	`3592`	`+ pub eii_impl: ThinVec<(NodeId, Path)>,`
`3593`	`3593`	`}`
`3594`	`3594`
`3595`	`3595`	`#[derive(Clone, Encodable, Decodable, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -961,8 +961,8 @@ pub fn walk_fn<'a, V: Visitor<'a>>(visitor: &mut V, kind: FnKind<'a>) -> V::Resu`
`961`	`961`	`try_visit!(visitor.visit_ident(ident));`
`962`	`962`
`963`	`963`	`// Identifier and visibility are visited as a part of the item.`
`964`		`- for (node_id, mi) in eii_impl {`
`965`		`- try_visit!(visitor.visit_path(&mi.path, *node_id));`
	`964`	`+ for (node_id, path) in eii_impl {`
	`965`	`+ try_visit!(visitor.visit_path(path, *node_id));`
`966`	`966`	`}`
`967`	`967`
`968`	`968`	`try_visit!(visitor.visit_fn_header(header));`
Original file line number	Diff line number	Diff line change
`@@ -948,8 +948,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`948`	`948`	`self.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);`
`949`	`949`	`self.check_defaultness(item.span, *defaultness);`
`950`	`950`
`951`		`- for (id, mi) in eii_impl {`
`952`		`- self.visit_path(&mi.path, *id);`
	`951`	`+ for (id, path) in eii_impl {`
	`952`	`+ self.visit_path(path, *id);`
`953`	`953`	`}`
`954`	`954`
`955`	`955`	`let is_intrinsic =`