add map for eii ids in resolver

Author: jdonszelmann

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -27,6 +27,7 @@ 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;

compiler/rustc_attr_parsing/src/context.rs

@@ -14,6 +14,7 @@ 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::{
@@ -77,6 +78,7 @@ attribute_groups!(
         // tidy-alphabetical-start
         Single<ConstStabilityIndirectParser>,
         Single<DeprecationParser>,
+        Single<EiiParser>,
         Single<RustcMacroEdition2021Parser>,
         Single<TransparencyParser>,
         // tidy-alphabetical-end
@@ -211,7 +213,6 @@ impl<'sess> AttributeParser<'sess> {
         attrs: &'a [ast::Attribute],
         target_span: Span,
         omit_doc: OmitDoc,
-
         lower_span: impl Copy + Fn(Span) -> Span,
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();

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::{DUMMY_SP, ExpnId, ExpnKind, Ident, Span, Symbol, kw, sym};
+use rustc_span::{EiiId, 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,6 +215,9 @@ 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)]

compiler/rustc_passes/src/check_attr.rs

@@ -124,6 +124,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     AttributeKind::Stability { span, .. }
                     | AttributeKind::ConstStability { span, .. },
                 ) => self.check_stability_promotable(*span, target),
+                Attribute::Parsed(AttributeKind::Eii(attr_span)) => {
+                    self.check_eii(hir_id, *attr_span, span, target)
+                }
                 Attribute::Parsed(AttributeKind::AllowInternalUnstable(syms)) => self
                     .check_allow_internal_unstable(
                         hir_id,
@@ -470,6 +473,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
+    /// Checks if an `#[inline]` is applied to a function or a closure.
+    fn check_eii(&self, _hir_id: HirId, _attr_span: Span, _defn_span: Span, target: Target) {
+        match target {
+            Target::ForeignFn => {}
+            target => {
+                // TODO:
+                bug!("wrong target for EII: {target:?}");
+            }
+        }
+    }
+
     /// Checks that `#[coverage(..)]` is applied to a function/closure/method,
     /// or to an impl block or module.
     fn check_coverage(&self, attr: &Attribute, target_span: Span, target: Target) {

compiler/rustc_resolve/src/def_collector.rs

@@ -8,8 +8,9 @@ use rustc_expand::expand::AstFragment;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind};
 use rustc_hir::def_id::LocalDefId;
+use rustc_middle::bug;
 use rustc_span::hygiene::LocalExpnId;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{EiiId, Span, Symbol, sym};
 use tracing::debug;
 
 use crate::{ImplTraitContext, InvocationParent, Resolver};
@@ -137,6 +138,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     &i.attrs,
                     i.span,
                     OmitDoc::Skip,
+                    None,
                     std::convert::identity,
                 );
 
@@ -261,6 +263,22 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
 
         let def = self.create_def(fi.id, Some(ident.name), def_kind, fi.span);
 
+        if let ForeignItemKind::Fn(_) = fi.kind {
+            for attr in &fi.attrs {
+                if attr.has_name(sym::eii)
+                    && let Some([arg]) = attr.meta_item_list().as_deref()
+                    && let Some(lit) = arg.lit()
+                    && let LitKind::Int(i, _) = lit.kind
+                    && let Ok(id) = u32::try_from(i.get())
+                {
+                    let id = EiiId::from(id);
+                    if let Some(other) = self.resolver.eii.insert(id, def) {
+                        bug!("{def:?}: {id:?} used more than once (used first on {other:?})");
+                    }
+                }
+            }
+        }
+
         self.with_parent(def, |this| visit::walk_item(this, fi));
     }
 

compiler/rustc_resolve/src/lib.rs

@@ -69,7 +69,7 @@ use rustc_query_system::ich::StableHashingContext;
 use rustc_session::lint::builtin::PRIVATE_MACRO_USE;
 use rustc_session::lint::{BuiltinLintDiag, LintBuffer};
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency};
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, EiiId, Ident, Span, Symbol, kw, sym};
 use smallvec::{SmallVec, smallvec};
 use tracing::debug;
 
@@ -1227,6 +1227,9 @@ pub struct Resolver<'ra, 'tcx> {
     current_crate_outer_attr_insert_span: Span,
 
     mods_with_parse_errors: FxHashSet<DefId>,
+
+    /// Map of defids for all items marked with #[eii(<eii id>)].
+    eii: FxHashMap<EiiId, LocalDefId>,
 }
 
 /// This provides memory for the rest of the crate. The `'ra` lifetime that is
@@ -1581,6 +1584,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             impl_binding_keys: Default::default(),
             current_crate_outer_attr_insert_span,
             mods_with_parse_errors: Default::default(),
+            eii: Default::default(),
         };
 
         let root_parent_scope = ParentScope::module(graph_root, &resolver);
@@ -1694,6 +1698,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             lifetime_elision_allowed: self.lifetime_elision_allowed,
             lint_buffer: Steal::new(self.lint_buffer),
             delegation_fn_sigs: self.delegation_fn_sigs,
+            eii: self.eii,
         };
         ResolverOutputs { global_ctxt, ast_lowering }
     }

compiler/rustc_span/src/lib.rs

@@ -1209,6 +1209,12 @@ rustc_index::newtype_index! {
     pub struct AttrId {}
 }
 
+rustc_index::newtype_index! {
+    #[orderable]
+    #[debug_format = "EiiId({})"]
+    pub struct EiiId {}
+}
+
 /// This trait is used to allow encoder specific encodings of certain types.
 /// It is similar to rustc_type_ir's TyEncoder.
 pub trait SpanEncoder: Encoder {