make linkage be external more often

Author: jdonszelmann

compiler/rustc_error_codes/src/error_codes/E0264.md

@@ -1,3 +1,5 @@
+#### this error code is no longer emitted by the compiler.
+
 An unknown external lang item was used.
 
 Erroneous code example:

compiler/rustc_hir/src/lang_items.rs

@@ -285,6 +285,10 @@ language_item_table! {
     PanicMisalignedPointerDereference, sym::panic_misaligned_pointer_dereference, panic_misaligned_pointer_dereference_fn, Target::Fn, GenericRequirement::Exact(0);
     PanicInfo,               sym::panic_info,          panic_info,                 Target::Struct,         GenericRequirement::None;
     PanicLocation,           sym::panic_location,      panic_location,             Target::Struct,         GenericRequirement::None;
+    /// Note: used to mark an extern item but now marks an externally implementable item. This means
+    /// that the PanicImpl used to be marked to be specially treated in the compiler, while it now
+    /// is only marked so we can check if it exists. There's no other reason for this lang item
+    /// anymore.
     PanicImpl,               sym::panic_impl,          panic_impl,                 Target::Fn,             GenericRequirement::None;
     PanicCannotUnwind,       sym::panic_cannot_unwind, panic_cannot_unwind,        Target::Fn,             GenericRequirement::Exact(0);
     PanicInCleanup,          sym::panic_in_cleanup,    panic_in_cleanup,           Target::Fn,             GenericRequirement::Exact(0);

compiler/rustc_middle/src/middle/eii.rs

@@ -7,6 +7,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 pub struct EiiMapping {
     pub extern_item: DefId,
     pub chosen_impl: DefId,
+    pub weak_linkage: bool,
 }
 
 pub type EiiMap = FxIndexMap<LocalDefId, EiiMapping>;

compiler/rustc_middle/src/mir/mono.rs

@@ -383,7 +383,7 @@ pub struct MonoItemData {
 /// Specifies the linkage type for a `MonoItem`.
 ///
 /// See <https://llvm.org/docs/LangRef.html#linkage-types> for more details about these variants.
-#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable)]
+#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable, Eq, Hash)]
 pub enum Linkage {
     External,
     AvailableExternally,

compiler/rustc_middle/src/mir/terminator.rs

@@ -225,6 +225,12 @@ impl<O> AssertKind<O> {
         }
     }
 
+    /// Generally do not use this and use `panic_function` instead.
+    /// Gives the lang item that is required to exist for this assertion
+    /// to be emitted. This sometimes causes the assertion not to be emitted
+    /// if a lang item isn't there.
+    pub fn required_lang_item(&self) {}
+
     /// Format the message arguments for the `assert(cond, msg..)` terminator in MIR printing.
     ///
     /// Needs to be kept in sync with the run-time behavior (which is defined by

compiler/rustc_middle/src/mir/visit.rs

@@ -354,7 +354,7 @@ macro_rules! make_mir_visitor {
                             receiver_by_ref: _,
                         }
                         | ty::InstanceKind::DropGlue(_def_id, None)
-                        | ty::InstanceKind::EiiShim { def_id: _def_id, extern_item: _, chosen_impl: _ } => {}
+                        | ty::InstanceKind::EiiShim { def_id: _def_id, extern_item: _, chosen_impl: _, weak_linkage: _ } => {}
 
                         ty::InstanceKind::FnPtrShim(_def_id, ty)
                         | ty::InstanceKind::DropGlue(_def_id, Some(ty))

compiler/rustc_middle/src/ty/instance.rs

@@ -187,7 +187,7 @@ pub enum InstanceKind<'tcx> {
     /// Generated by externally implementable items. This function adds indirection so we can choose
     /// in the final crate whether to call an explicit implementation or, if none are given, call the
     /// default.
-    EiiShim { def_id: DefId, extern_item: DefId, chosen_impl: DefId },
+    EiiShim { def_id: DefId, extern_item: DefId, chosen_impl: DefId, weak_linkage: bool },
 }
 
 impl<'tcx> Instance<'tcx> {
@@ -436,7 +436,10 @@ pub fn fmt_instance(
         }
         InstanceKind::AsyncDropGlue(_, ty) => write!(f, " - shim({ty})"),
         InstanceKind::AsyncDropGlueCtorShim(_, ty) => write!(f, " - shim(Some({ty}))"),
-        InstanceKind::EiiShim { def_id: _, extern_item, chosen_impl } => {
+        InstanceKind::EiiShim { def_id: _, extern_item, chosen_impl, weak_linkage: true } => {
+            write!(f, " - shim(eii: {extern_item:?} -> {chosen_impl:?} [weak]")
+        }
+        InstanceKind::EiiShim { def_id: _, extern_item, chosen_impl, weak_linkage: false } => {
             write!(f, " - shim(eii: {extern_item:?} -> {chosen_impl:?})")
         }
     }

compiler/rustc_mir_transform/src/shim.rs

@@ -114,7 +114,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
             receiver_by_ref,
         } => build_construct_coroutine_by_move_shim(tcx, coroutine_closure_def_id, receiver_by_ref),
 
-        e @ ty::InstanceKind::EiiShim { def_id: _, extern_item, chosen_impl } => {
+        e @ ty::InstanceKind::EiiShim { def_id: _, extern_item, chosen_impl, weak_linkage: _ } => {
             let source = MirSource::from_instance(e);
 
             // get the signature for the new function this shim is creating

compiler/rustc_monomorphize/src/collector.rs

@@ -1614,7 +1614,7 @@ impl<'v> RootCollector<'_, 'v> {
     /// For each externally implementable item, we should generate an alias MonoItem that
     /// determines what implementation is called. This could be a default implementation.
     fn push_extra_eii_roots(&mut self) {
-        for (shim_did, &EiiMapping { extern_item, chosen_impl, .. }) in
+        for (shim_did, &EiiMapping { extern_item, chosen_impl, weak_linkage, .. }) in
             self.tcx.get_externally_implementable_item_impls(())
         {
             self.output.push(create_fn_mono_item(
@@ -1624,6 +1624,7 @@ impl<'v> RootCollector<'_, 'v> {
                         def_id: (*shim_did).into(),
                         extern_item,
                         chosen_impl,
+                        weak_linkage,
                     },
                     args: ty::GenericArgs::empty(),
                 },

compiler/rustc_monomorphize/src/partitioning.rs

@@ -635,7 +635,12 @@ fn characteristic_def_id_of_mono_item<'tcx>(
                 ty::InstanceKind::Item(def) => def,
                 // EII shims have a characteristic defid.
                 // But it's not their own, its the one of the extern item it is implementing.
-                ty::InstanceKind::EiiShim { def_id: _, extern_item, chosen_impl: _ } => extern_item,
+                ty::InstanceKind::EiiShim {
+                    def_id: _,
+                    extern_item,
+                    chosen_impl: _,
+                    weak_linkage: _,
+                } => extern_item,
                 ty::InstanceKind::VTableShim(..)
                 | ty::InstanceKind::ReifyShim(..)
                 | ty::InstanceKind::FnPtrShim(..)
@@ -770,8 +775,10 @@ fn mono_item_linkage_and_visibility<'tcx>(
     // together anyway. LLVM ensures the last one is the one that's chosen
     // TODO: this isn't the problem if they both decided to choose either the default or the
     // same explicit impl but if their view on it differs it is a problem!
-    if let MonoItem::Fn(Instance { def: InstanceKind::EiiShim { .. }, .. }) = mono_item {
-        (Linkage::WeakAny, vis)
+    if let MonoItem::Fn(Instance { def: InstanceKind::EiiShim { weak_linkage, .. }, .. }) =
+        mono_item
+    {
+        if *weak_linkage { (Linkage::WeakAny, vis) } else { (Linkage::External, vis) }
     } else {
         (Linkage::External, vis)
     }