Rollup of 5 pull requests

compiler/rustc_ast/src/ast.rs

@@ -2109,16 +2109,18 @@ pub struct MacroDef {
     /// `true` if macro was defined with `macro_rules`.
     pub macro_rules: bool,
 
-    /// If this is a macro used for externally implementable items,
-    /// it refers to an extern item which is its "target". This requires
-    /// name resolution so can't just be an attribute, so we store it in this field.
-    pub eii_extern_target: Option<EiiExternTarget>,
+    /// Corresponds to `#[eii_declaration(...)]`.
+    /// `#[eii_declaration(...)]` is a built-in attribute macro, not a built-in attribute,
+    /// because we require some name resolution to occur in the parameters of this attribute.
+    /// Name resolution isn't possible in attributes otherwise, so we encode it in the AST.
+    /// During ast lowering, we turn it back into an attribute again
+    pub eii_declaration: Option<EiiDecl>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
-pub struct EiiExternTarget {
+pub struct EiiDecl {
     /// path to the extern item we're targeting
-    pub extern_item_path: Path,
+    pub foreign_item: Path,
     pub impl_unsafe: bool,
 }
 
@@ -3824,7 +3826,7 @@ pub struct EiiImpl {
     ///
     /// This field is that shortcut: we prefill the extern target to skip a name resolution step,
     /// making sure it never fails. It'd be awful UX if we fail name resolution in code invisible to the user.
-    pub known_eii_macro_resolution: Option<EiiExternTarget>,
+    pub known_eii_macro_resolution: Option<EiiDecl>,
     pub impl_safety: Safety,
     pub span: Span,
     pub inner_span: Span,

compiler/rustc_ast/src/visit.rs

@@ -489,7 +489,7 @@ macro_rules! common_visitor_and_walkers {
             WhereEqPredicate,
             WhereRegionPredicate,
             YieldKind,
-            EiiExternTarget,
+            EiiDecl,
             EiiImpl,
         );
 

compiler/rustc_ast_lowering/src/item.rs

@@ -2,7 +2,7 @@ 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, EiiDecl, EiiImplResolution};
+use rustc_hir::attrs::{AttributeKind, EiiImplResolution};
 use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
 use rustc_hir::{
@@ -134,16 +134,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_eii_extern_target(
+    fn lower_eii_decl(
         &mut self,
         id: NodeId,
-        eii_name: Ident,
-        EiiExternTarget { extern_item_path, impl_unsafe }: &EiiExternTarget,
-    ) -> Option<EiiDecl> {
-        self.lower_path_simple_eii(id, extern_item_path).map(|did| EiiDecl {
-            eii_extern_target: did,
+        name: Ident,
+        EiiDecl { foreign_item, impl_unsafe }: &EiiDecl,
+    ) -> Option<hir::attrs::EiiDecl> {
+        self.lower_path_simple_eii(id, foreign_item).map(|did| hir::attrs::EiiDecl {
+            foreign_item: did,
             impl_unsafe: *impl_unsafe,
-            name: eii_name,
+            name,
         })
     }
 
@@ -160,7 +160,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }: &EiiImpl,
     ) -> hir::attrs::EiiImpl {
         let resolution = if let Some(target) = known_eii_macro_resolution
-            && let Some(decl) = self.lower_eii_extern_target(
+            && let Some(decl) = self.lower_eii_decl(
                 *node_id,
                 // the expect is ok here since we always generate this path in the eii macro.
                 eii_macro_path.segments.last().expect("at least one segment").ident,
@@ -196,9 +196,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     eii_impls.iter().map(|i| self.lower_eii_impl(i)).collect(),
                 ))]
             }
-            ItemKind::MacroDef(name, MacroDef { eii_extern_target: Some(target), .. }) => self
-                .lower_eii_extern_target(id, *name, target)
-                .map(|decl| vec![hir::Attribute::Parsed(AttributeKind::EiiExternTarget(decl))])
+            ItemKind::MacroDef(name, MacroDef { eii_declaration: Some(target), .. }) => self
+                .lower_eii_decl(id, *name, target)
+                .map(|decl| vec![hir::Attribute::Parsed(AttributeKind::EiiDeclaration(decl))])
                 .unwrap_or_default(),
 
             ItemKind::ExternCrate(..)
@@ -242,10 +242,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             vis_span,
             span: self.lower_span(i.span),
             has_delayed_lints: !self.delayed_lints.is_empty(),
-            eii: find_attr!(
-                attrs,
-                AttributeKind::EiiImpls(..) | AttributeKind::EiiExternTarget(..)
-            ),
+            eii: find_attr!(attrs, AttributeKind::EiiImpls(..) | AttributeKind::EiiDeclaration(..)),
         };
         self.arena.alloc(item)
     }
@@ -539,7 +536,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::ItemKind::TraitAlias(constness, ident, generics, bounds)
             }
-            ItemKind::MacroDef(ident, MacroDef { body, macro_rules, eii_extern_target: _ }) => {
+            ItemKind::MacroDef(ident, MacroDef { body, macro_rules, eii_declaration: _ }) => {
                 let ident = self.lower_ident(*ident);
                 let body = Box::new(self.lower_delim_args(body));
                 let def_id = self.local_def_id(id);
@@ -553,7 +550,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let macro_def = self.arena.alloc(ast::MacroDef {
                     body,
                     macro_rules: *macro_rules,
-                    eii_extern_target: None,
+                    eii_declaration: None,
                 });
                 hir::ItemKind::Macro(ident, macro_def, macro_kinds)
             }
@@ -693,7 +690,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             has_delayed_lints: !this.delayed_lints.is_empty(),
                             eii: find_attr!(
                                 attrs,
-                                AttributeKind::EiiImpls(..) | AttributeKind::EiiExternTarget(..)
+                                AttributeKind::EiiImpls(..) | AttributeKind::EiiDeclaration(..)
                             ),
                         };
                         hir::OwnerNode::Item(this.arena.alloc(item))

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -865,10 +865,10 @@ 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_extern_target) = &macro_def.eii_extern_target {
-            self.word("#[eii_extern_target(");
-            self.print_path(&eii_extern_target.extern_item_path, false, 0);
-            if eii_extern_target.impl_unsafe {
+        if let Some(eii_decl) = &macro_def.eii_declaration {
+            self.word("#[eii_declaration(");
+            self.print_path(&eii_decl.foreign_item, false, 0);
+            if eii_decl.impl_unsafe {
                 self.word(",");
                 self.space();
                 self.word("unsafe");

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -709,11 +709,11 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcPassIndirectlyInNonRusticAbisPa
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcPassIndirectlyInNonRusticAbis;
 }
 
-pub(crate) struct EiiExternItemParser;
+pub(crate) struct EiiForeignItemParser;
 
-impl<S: Stage> NoArgsAttributeParser<S> for EiiExternItemParser {
-    const PATH: &[Symbol] = &[sym::rustc_eii_extern_item];
+impl<S: Stage> NoArgsAttributeParser<S> for EiiForeignItemParser {
+    const PATH: &[Symbol] = &[sym::rustc_eii_foreign_item];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::ForeignFn)]);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::EiiExternItem;
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::EiiForeignItem;
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -21,7 +21,7 @@ use crate::attributes::allow_unstable::{
 use crate::attributes::body::CoroutineParser;
 use crate::attributes::cfi_encoding::CfiEncodingParser;
 use crate::attributes::codegen_attrs::{
-    ColdParser, CoverageParser, EiiExternItemParser, ExportNameParser, ForceTargetFeatureParser,
+    ColdParser, CoverageParser, EiiForeignItemParser, ExportNameParser, ForceTargetFeatureParser,
     NakedParser, NoMangleParser, ObjcClassParser, ObjcSelectorParser, OptimizeParser,
     RustcPassIndirectlyInNonRusticAbisParser, SanitizeParser, TargetFeatureParser,
     ThreadLocalParser, TrackCallerParser, UsedParser,
@@ -243,7 +243,7 @@ attribute_parsers!(
         Single<WithoutArgs<CoroutineParser>>,
         Single<WithoutArgs<DenyExplicitImplParser>>,
         Single<WithoutArgs<DoNotImplementViaObjectParser>>,
-        Single<WithoutArgs<EiiExternItemParser>>,
+        Single<WithoutArgs<EiiForeignItemParser>>,
         Single<WithoutArgs<ExportStableParser>>,
         Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<FfiPureParser>>,

compiler/rustc_builtin_macros/messages.ftl

@@ -151,9 +151,9 @@ builtin_macros_derive_path_args_value = traits in `#[derive(...)]` don't accept
 
 builtin_macros_duplicate_macro_attribute = duplicated attribute
 
-builtin_macros_eii_extern_target_expected_list = `#[eii_extern_target(...)]` expects a list of one or two elements
-builtin_macros_eii_extern_target_expected_macro = `#[eii_extern_target(...)]` is only valid on macros
-builtin_macros_eii_extern_target_expected_unsafe = expected this argument to be "unsafe"
+builtin_macros_eii_declaration_expected_list = `#[eii_declaration(...)]` expects a list of one or two elements
+builtin_macros_eii_declaration_expected_macro = `#[eii_declaration(...)]` is only valid on macros
+builtin_macros_eii_declaration_expected_unsafe = expected this argument to be "unsafe"
     .note = the second argument is optional
 
 builtin_macros_eii_only_once = `#[{$name}]` can only be specified once

compiler/rustc_builtin_macros/src/eii.rs

@@ -1,7 +1,7 @@
 use rustc_ast::token::{Delimiter, TokenKind};
 use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
 use rustc_ast::{
-    Attribute, DUMMY_NODE_ID, EiiExternTarget, EiiImpl, ItemKind, MetaItem, Path, Stmt, StmtKind,
+    Attribute, DUMMY_NODE_ID, EiiDecl, EiiImpl, ItemKind, MetaItem, Path, Stmt, StmtKind,
     Visibility, ast,
 };
 use rustc_ast_pretty::pprust::path_to_string;
@@ -30,7 +30,7 @@ use crate::errors::{
 /// }
 ///
 /// #[rustc_builtin_macro(eii_shared_macro)]
-/// #[eii_extern_target(panic_handler)]
+/// #[eii_declaration(panic_handler)]
 /// macro panic_handler() {}
 /// ```
 pub(crate) fn eii(
@@ -210,8 +210,8 @@ fn generate_default_impl(
         },
         span: eii_attr_span,
         is_default: true,
-        known_eii_macro_resolution: Some(ast::EiiExternTarget {
-            extern_item_path: ecx.path(
+        known_eii_macro_resolution: Some(ast::EiiDecl {
+            foreign_item: ecx.path(
                 foreign_item_name.span,
                 // prefix super to escape the `dflt` module generated below
                 vec![Ident::from_str_and_span("super", foreign_item_name.span), foreign_item_name],
@@ -295,9 +295,9 @@ fn generate_foreign_item(
     let mut foreign_item_attrs = ThinVec::new();
     foreign_item_attrs.extend_from_slice(attrs_from_decl);
 
-    // Add the rustc_eii_extern_item on the foreign item. Usually, foreign items are mangled.
+    // Add the rustc_eii_foreign_item on the foreign item. Usually, foreign items are mangled.
     // This attribute makes sure that we later know that this foreign item's symbol should not be.
-    foreign_item_attrs.push(ecx.attr_word(sym::rustc_eii_extern_item, eii_attr_span));
+    foreign_item_attrs.push(ecx.attr_word(sym::rustc_eii_foreign_item, eii_attr_span));
 
     let abi = match func.sig.header.ext {
         // extern "X" fn  =>  extern "X" {}
@@ -349,7 +349,7 @@ fn generate_foreign_item(
 /// // This attribute tells the compiler that
 /// #[builtin_macro(eii_shared_macro)]
 /// // the metadata to link this macro to the generated foreign item.
-/// #[eii_extern_target(<related_reign_item>)]
+/// #[eii_declaration(<related_foreign_item>)]
 /// macro macro_name { () => {} }
 /// ```
 fn generate_attribute_macro_to_implement(
@@ -401,9 +401,9 @@ fn generate_attribute_macro_to_implement(
                     ]),
                 }),
                 macro_rules: false,
-                // #[eii_extern_target(foreign_item_ident)]
-                eii_extern_target: Some(ast::EiiExternTarget {
-                    extern_item_path: ast::Path::from_ident(foreign_item_name),
+                // #[eii_declaration(foreign_item_ident)]
+                eii_declaration: Some(ast::EiiDecl {
+                    foreign_item: ast::Path::from_ident(foreign_item_name),
                     impl_unsafe,
                 }),
             },
@@ -412,7 +412,7 @@ fn generate_attribute_macro_to_implement(
     })
 }
 
-pub(crate) fn eii_extern_target(
+pub(crate) fn eii_declaration(
     ecx: &mut ExtCtxt<'_>,
     span: Span,
     meta_item: &ast::MetaItem,
@@ -461,7 +461,7 @@ pub(crate) fn eii_extern_target(
         false
     };
 
-    d.eii_extern_target = Some(EiiExternTarget { extern_item_path, impl_unsafe });
+    d.eii_declaration = Some(EiiDecl { foreign_item: extern_item_path, impl_unsafe });
 
     // Return the original item and the new methods.
     vec![item]

compiler/rustc_builtin_macros/src/errors.rs

@@ -1010,21 +1010,21 @@ pub(crate) struct CfgSelectUnreachable {
 }
 
 #[derive(Diagnostic)]
-#[diag(builtin_macros_eii_extern_target_expected_macro)]
+#[diag(builtin_macros_eii_declaration_expected_macro)]
 pub(crate) struct EiiExternTargetExpectedMacro {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(builtin_macros_eii_extern_target_expected_list)]
+#[diag(builtin_macros_eii_declaration_expected_list)]
 pub(crate) struct EiiExternTargetExpectedList {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(builtin_macros_eii_extern_target_expected_unsafe)]
+#[diag(builtin_macros_eii_declaration_expected_unsafe)]
 pub(crate) struct EiiExternTargetExpectedUnsafe {
     #[primary_span]
     #[note]

compiler/rustc_builtin_macros/src/lib.rs

@@ -119,7 +119,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         derive: derive::Expander { is_const: false },
         derive_const: derive::Expander { is_const: true },
         eii: eii::eii,
-        eii_extern_target: eii::eii_extern_target,
+        eii_declaration: eii::eii_declaration,
         eii_shared_macro: eii::eii_shared_macro,
         global_allocator: global_allocator::expand,
         test: test::expand_test,

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -1520,7 +1520,6 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
     // Unwrap potential addrspacecast
     let vtable = find_vtable_behind_cast(vtable);
     let trait_ref_self = trait_ref.with_self_ty(cx.tcx, ty);
-    let trait_ref_self = cx.tcx.erase_and_anonymize_regions(trait_ref_self);
     let trait_def_id = trait_ref_self.def_id;
     let trait_vis = cx.tcx.visibility(trait_def_id);
 

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -282,16 +282,16 @@ fn process_builtin_attrs(
                 AttributeKind::ObjcSelector { methname, .. } => {
                     codegen_fn_attrs.objc_selector = Some(*methname);
                 }
-                AttributeKind::EiiExternItem => {
+                AttributeKind::EiiForeignItem => {
                     codegen_fn_attrs.flags |= CodegenFnAttrFlags::EXTERNALLY_IMPLEMENTABLE_ITEM;
                 }
                 AttributeKind::EiiImpls(impls) => {
                     for i in impls {
-                        let extern_item = match i.resolution {
+                        let foreign_item = match i.resolution {
                             EiiImplResolution::Macro(def_id) => {
                                 let Some(extern_item) = find_attr!(
                                     tcx.get_all_attrs(def_id),
-                                    AttributeKind::EiiExternTarget(target) => target.eii_extern_target
+                                    AttributeKind::EiiDeclaration(target) => target.foreign_item
                                 ) else {
                                     tcx.dcx().span_delayed_bug(
                                         i.span,
@@ -301,7 +301,7 @@ fn process_builtin_attrs(
                                 };
                                 extern_item
                             }
-                            EiiImplResolution::Known(decl) => decl.eii_extern_target,
+                            EiiImplResolution::Known(decl) => decl.foreign_item,
                             EiiImplResolution::Error(_eg) => continue,
                         };
 
@@ -316,13 +316,13 @@ fn process_builtin_attrs(
                             // iterate over all implementations *in the current crate*
                             // (this is ok since we generate codegen fn attrs in the local crate)
                             // if any of them is *not default* then don't emit the alias.
-                            && tcx.externally_implementable_items(LOCAL_CRATE).get(&extern_item).expect("at least one").1.iter().any(|(_, imp)| !imp.is_default)
+                            && tcx.externally_implementable_items(LOCAL_CRATE).get(&foreign_item).expect("at least one").1.iter().any(|(_, imp)| !imp.is_default)
                         {
                             continue;
                         }
 
                         codegen_fn_attrs.foreign_item_symbol_aliases.push((
-                            extern_item,
+                            foreign_item,
                             if i.is_default { Linkage::LinkOnceAny } else { Linkage::External },
                             Visibility::Default,
                         ));

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -13,7 +13,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{FloatTy, PolyExistentialPredicate, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{FloatTy, PolyExistentialPredicate, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug, ty};
 use rustc_span::{Symbol, sym};
 use rustc_trait_selection::traits::{Obligation, ObligationCause, ObligationCtxt};
@@ -243,13 +243,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 ocx.register_obligations(preds.iter().map(|pred: PolyExistentialPredicate<'_>| {
                     let pred = pred.with_self_ty(tcx, tp_ty);
                     // Lifetimes can only be 'static because of the bound on T
-                    let pred = pred.fold_with(&mut ty::BottomUpFolder {
-                        tcx,
-                        ty_op: |ty| ty,
-                        lt_op: |lt| {
-                            if lt == tcx.lifetimes.re_erased { tcx.lifetimes.re_static } else { lt }
-                        },
-                        ct_op: |ct| ct,
+                    let pred = ty::fold_regions(tcx, pred, |r, _| {
+                        if r == tcx.lifetimes.re_erased { tcx.lifetimes.re_static } else { r }
                     });
                     Obligation::new(tcx, ObligationCause::dummy(), param_env, pred)
                 }));