Auto merge of #158266 - JonathanBrouwer:rollup-zVReYNF, r=JonathanBrouwer

Rollup of 7 pull requests

Successful merges:

 - #157983 (Lift the same-signature restriction for `extern "tail"`)
 - #158242 (Fix linking for wasm with crate metadata included)
 - #158119 (Refactor `proc_macro_decls_static`)
 - #158172 (update `asm_experimental_reg` comments)
 - #158230 (Include `Item::stability` info in rustdoc JSON.)
 - #158258 (Use an unexpanded span for actually written down opt out params)
 - #158262 (Change compiler leads in triagebot.toml)

Author: bors

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -1817,7 +1817,13 @@ pub(crate) fn exported_symbols(
         exported_symbols_for_non_proc_macro(tcx, crate_type)
     };
 
-    if crate_type == CrateType::Dylib || crate_type == CrateType::ProcMacro {
+    // Preserve the metadata symbol to ensure the metadata section doesn't get removed by the
+    // linker. On wasm however the metadata is put in a custom section, to which symbols can't
+    // refer, so there is no metadata symbol there. Luckily custom sections are always preserved by
+    // the linker.
+    if (crate_type == CrateType::Dylib || crate_type == CrateType::ProcMacro)
+        && !tcx.sess.target.is_like_wasm
+    {
         let metadata_symbol_name = exported_symbols::metadata_symbol_name(tcx);
         symbols.push((metadata_symbol_name, SymbolExportKind::Data));
     }

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1317,7 +1317,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     }
                     LocalRef::Operand(arg) => {
                         let Ref(place_value) = arg.val else {
-                            bug!("only `Ref` should use `PassMode::Indirect`");
+                            bug!(
+                                "only `Ref` should use `PassMode::Indirect`, but got {:?}",
+                                arg.val
+                            );
                         };
                         bx.typed_place_copy(place_value, tmp.val, fn_abi.args[i].layout);
                         op.val = arg.val;

compiler/rustc_hir/src/hir.rs

@@ -4570,6 +4570,7 @@ impl<'hir> Item<'hir> {
         HirId::make_owner(self.owner_id.def_id)
     }
 
+    #[inline]
     pub fn item_id(&self) -> ItemId {
         ItemId { owner_id: self.owner_id }
     }

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -25,17 +25,17 @@ use crate::hir_ty_lowering::{
 #[derive(Debug, Default)]
 struct CollectedBound {
     /// `Trait`
-    positive: bool,
+    positive: Option<Span>,
     /// `?Trait`
-    maybe: bool,
+    maybe: Option<Span>,
     /// `!Trait`
-    negative: bool,
+    negative: Option<Span>,
 }
 
 impl CollectedBound {
     /// Returns `true` if any of `Trait`, `?Trait` or `!Trait` were encountered.
     fn any(&self) -> bool {
-        self.positive || self.maybe || self.negative
+        self.positive.is_some() || self.maybe.is_some() || self.negative.is_some()
     }
 }
 
@@ -96,9 +96,9 @@ fn collect_bounds<'a, 'tcx>(
         }
 
         match ptr.modifiers.polarity {
-            hir::BoundPolarity::Maybe(_) => collect_into.maybe = true,
-            hir::BoundPolarity::Negative(_) => collect_into.negative = true,
-            hir::BoundPolarity::Positive => collect_into.positive = true,
+            hir::BoundPolarity::Maybe(_) => collect_into.maybe = Some(ptr.span),
+            hir::BoundPolarity::Negative(_) => collect_into.negative = Some(ptr.span),
+            hir::BoundPolarity::Positive => collect_into.positive = Some(ptr.span),
         }
     });
     collect_into
@@ -180,10 +180,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             ImpliedBoundsContext::TyParam(..) | ImpliedBoundsContext::AssociatedTypeOrImplTrait => {
             }
         }
-
         let collected = collect_sizedness_bounds(tcx, hir_bounds, context, span);
-        if (collected.sized.maybe || collected.sized.negative)
-            && !collected.sized.positive
+        if let Some(span) = collected.sized.maybe.or(collected.sized.negative)
+            && collected.sized.positive.is_none()
             && !collected.meta_sized.any()
             && !collected.pointee_sized.any()
         {

compiler/rustc_hir_typeck/src/check.rs

@@ -90,7 +90,7 @@ pub(super) fn check_fn<'a, 'tcx>(
         }
 
         // Check that argument is Sized.
-        if !params_can_be_unsized {
+        if !params_can_be_unsized || fn_sig.abi() == rustc_abi::ExternAbi::RustTail {
             fcx.require_type_is_sized(
                 param_ty,
                 param.ty_span,

compiler/rustc_interface/src/lib.rs

@@ -10,7 +10,6 @@ pub mod diagnostics;
 pub mod interface;
 mod limits;
 pub mod passes;
-mod proc_macro_decls;
 mod queries;
 pub mod util;
 

compiler/rustc_interface/src/passes.rs

@@ -49,7 +49,7 @@ use rustc_trait_selection::{solve, traits};
 use tracing::{info, instrument};
 
 use crate::interface::Compiler;
-use crate::{diagnostics, limits, proc_macro_decls, util};
+use crate::{diagnostics, limits, util};
 
 pub fn parse<'a>(sess: &'a Session) -> ast::Crate {
     let mut krate = sess
@@ -897,9 +897,9 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     providers.queries.resolutions = |tcx, ()| tcx.resolver_for_lowering_raw(()).2;
     providers.queries.early_lint_checks = early_lint_checks;
     providers.queries.env_var_os = env_var_os;
+    providers.queries.proc_macro_decls_static = |tcx, _| tcx.hir_crate_items(()).proc_macro_decls();
     rustc_ast_lowering::provide(&mut providers.queries);
     limits::provide(&mut providers.queries);
-    proc_macro_decls::provide(&mut providers.queries);
     rustc_expand::provide(&mut providers.queries);
     rustc_const_eval::provide(providers);
     rustc_middle::hir::provide(&mut providers.queries);

compiler/rustc_interface/src/proc_macro_decls.rs

@@ -1275,8 +1275,10 @@ pub(super) fn hir_module_items(tcx: TyCtxt<'_>, module_id: LocalModDefId) -> Mod
         opaques,
         nested_bodies,
         eiis,
+        proc_macro_decls,
         ..
     } = collector;
+
     ModuleItems {
         add_root: false,
         submodules: submodules.into_boxed_slice(),
@@ -1288,6 +1290,7 @@ pub(super) fn hir_module_items(tcx: TyCtxt<'_>, module_id: LocalModDefId) -> Mod
         opaques: opaques.into_boxed_slice(),
         nested_bodies: nested_bodies.into_boxed_slice(),
         eiis: eiis.into_boxed_slice(),
+        proc_macro_decls,
     }
 }
 
@@ -1310,6 +1313,7 @@ pub(crate) fn hir_crate_items(tcx: TyCtxt<'_>, _: ()) -> ModuleItems {
         opaques,
         nested_bodies,
         eiis,
+        proc_macro_decls,
         ..
     } = collector;
 
@@ -1324,40 +1328,32 @@ pub(crate) fn hir_crate_items(tcx: TyCtxt<'_>, _: ()) -> ModuleItems {
         opaques: opaques.into_boxed_slice(),
         nested_bodies: nested_bodies.into_boxed_slice(),
         eiis: eiis.into_boxed_slice(),
+        proc_macro_decls,
     }
 }
 
 struct ItemCollector<'tcx> {
     // When true, it collects all items in the create,
     // otherwise it collects items in some module.
+    // Converting this to generic const didn't lead to significant perf improvements
+    // (see <https://github.com/rust-lang/rust/pull/158119#issuecomment-4751513679>).
     crate_collector: bool,
     tcx: TyCtxt<'tcx>,
-    submodules: Vec<OwnerId>,
-    items: Vec<ItemId>,
-    trait_items: Vec<TraitItemId>,
-    impl_items: Vec<ImplItemId>,
-    foreign_items: Vec<ForeignItemId>,
-    body_owners: Vec<LocalDefId>,
-    opaques: Vec<LocalDefId>,
-    nested_bodies: Vec<LocalDefId>,
-    eiis: Vec<LocalDefId>,
+    submodules: Vec<OwnerId> = vec![],
+    items: Vec<ItemId> = vec![],
+    trait_items: Vec<TraitItemId> = vec![],
+    impl_items: Vec<ImplItemId> = vec![],
+    foreign_items: Vec<ForeignItemId> = vec![],
+    body_owners: Vec<LocalDefId> = vec![],
+    opaques: Vec<LocalDefId> = vec![],
+    nested_bodies: Vec<LocalDefId> = vec![],
+    eiis: Vec<LocalDefId> = vec![],
+    proc_macro_decls: Option<LocalDefId> = None,
 }
 
 impl<'tcx> ItemCollector<'tcx> {
     fn new(tcx: TyCtxt<'tcx>, crate_collector: bool) -> ItemCollector<'tcx> {
-        ItemCollector {
-            crate_collector,
-            tcx,
-            submodules: Vec::default(),
-            items: Vec::default(),
-            trait_items: Vec::default(),
-            impl_items: Vec::default(),
-            foreign_items: Vec::default(),
-            body_owners: Vec::default(),
-            opaques: Vec::default(),
-            nested_bodies: Vec::default(),
-            eiis: Vec::default(),
-        }
+        ItemCollector { crate_collector, tcx, .. }
     }
 }
 
@@ -1373,7 +1369,16 @@ impl<'hir> Visitor<'hir> for ItemCollector<'hir> {
             self.body_owners.push(item.owner_id.def_id);
         }
 
-        self.items.push(item.item_id());
+        let item_id = item.item_id();
+
+        if self.crate_collector
+            && self.proc_macro_decls.is_none()
+            && find_attr!(self.tcx, item_id.hir_id(), RustcProcMacroDecls)
+        {
+            self.proc_macro_decls = Some(item_id.owner_id.def_id);
+        }
+
+        self.items.push(item_id);
 
         if let ItemKind::Static(..) | ItemKind::Fn { .. } | ItemKind::Macro(..) = &item.kind
             && item.eii

compiler/rustc_middle/src/hir/map.rs

@@ -39,6 +39,9 @@ pub struct ModuleItems {
 
     /// Statics and functions with an `EiiImpls` or `EiiExternTarget` attribute
     eiis: Box<[LocalDefId]>,
+
+    // only filled with hir_crate_items, not with hir_module_items
+    proc_macro_decls: Option<LocalDefId>,
 }
 
 impl ModuleItems {
@@ -56,6 +59,11 @@ impl ModuleItems {
         self.trait_items.iter().copied()
     }
 
+    #[inline]
+    pub fn proc_macro_decls(&self) -> Option<LocalDefId> {
+        self.proc_macro_decls
+    }
+
     pub fn eiis(&self) -> impl Iterator<Item = LocalDefId> {
         self.eiis.iter().copied()
     }