Update.

Author: m-ou-se

compiler/rustc_ast_lowering/src/item.rs

@@ -155,30 +155,34 @@ impl<'hir> LoweringContext<'_, 'hir> {
         i: &ItemKind,
     ) -> Vec<hir::Attribute> {
         match i {
+            ItemKind::Fn(box Fn { eii_impl, .. }) if eii_impl.is_empty() => Vec::new(),
             ItemKind::Fn(box Fn { eii_impl, .. }) => {
-                let mut eii_impls = ThinVec::new();
-                for EIIImpl {
-                    node_id,
-                    eii_macro_path,
-                    impl_safety,
-                    span,
-                    inner_span,
-                    is_default,
-                } in eii_impl
-                {
-                    let did = self.lower_path_simple_eii(*node_id, eii_macro_path);
-                    eii_impls.push(rustc_attr_parsing::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,
-                    })
-                }
-
-                vec![hir::Attribute::Parsed(AttributeKind::EiiImpl(eii_impls))]
+                vec![hir::Attribute::Parsed(AttributeKind::EiiImpl(
+                    eii_impl
+                        .iter()
+                        .map(
+                            |EIIImpl {
+                                 node_id,
+                                 eii_macro_path,
+                                 impl_safety,
+                                 span,
+                                 inner_span,
+                                 is_default,
+                             }| {
+                                let did = self.lower_path_simple_eii(*node_id, eii_macro_path);
+                                rustc_attr_parsing::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_macro_for: Some(EIIMacroFor { extern_item_path, impl_unsafe }),
@@ -551,14 +555,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(ident, ast_macro_def, macro_kind)
+                hir::ItemKind::Macro(ident, macro_def, macro_kind)
             }
             ItemKind::Delegation(box delegation) => {
                 debug_assert_ne!(ident.name, kw::Empty);

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -788,6 +788,17 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
         sp: Span,
         print_visibility: impl FnOnce(&mut Self),
     ) {
+        if let Some(eii_macro_for) = &macro_def.eii_macro_for {
+            self.word("#[eii_macro_for(");
+            self.print_path(&eii_macro_for.extern_item_path, false, 0);
+            if eii_macro_for.impl_unsafe {
+                self.word(",");
+                self.space();
+                self.word("unsafe");
+            }
+            self.word(")]");
+            self.hardbreak();
+        }
         let (kw, has_bang) = if macro_def.macro_rules {
             ("macro_rules", true)
         } else {

compiler/rustc_builtin_macros/src/eii.rs

@@ -1,10 +1,209 @@
-use rustc_ast::{
-    DUMMY_NODE_ID, DUMMY_NODE_ID, EIIImpl, EIIImpl, EIIMacroFor, EiiMacroFor, ItemKind, ItemKind,
-    ast, ast,
-};
+use rustc_ast::ptr::P;
+use rustc_ast::token::{Delimiter, TokenKind};
+use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
+use rustc_ast::{DUMMY_NODE_ID, EIIImpl, EIIMacroFor, ItemKind, ast, token, tokenstream};
 use rustc_ast_pretty::pprust::path_to_string;
 use rustc_expand::base::{Annotatable, ExtCtxt};
-use rustc_span::{Span, Span, kw, kw};
+use rustc_span::{Ident, Span, kw, sym};
+
+/* ```rust
+
+#[eii]
+fn panic_handler();
+
+#[eii(panic_handler)]
+fn panic_handler();
+
+#[eii(panic_handler, unsafe)]
+fn panic_handler();
+
+// expansion:
+
+extern "Rust" {
+    fn panic_handler();
+}
+
+#[rustc_builtin_macro(eii_macro)] // eii_macro_for: panic_handler
+macro panic_handler() {}
+
+``` */
+pub(crate) fn eii(
+    ecx: &mut ExtCtxt<'_>,
+    span: Span,
+    meta_item: &ast::MetaItem,
+    item: Annotatable,
+) -> Vec<Annotatable> {
+    let span = ecx.with_def_site_ctxt(span);
+
+    let Annotatable::Item(item) = item else {
+        ecx.dcx()
+            .emit_err(EIIMacroExpectedFunction { span, name: path_to_string(&meta_item.path) });
+        return vec![item];
+    };
+
+    let macro_name = if meta_item.is_word() {
+        item.ident
+    } else if let Some([first]) = meta_item.meta_item_list()
+        && let Some(m) = first.meta_item()
+        && m.path.segments.len() == 1
+    {
+        m.path.segments[0].ident
+    } else {
+        ecx.dcx().emit_err(EIIMacroExpectedMaxOneArgument {
+            span: meta_item.span,
+            name: path_to_string(&meta_item.path),
+        });
+        return vec![Annotatable::Item(item)];
+    };
+
+    let item = item.into_inner();
+
+    let ast::Item {
+        attrs,
+        id: _,
+        span: item_span,
+        vis,
+        ident: item_name,
+        kind: ItemKind::Fn(mut func),
+        tokens: _,
+    } = item
+    else {
+        ecx.dcx()
+            .emit_err(EIIMacroExpectedFunction { span, name: path_to_string(&meta_item.path) });
+        return vec![Annotatable::Item(P(item))];
+    };
+
+    let impl_unsafe = false; // TODO
+
+    let abi = match func.sig.header.ext {
+        // extern "X" fn  =>  extern "X" {}
+        ast::Extern::Explicit(lit, _) => Some(lit),
+        // extern fn  =>  extern {}
+        ast::Extern::Implicit(_) => None,
+        // fn  =>  extern "Rust" {}
+        ast::Extern::None => Some(ast::StrLit {
+            symbol: sym::Rust,
+            suffix: None,
+            symbol_unescaped: sym::Rust,
+            style: ast::StrStyle::Cooked,
+            span,
+        }),
+    };
+
+    // ABI has been moved to the extern {} block, so we remove it from the fn item.
+    func.sig.header.ext = ast::Extern::None;
+
+    // And mark safe functions explicitly as `safe fn`.
+    if func.sig.header.safety == ast::Safety::Default {
+        func.sig.header.safety = ast::Safety::Safe(func.sig.span);
+    }
+
+    // extern "…" { safe fn item(); }
+    let extern_block = Annotatable::Item(P(ast::Item {
+        attrs: ast::AttrVec::default(),
+        id: ast::DUMMY_NODE_ID,
+        span,
+        vis: ast::Visibility { span, kind: ast::VisibilityKind::Inherited, tokens: None },
+        ident: Ident::dummy(),
+        kind: ast::ItemKind::ForeignMod(ast::ForeignMod {
+            extern_span: span,
+            safety: ast::Safety::Unsafe(span),
+            abi,
+            items: From::from([P(ast::ForeignItem {
+                attrs,
+                id: ast::DUMMY_NODE_ID,
+                span: item_span,
+                vis,
+                ident: item_name,
+                kind: ast::ForeignItemKind::Fn(func),
+                tokens: None,
+            })]),
+        }),
+        tokens: None,
+    }));
+
+    let macro_def = Annotatable::Item(P(ast::Item {
+        attrs: ast::AttrVec::from_iter([
+            // #[eii_macro_for(item_name)]
+            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_macro_for, span)),
+                        args: ast::AttrArgs::Delimited(ast::DelimArgs {
+                            dspan: DelimSpan::from_single(span),
+                            delim: Delimiter::Parenthesis,
+                            tokens: TokenStream::new(vec![tokenstream::TokenTree::Token(
+                                token::Token::from_ast_ident(item_name),
+                                Spacing::Alone,
+                            )]),
+                        }),
+                        tokens: None,
+                    },
+                    tokens: None,
+                })),
+                id: ecx.sess.psess.attr_id_generator.mk_attr_id(),
+                style: ast::AttrStyle::Outer,
+                span,
+            },
+            // #[builtin_macro(eii_macro)]
+            ast::Attribute {
+                kind: ast::AttrKind::Normal(P(ast::NormalAttr {
+                    item: ast::AttrItem {
+                        unsafety: ast::Safety::Default,
+                        path: ast::Path::from_ident(Ident::new(sym::rustc_builtin_macro, span)),
+                        args: ast::AttrArgs::Delimited(ast::DelimArgs {
+                            dspan: DelimSpan::from_single(span),
+                            delim: Delimiter::Parenthesis,
+                            tokens: TokenStream::new(vec![tokenstream::TokenTree::token_alone(
+                                token::TokenKind::Ident(sym::eii_macro, token::IdentIsRaw::No),
+                                span,
+                            )]),
+                        }),
+                        tokens: None,
+                    },
+                    tokens: None,
+                })),
+                id: ecx.sess.psess.attr_id_generator.mk_attr_id(),
+                style: ast::AttrStyle::Outer,
+                span,
+            },
+        ]),
+        id: ast::DUMMY_NODE_ID,
+        span,
+        // pub
+        vis: ast::Visibility { span, kind: ast::VisibilityKind::Public, tokens: None },
+        // macro macro_name
+        ident: macro_name,
+        kind: ast::ItemKind::MacroDef(ast::MacroDef {
+            // { () => {} }
+            body: P(ast::DelimArgs {
+                dspan: DelimSpan::from_single(span),
+                delim: Delimiter::Brace,
+                tokens: TokenStream::from_iter([
+                    TokenTree::Delimited(
+                        DelimSpan::from_single(span),
+                        DelimSpacing::new(Spacing::Alone, Spacing::Alone),
+                        Delimiter::Parenthesis,
+                        TokenStream::default(),
+                    ),
+                    TokenTree::token_alone(TokenKind::FatArrow, span),
+                    TokenTree::Delimited(
+                        DelimSpan::from_single(span),
+                        DelimSpacing::new(Spacing::Alone, Spacing::Alone),
+                        Delimiter::Brace,
+                        TokenStream::default(),
+                    ),
+                ]),
+            }),
+            macro_rules: false,
+            eii_macro_for: None,
+        }),
+        tokens: None,
+    }));
+
+    vec![extern_block, macro_def]
+}
 
 use crate::errors::{
     EIIMacroExpectedFunction, EIIMacroExpectedMaxOneArgument, EIIMacroForExpectedList,

compiler/rustc_builtin_macros/src/lib.rs

@@ -124,6 +124,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         global_allocator: global_allocator::expand,
         test: test::expand_test,
         test_case: test::expand_test_case,
+        eii: eii::eii,
         eii_macro_for: eii::eii_macro_for,
         eii_macro: eii::eii_macro,
     }

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -111,12 +111,22 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
 
         if let hir::Attribute::Parsed(p) = attr {
             match p {
+                /*
+                AttributeKind::EiiImpl(eii_macro) => {
+                    let Some(eii_extern_item) = find_attr!(
+                        tcx.get_all_attrs(eii_macro),
+                        AttributeKind::EiiMacroFor { eii_extern_item, .. } => *eii_extern_item
+                    ) else {
+                        tcx.dcx().span_delayed_bug(attr.span(), "missing attr on EII macro");
+                        continue;
+                    };
+                    let _ = eii_extern_item; // XXX mangle as this item or something.
+                }*/
                 AttributeKind::Repr(reprs) => {
                     codegen_fn_attrs.alignment = reprs
                         .iter()
                         .find_map(|(r, _)| if let ReprAlign(x) = r { Some(*x) } else { None });
                 }
-
                 _ => {}
             }
         }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1041,21 +1041,6 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         "#[rustc_force_inline] forces a free function to be inlined"
     ),
 
-    gated!(
-        eii, Normal, template!(Word),
-        ErrorPreceding, EncodeCrossCrate::No,
-        eii_internals, "internally used to implement EII"
-    ),
-    gated!(
-        eii_impl, Normal, template!(List: "/*opt*/ default"),
-        ErrorPreceding, EncodeCrossCrate::No,
-        eii_internals, "internally used to implement EII"
-    ),
-    gated!(
-        eii_macro_for, Normal, template!(List: "path"),
-        ErrorPreceding, EncodeCrossCrate::No,
-        eii_internals, "internally used to implement EII"
-    ),
     // ==========================================================================
     // Internal attributes, Testing:
     // ==========================================================================

compiler/rustc_hir_analysis/src/check/compare_eii.rs

@@ -2,20 +2,15 @@ use std::borrow::Cow;
 use std::iter;
 
 use rustc_data_structures::fx::FxIndexSet;
-use rustc_errors::{
-    Applicability, E0050, E0053, E0053, E0053, struct_span_code_err, struct_span_code_err,
-    struct_span_code_err,
-};
+use rustc_errors::{Applicability, E0050, E0053, struct_span_code_err};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::{
-    self as hir, self as hir, self as hir, FnSig, HirId, HirId, HirId, ItemKind, ItemKind, ItemKind,
-};
+use rustc_hir::{self as hir, FnSig, HirId, ItemKind};
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty;
 use rustc_middle::ty::TyCtxt;
-use rustc_middle::ty::error::{ExpectedFound, TypeError, TypeError, TypeError};
-use rustc_span::{ErrorGuaranteed, Ident, Span};
+use rustc_middle::ty::error::{ExpectedFound, TypeError};
+use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::regions::InferCtxtRegionExt;
 use rustc_trait_selection::traits::ObligationCtxt;

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -40,7 +40,7 @@ use rustc_trait_selection::traits::{
 use tracing::{debug, instrument};
 use {rustc_ast as ast, rustc_hir as hir};
 
-use super::compare_eii::{compare_eii_function_types, compare_eii_predicate_entailment};
+use super::compare_eii::compare_eii_function_types;
 use crate::autoderef::Autoderef;
 use crate::collect::CollectItemTypesVisitor;
 use crate::constrained_generic_params::{Parameter, identify_constrained_generic_params};