codegen eii

Author: jdonszelmann

compiler/rustc_ast/src/ast.rs

@@ -1881,6 +1881,7 @@ pub struct MacroDef {
 pub struct EIIMacroFor {
     pub extern_item_path: Path,
     pub impl_unsafe: bool,
+    pub span: Span,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)]

compiler/rustc_ast/src/mut_visit.rs

@@ -751,7 +751,7 @@ fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {
 
 fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {
     let MacroDef { body, macro_rules: _, eii_macro_for } = macro_def;
-    if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = eii_macro_for {
+    if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _, span: _ }) = eii_macro_for {
         vis.visit_path(extern_item_path);
     }
     visit_delim_args(vis, body);

compiler/rustc_ast/src/visit.rs

@@ -460,7 +460,9 @@ impl WalkItemKind for ItemKind {
             ItemKind::MacCall(mac) => try_visit!(visitor.visit_mac_call(mac)),
             ItemKind::MacroDef(ts) => {
                 try_visit!(visitor.visit_mac_def(ts, id));
-                if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = &ts.eii_macro_for {
+                if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _, span: _ }) =
+                    &ts.eii_macro_for
+                {
                     try_visit!(visitor.visit_path(extern_item_path, id));
                 }
             }

compiler/rustc_ast_lowering/src/item.rs

@@ -2,7 +2,7 @@ use rustc_abi::ExternAbi;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
-use rustc_attr_parsing::AttributeKind;
+use rustc_attr_parsing::{AttributeKind, EIIDecl};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
@@ -184,13 +184,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ))]
             }
             ItemKind::MacroDef(MacroDef {
-                eii_macro_for: Some(EIIMacroFor { extern_item_path, impl_unsafe }),
+                eii_macro_for: Some(EIIMacroFor { extern_item_path, impl_unsafe, span }),
                 ..
             }) => {
-                vec![hir::Attribute::Parsed(AttributeKind::EiiMacroFor {
+                vec![hir::Attribute::Parsed(AttributeKind::EiiMacroFor(EIIDecl {
                     eii_extern_item: self.lower_path_simple_eii(id, extern_item_path),
                     impl_unsafe: *impl_unsafe,
-                })]
+                    span: self.lower_span(*span),
+                }))]
             }
             ItemKind::ExternCrate(..)
             | ItemKind::Use(..)

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -139,7 +139,7 @@ impl Deprecation {
     }
 }
 
-#[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+#[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
 pub struct EIIImpl {
     pub eii_macro: DefId,
     pub impl_marked_unsafe: bool,
@@ -148,6 +148,14 @@ pub struct EIIImpl {
     pub is_default: bool,
 }
 
+#[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub struct EIIDecl {
+    pub eii_extern_item: DefId,
+    /// whether or not it is unsafe to implement this EII
+    pub impl_unsafe: bool,
+    pub span: Span,
+}
+
 /// Represent parsed, *built in*, inert attributes.
 ///
 /// That means attributes that are not actually ever expanded.
@@ -200,11 +208,8 @@ pub enum AttributeKind {
         comment: Symbol,
     },
     EiiImpl(ThinVec<EIIImpl>),
-    EiiMacroFor {
-        eii_extern_item: DefId,
-        /// whether or not it is unsafe to implement this EII
-        impl_unsafe: bool,
-    },
+    EiiMacroFor(EIIDecl),
+    EiiMangleExtern,
     MacroTransparency(Transparency),
     Repr(ThinVec<(ReprAttr, Span)>),
     RustcMacroEdition2021,

compiler/rustc_attr_parsing/src/attributes/eii.rs

@@ -0,0 +1,17 @@
+use rustc_attr_data_structures::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use super::{AcceptContext, SingleAttributeParser};
+use crate::parser::ArgParser;
+
+pub(crate) struct EiiMangleExternParser;
+
+impl SingleAttributeParser for EiiMangleExternParser {
+    const PATH: &'static [Symbol] = &[sym::eii_mangle_extern];
+
+    fn on_duplicate(_cx: &AcceptContext<'_>, _first_span: Span) {}
+    fn convert(_cx: &AcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        assert!(args.no_args());
+        Some(AttributeKind::EiiMangleExtern)
+    }
+}

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::EiiMangleExternParser;
 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<EiiMangleExternParser>,
         Single<RustcMacroEdition2021Parser>,
         Single<TransparencyParser>,
         // tidy-alphabetical-end

compiler/rustc_builtin_macros/src/eii.rs

@@ -77,7 +77,7 @@ fn eii_(
     let item = item.into_inner();
 
     let ast::Item {
-        attrs,
+        mut attrs,
         id: _,
         span: item_span,
         vis,
@@ -145,14 +145,14 @@ fn eii_(
                             rules: ast::BlockCheckMode::Default,
                             span,
                             tokens: None,
-                            could_be_bare_literal: false,
                         }),
                         None,
                     ),
                     span,
                     attrs: ThinVec::new(),
                     tokens: None,
                 })),
+                define_opaque: None,
             })),
             tokens: None,
         })))
@@ -184,6 +184,21 @@ fn eii_(
     }
 
     // extern "…" { safe fn item(); }
+    // #[eii_mangle_extern]
+    attrs.push(ast::Attribute {
+        kind: ast::AttrKind::Normal(P(ast::NormalAttr {
+            item: ast::AttrItem {
+                unsafety: ast::Safety::Default,
+                path: ast::Path::from_ident(Ident::new(sym::eii_mangle_extern, span)),
+                args: ast::AttrArgs::Empty,
+                tokens: None,
+            },
+            tokens: None,
+        })),
+        id: ecx.sess.psess.attr_id_generator.mk_attr_id(),
+        style: ast::AttrStyle::Outer,
+        span,
+    });
     let extern_block = Annotatable::Item(P(ast::Item {
         attrs: ast::AttrVec::default(),
         id: ast::DUMMY_NODE_ID,
@@ -264,6 +279,7 @@ fn eii_(
             eii_macro_for: Some(ast::EIIMacroFor {
                 extern_item_path: ast::Path::from_ident(item_name),
                 impl_unsafe,
+                span: decl_span,
             }),
         }),
         tokens: None,
@@ -322,7 +338,7 @@ pub(crate) fn eii_macro_for(
         false
     };
 
-    d.eii_macro_for = Some(EIIMacroFor { extern_item_path, impl_unsafe });
+    d.eii_macro_for = Some(EIIMacroFor { extern_item_path, impl_unsafe, span });
 
     // Return the original item and the new methods.
     vec![item]

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1981,6 +1981,7 @@ fn add_post_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor
 /// used in any sections, so the linker will therefore pick relevant rlibs for linking, but
 /// unused `#[no_mangle]` or `#[used]` can still be discard by GC sections.
 ///
+// TODO: does EII solves this?
 /// There's a few internal crates in the standard library (aka libcore and
 /// libstd) which actually have a circular dependence upon one another. This
 /// currently arises through "weak lang items" where libcore requires things