EII lowering

jdonszelmann · jdonszelmann · commit 9949588e6c9e · 2025-09-09T11:59:02.000-07:00
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -2,13 +2,14 @@ use rustc_abi::ExternAbi;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
 use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
-use rustc_hir::attrs::AttributeKind;
+use rustc_hir::attrs::{AttributeKind, EiiDecl};
 use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
 use rustc_hir::{self as hir, HirId, LifetimeSource, PredicateOrigin, Target, find_attr};
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
+use rustc_span::def_id::DefId;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
 use smallvec::{SmallVec, smallvec};
@@ -133,10 +134,92 @@ 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_impls, .. }) if eii_impls.is_empty() => Vec::new(),
+            ItemKind::Fn(box Fn { eii_impls, .. }) => {
+                vec![hir::Attribute::Parsed(AttributeKind::EiiImpls(
+                    eii_impls
+                        .iter()
+                        .flat_map(
+                            |EiiImpl {
+                                 node_id,
+                                 eii_macro_path,
+                                 impl_safety,
+                                 span,
+                                 inner_span,
+                                 is_default,
+                             }| {
+                                self.lower_path_simple_eii(*node_id, eii_macro_path).map(|did| {
+                                    hir::attrs::EiiImpl {
+                                        eii_macro: did,
+                                        span: self.lower_span(*span),
+                                        inner_span: self.lower_span(*inner_span),
+                                        impl_marked_unsafe: self
+                                            .lower_safety(*impl_safety, hir::Safety::Safe)
+                                            .is_unsafe(),
+                                        is_default: *is_default,
+                                    }
+                                })
+                            },
+                        )
+                        .collect(),
+                ))]
+            }
+            ItemKind::MacroDef(
+                _,
+                MacroDef {
+                    eii_extern_target: Some(EiiExternTarget { extern_item_path, impl_unsafe, span }),
+                    ..
+                },
+            ) => self
+                .lower_path_simple_eii(id, extern_item_path)
+                .map(|did| {
+                    vec![hir::Attribute::Parsed(AttributeKind::EiiExternTarget(EiiDecl {
+                        eii_extern_target: did,
+                        impl_unsafe: *impl_unsafe,
+                        span: self.lower_span(*span),
+                    }))]
+                })
+                .unwrap_or_default(),
+            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 attrs = self.lower_attrs(hir_id, &i.attrs, i.span, Target::from_ast_item(i));
+
+        let extra_hir_attributes = self.generate_extra_attrs_for_item_kind(i.id, &i.kind);
+        let attrs = self.lower_attrs_with_extra(
+            hir_id,
+            &i.attrs,
+            i.span,
+            Target::from_ast_item(i),
+            &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(),
@@ -465,6 +548,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
+    fn lower_path_simple_eii(&mut self, id: NodeId, path: &Path) -> Option<DefId> {
+        let res = self.resolver.get_partial_res(id)?;
+        let Some(did) = res.expect_full_res().opt_def_id() else {
+            self.dcx().span_delayed_bug(path.span, "should have errored in resolve");
+            return None;
+        };
+
+        Some(did)
+    }
+
     fn lower_const_item(
         &mut self,
         ty: &Ty,
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -945,11 +945,23 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         target_span: Span,
         target: Target,
     ) -> &'hir [hir::Attribute] {
-        if attrs.is_empty() {
+        self.lower_attrs_with_extra(id, attrs, target_span, target, &[])
+    }
+
+    fn lower_attrs_with_extra(
+        &mut self,
+        id: HirId,
+        attrs: &[Attribute],
+        target_span: Span,
+        target: Target,
+        extra_hir_attributes: &[hir::Attribute],
+    ) -> &'hir [hir::Attribute] {
+        if attrs.is_empty() && extra_hir_attributes.is_empty() {
             &[]
         } else {
-            let lowered_attrs =
+            let mut lowered_attrs =
                 self.lower_attrs_vec(attrs, self.lower_span(target_span), id, target);
+            lowered_attrs.extend(extra_hir_attributes.iter().cloned());
 
             assert_eq!(id.owner, self.current_hir_id_owner);
             let ret = self.arena.alloc_from_iter(lowered_attrs);
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -16,6 +16,23 @@ use thin_vec::ThinVec;
 use crate::attrs::pretty_printing::PrintAttribute;
 use crate::{DefaultBodyStability, PartialConstStability, RustcVersion, Stability};
 
+#[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub struct EiiImpl {
+    pub eii_macro: DefId,
+    pub impl_marked_unsafe: bool,
+    pub span: Span,
+    pub inner_span: Span,
+    pub is_default: bool,
+}
+
+#[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub struct EiiDecl {
+    pub eii_extern_target: DefId,
+    /// whether or not it is unsafe to implement this EII
+    pub impl_unsafe: bool,
+    pub span: Span,
+}
+
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, PrintAttribute)]
 pub enum InlineAttr {
     None,
@@ -502,6 +519,12 @@ pub enum AttributeKind {
     /// Represents `#[rustc_dummy]`.
     Dummy,
 
+    /// Implementation detail of `#[eii]`
+    EiiExternTarget(EiiDecl),
+
+    /// Implementation detail of `#[eii]`
+    EiiImpls(ThinVec<EiiImpl>),
+
     /// Represents [`#[export_name]`](https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute).
     ExportName {
         /// The name to export this item with.
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -43,6 +43,8 @@ impl AttributeKind {
             DoNotImplementViaObject(..) => No,
             DocComment { .. } => Yes,
             Dummy => No,
+            EiiExternTarget(_) => Yes,
+            EiiImpls(..) => No,
             ExportName { .. } => Yes,
             ExportStable => No,
             FfiConst(..) => No,
diff --git a/compiler/rustc_hir/src/attrs/pretty_printing.rs b/compiler/rustc_hir/src/attrs/pretty_printing.rs
@@ -4,6 +4,7 @@ use rustc_abi::Align;
 use rustc_ast::token::CommentKind;
 use rustc_ast::{AttrStyle, IntTy, UintTy};
 use rustc_ast_pretty::pp::Printer;
+use rustc_span::def_id::DefId;
 use rustc_span::hygiene::Transparency;
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 use rustc_target::spec::SanitizerSet;
@@ -157,4 +158,5 @@ print_debug!(
     CommentKind,
     Transparency,
     SanitizerSet,
+    DefId,
 );
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
@@ -708,3 +708,18 @@ passes_useless_stability =
     this stability annotation is useless
     .label = useless stability annotation
     .item = the stability attribute annotates this item
+
+passes_eii_fn_with_target_feature =
+    `#[{$name}]` is not allowed to have `#[target_feature]`
+    .label = `#[{$name}]` is not allowed to have `#[target_feature]`
+
+passes_eii_fn_with_track_caller =
+    `#[{$name}]` is not allowed to have `#[track_caller]`
+    .label = `#[{$name}]` is not allowed to have `#[track_caller]`
+
+passes_eii_impl_not_function =
+    `eii_macro_for` is only valid on functions
+
+passes_eii_impl_requires_unsafe =
+    `#[{$name}]` is unsafe to implement
+passes_eii_impl_requires_unsafe_suggestion = wrap the attribute in `unsafe(...)`
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -18,7 +18,9 @@ use rustc_feature::{
     ACCEPTED_LANG_FEATURES, AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP,
     BuiltinAttribute,
 };
-use rustc_hir::attrs::{AttributeKind, InlineAttr, MirDialect, MirPhase, ReprAttr, SanitizerSet};
+use rustc_hir::attrs::{
+    AttributeKind, EiiDecl, EiiImpl, InlineAttr, MirDialect, MirPhase, ReprAttr, SanitizerSet,
+};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalModDefId;
 use rustc_hir::intravisit::{self, Visitor};
@@ -218,8 +220,12 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::Link(_, attr_span)) => {
                     self.check_link(hir_id, *attr_span, span, target)
                 }
+                Attribute::Parsed(AttributeKind::EiiImpls(impls)) => {
+                     self.check_eii_impl(impls, target)
+                },
                 Attribute::Parsed(
-                    AttributeKind::BodyStability { .. }
+                    AttributeKind::EiiExternTarget { .. }
+                    | AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
                     | AttributeKind::MacroTransparency(_)
                     | AttributeKind::Pointee(..)
@@ -450,6 +456,30 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         );
     }
 
+    fn check_eii_impl(&self, impls: &[EiiImpl], target: Target) {
+        for EiiImpl { span, inner_span, eii_macro, impl_marked_unsafe, is_default: _ } in impls {
+            match target {
+                Target::Fn => {}
+                _ => {
+                    self.dcx().emit_err(errors::EiiImplNotFunction { span: *span });
+                }
+            }
+
+            if find_attr!(self.tcx.get_all_attrs(*eii_macro), AttributeKind::EiiExternTarget(EiiDecl { impl_unsafe, .. }) if *impl_unsafe)
+                && !impl_marked_unsafe
+            {
+                self.dcx().emit_err(errors::EiiImplRequiresUnsafe {
+                    span: *span,
+                    name: self.tcx.item_name(*eii_macro),
+                    suggestion: errors::EiiImplRequiresUnsafeSuggestion {
+                        left: inner_span.shrink_to_lo(),
+                        right: inner_span.shrink_to_hi(),
+                    },
+                });
+            }
+        }
+    }
+
     /// Checks if `#[diagnostic::do_not_recommend]` is applied on a trait impl and that it has no
     /// arguments.
     fn check_do_not_recommend(
@@ -649,6 +679,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         sig_span: sig.span,
                     });
                 }
+
+                if let Some(impls) = find_attr!(attrs, AttributeKind::EiiImpls(impls) => impls) {
+                    let sig = self.tcx.hir_node(hir_id).fn_sig().unwrap();
+                    for i in impls {
+                        self.dcx().emit_err(errors::EiiWithTrackCaller {
+                            attr_span,
+                            name: self.tcx.item_name(i.eii_macro),
+                            sig_span: sig.span,
+                        });
+                    }
+                }
             }
             _ => {}
         }
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
@@ -1630,3 +1630,42 @@ pub(crate) struct CustomMirIncompatibleDialectAndPhase {
     #[label]
     pub phase_span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(passes_eii_impl_not_function)]
+pub(crate) struct EiiImplNotFunction {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(passes_eii_impl_requires_unsafe)]
+pub(crate) struct EiiImplRequiresUnsafe {
+    #[primary_span]
+    pub span: Span,
+    pub name: Symbol,
+    #[subdiagnostic]
+    pub suggestion: EiiImplRequiresUnsafeSuggestion,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    passes_eii_impl_requires_unsafe_suggestion,
+    applicability = "machine-applicable"
+)]
+pub(crate) struct EiiImplRequiresUnsafeSuggestion {
+    #[suggestion_part(code = "unsafe(")]
+    pub left: Span,
+    #[suggestion_part(code = ")")]
+    pub right: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(passes_eii_fn_with_track_caller)]
+pub(crate) struct EiiWithTrackCaller {
+    #[primary_span]
+    pub attr_span: Span,
+    pub name: Symbol,
+    #[label]
+    pub sig_span: Span,
+}
