fix various bugs in EII (todo: absorb)

Author: jdonszelmann

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -59,6 +59,8 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, _: LocalCrate) -> DefIdMap<S
     let special_runtime_crate =
         tcx.is_panic_runtime(LOCAL_CRATE) || tcx.is_compiler_builtins(LOCAL_CRATE);
 
+    let eii_map = tcx.get_externally_implementable_item_impls(());
+
     let mut reachable_non_generics: DefIdMap<_> = tcx
         .reachable_set(())
         .items()
@@ -99,6 +101,17 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, _: LocalCrate) -> DefIdMap<S
                 return None;
             }
 
+            // We don't want to export EII shims. These are always created in final crates of a
+            // compile graph. The are exported in the linker sense - other compilation units can access them.
+            // But once we made a shim, we're the last one so we don't have to export downwards.
+            // The reason we explicitly need to exclude these is that for dylibs (.so) we already
+            // generate EII shims. However, these aren't always the final crate. However, in that
+            // case the final crate will generate its own shim so we shouldn't export the existing
+            // one from the dylib.
+            if eii_map.contains_key(&def_id) {
+                return None;
+            }
+
             if tcx.cross_crate_inlinable(def_id) { None } else { Some(def_id) }
         })
         .map(|def_id| {

compiler/rustc_const_eval/src/const_eval/fn_queries.rs

@@ -39,6 +39,8 @@ fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness {
                 // If the function itself is not annotated with `const`, it may still be a `const fn`
                 // if it resides in a const trait impl.
                 parent_impl_or_trait_constness(tcx, def_id)
+            } else if tcx.get_externally_implementable_item_impls(()).contains_key(&def_id) {
+                hir::Constness::NotConst
             } else {
                 tcx.dcx().span_bug(
                     tcx.def_span(def_id),

compiler/rustc_hir_analysis/messages.ftl

@@ -159,6 +159,10 @@ hir_analysis_drop_impl_reservation = reservation `Drop` impls are not supported
 hir_analysis_duplicate_precise_capture = cannot capture parameter `{$name}` twice
     .label = parameter captured again here
 
+hir_analysis_eii_with_generics =
+    #[{$eii_name}] cannot have generic parameters other than lifetimes
+    .label = required by this attribute
+
 hir_analysis_empty_specialization = specialization impl does not specialize any associated items
     .note = impl is a specialization of this impl
 
@@ -295,10 +299,10 @@ hir_analysis_lifetime_not_captured = `impl Trait` captures lifetime parameter, b
     .param_label = this lifetime parameter is captured
 
 hir_analysis_lifetimes_or_bounds_mismatch_on_eii =
-    lifetime parameters or bounds `{$ident}` do not match the declaration
+    lifetime parameters or bounds of `{$ident}` do not match the declaration
     .label = lifetimes do not match
     .generics_label = lifetimes in impl do not match this signature
-    .where_label = this `where` clause might not match the one in the trait
+    .where_label = this `where` clause might not match the one in the declaration
     .bounds_label = this bound might be missing in the implementation
 
 hir_analysis_lifetimes_or_bounds_mismatch_on_trait =

compiler/rustc_hir_analysis/src/check/compare_eii.rs

@@ -16,7 +16,7 @@ use rustc_trait_selection::traits::ObligationCtxt;
 use tracing::{debug, instrument};
 
 use super::potentially_plural_count;
-use crate::errors::LifetimesOrBoundsMismatchOnEII;
+use crate::errors::{EiiWithGenerics, LifetimesOrBoundsMismatchOnEII};
 
 /// Checks a bunch of different properties of the impl/trait methods for
 /// compatibility, such as asyncness, number of argument, self receiver kind,
@@ -28,12 +28,31 @@ fn check_is_structurally_compatible<'tcx>(
     eii_name: Symbol,
     eii_attr_span: Span,
 ) -> Result<(), ErrorGuaranteed> {
-    // FIXME(jdonszelmann): check no generics
+    check_no_generics(tcx, external_impl, declaration, eii_name, eii_attr_span)?;
     compare_number_of_method_arguments(tcx, external_impl, declaration, eii_name, eii_attr_span)?;
     check_region_bounds_on_impl_item(tcx, external_impl, declaration, eii_attr_span)?;
     Ok(())
 }
 
+fn check_no_generics<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    external_impl: LocalDefId,
+    _declaration: DefId,
+    eii_name: Symbol,
+    eii_attr_span: Span,
+) -> Result<(), ErrorGuaranteed> {
+    let generics = tcx.generics_of(external_impl);
+    if generics.own_requires_monomorphization() {
+        tcx.dcx().emit_err(EiiWithGenerics {
+            span: tcx.def_span(external_impl),
+            attr: eii_attr_span,
+            eii_name,
+        });
+    }
+
+    Ok(())
+}
+
 fn check_region_bounds_on_impl_item<'tcx>(
     tcx: TyCtxt<'tcx>,
     external_impl: LocalDefId,
@@ -268,6 +287,8 @@ pub(crate) fn compare_eii_function_types<'tcx>(
             terr,
             (declaration, declaration_sig),
             (external_impl, external_impl_sig),
+            eii_attr_span,
+            eii_name,
         );
         return Err(emitted);
     }
@@ -299,6 +320,8 @@ fn report_eii_mismatch<'tcx>(
     terr: TypeError<'tcx>,
     (declaration_did, declaration_sig): (DefId, ty::FnSig<'tcx>),
     (external_impl_did, external_impl_sig): (LocalDefId, ty::FnSig<'tcx>),
+    eii_attr_span: Span,
+    eii_name: Symbol,
 ) -> ErrorGuaranteed {
     let tcx = infcx.tcx;
     let (impl_err_span, trait_err_span, external_impl_name) =
@@ -308,9 +331,12 @@ fn report_eii_mismatch<'tcx>(
         tcx.dcx(),
         impl_err_span,
         E0053, // TODO: new error code
-        "function `{}` has a type that is incompatible with the declaration",
+        "function `{}` has a type that is incompatible with the declaration of `#[{eii_name}]`",
         external_impl_name
     );
+
+    diag.span_note(eii_attr_span, "expected this because of this attribute");
+
     match &terr {
         TypeError::ArgumentMutability(i) | TypeError::ArgumentSorts(_, i) => {
             if declaration_sig.inputs().len() == *i {

compiler/rustc_hir_analysis/src/collect.rs

@@ -33,6 +33,7 @@ use rustc_hir::{self as hir, GenericParamKind, HirId, Node, PreciseCapturingArgK
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::hir::nested_filter;
+use rustc_middle::middle::eii::EiiMapping;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::util::{Discr, IntTypeExt};
 use rustc_middle::ty::{self, AdtKind, Const, IsSuggestable, Ty, TyCtxt, TypingMode, fold_regions};
@@ -1372,6 +1373,16 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_, ty::PolyFn
             bug!("to get the signature of a closure, use `args.as_closure().sig()` not `fn_sig()`",);
         }
 
+        x @ Synthetic => {
+            if let Some(EiiMapping { extern_item, .. }) =
+                tcx.get_externally_implementable_item_impls(()).get(&def_id)
+            {
+                return tcx.fn_sig(extern_item);
+            } else {
+                bug!("unexpected sort of node in fn_sig(): {:?}", x);
+            }
+        }
+
         x => {
             bug!("unexpected sort of node in fn_sig(): {:?}", x);
         }

compiler/rustc_hir_analysis/src/errors.rs

@@ -222,6 +222,16 @@ pub(crate) struct LifetimesOrBoundsMismatchOnEII {
     pub ident: Symbol,
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_analysis_eii_with_generics)]
+pub(crate) struct EiiWithGenerics {
+    #[primary_span]
+    pub span: Span,
+    #[label]
+    pub attr: Span,
+    pub eii_name: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_analysis_drop_impl_on_wrong_item, code = E0120)]
 pub(crate) struct DropImplOnWrongItem {

compiler/rustc_middle/src/arena.rs

@@ -115,7 +115,7 @@ macro_rules! arena_types {
             [decode] specialization_graph: rustc_middle::traits::specialization_graph::Graph,
             [] crate_inherent_impls: rustc_middle::ty::CrateInherentImpls,
             [] hir_owner_nodes: rustc_hir::OwnerNodes<'tcx>,
-            [] get_externally_implementable_item_impls: rustc_data_structures::fx::FxIndexMap<rustc_hir::def_id::DefId, (rustc_hir::def_id::DefId, rustc_hir::def_id::LocalDefId)>,
+            [] get_externally_implementable_item_impls: rustc_middle::middle::eii::EiiMap,
         ]);
     )
 }

compiler/rustc_middle/src/hir/map.rs

@@ -19,6 +19,7 @@ use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, sym, with_metavar_spa
 
 use crate::hir::{ModuleItems, nested_filter};
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
+use crate::middle::eii::EiiMapping;
 use crate::query::LocalCrate;
 use crate::ty::TyCtxt;
 
@@ -1027,7 +1028,15 @@ impl<'tcx> TyCtxt<'tcx> {
             Node::Crate(item) => item.spans.inner_span,
             Node::WherePredicate(pred) => pred.span,
             Node::PreciseCapturingNonLifetimeArg(param) => param.ident.span,
-            Node::Synthetic => unreachable!(),
+            Node::Synthetic => {
+                if let Some(EiiMapping { chosen_impl, .. }) =
+                    self.tcx.get_externally_implementable_item_impls(()).get(&hir_id.owner.def_id)
+                {
+                    self.tcx.def_span(chosen_impl)
+                } else {
+                    unreachable!()
+                }
+            }
             Node::Err(span) => span,
         }
     }

compiler/rustc_middle/src/hir/mod.rs

@@ -16,6 +16,7 @@ use rustc_hir::*;
 use rustc_macros::{Decodable, Encodable, HashStable};
 use rustc_span::{ErrorGuaranteed, ExpnId, Span};
 
+use crate::middle::eii::EiiMapping;
 use crate::query::Providers;
 use crate::ty::{EarlyBinder, ImplSubject, TyCtxt};
 
@@ -223,6 +224,10 @@ pub fn provide(providers: &mut Providers) {
         }) = tcx.hir_node(tcx.local_def_id_to_hir_id(def_id))
         {
             idents
+        } else if let Some(EiiMapping { chosen_impl, .. }) =
+            tcx.get_externally_implementable_item_impls(()).get(&def_id)
+        {
+            tcx.fn_arg_names(chosen_impl)
         } else {
             span_bug!(
                 tcx.hir_span(tcx.local_def_id_to_hir_id(def_id)),

compiler/rustc_middle/src/middle/eii.rs

@@ -0,0 +1,12 @@
+use rustc_data_structures::fx::FxIndexMap;
+use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+
+#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
+#[derive(TyEncodable, TyDecodable, HashStable)]
+pub struct EiiMapping {
+    pub extern_item: DefId,
+    pub chosen_impl: DefId,
+}
+
+pub type EiiMap = FxIndexMap<LocalDefId, EiiMapping>;

compiler/rustc_middle/src/middle/mod.rs

@@ -30,6 +30,7 @@ pub mod lib_features {
         }
     }
 }
+pub mod eii;
 pub mod privacy;
 pub mod region;
 pub mod resolve_bound_vars;

compiler/rustc_middle/src/mir/mono.rs

@@ -181,8 +181,11 @@ impl<'tcx> MonoItem<'tcx> {
             return opt_incr_drop_glue_mode(tcx, ty);
         }
 
-        // eii shims are only generated in the final crate.
-        // As such, they will be both globally shared and unique.
+        // Eii shims are only generated in the final crate because we need to resolve defaults.
+        // Specifically, only when making the final crate we know whether there was an explicit
+        // implementation given *somewhere* and if not we then have to decide whether there is
+        // a default which we need to insert. That default needs to be shared between all
+        // dependencies; hence globally shared.
         if let InstanceKind::EiiShim { .. } = instance.def {
             return InstantiationMode::GloballyShared { may_conflict: false };
         }

compiler/rustc_middle/src/query/mod.rs

@@ -52,6 +52,7 @@ use crate::lint::LintExpectation;
 use crate::metadata::ModChild;
 use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
+use crate::middle::eii::EiiMap;
 use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use crate::middle::lib_features::LibFeatures;
 use crate::middle::privacy::EffectiveVisibilities;
@@ -1105,7 +1106,7 @@ rustc_queries! {
         desc { |tcx| "checking loops in {}", describe_as_module(key, tcx) }
     }
 
-    query get_externally_implementable_item_impls(_: ()) -> &'tcx rustc_data_structures::fx::FxIndexMap<DefId, (DefId, LocalDefId)> {
+    query get_externally_implementable_item_impls(_: ()) -> &'tcx EiiMap {
         desc { "check externally implementable items" }
     }
 
@@ -1711,11 +1712,6 @@ rustc_queries! {
         desc { "checking if the crate has_alloc_error_handler" }
         separate_provide_extern
     }
-    query has_panic_handler(_: CrateNum) -> bool {
-        fatal_cycle
-        desc { "checking if the crate has_panic_handler" }
-        separate_provide_extern
-    }
     query is_profiler_runtime(_: CrateNum) -> bool {
         fatal_cycle
         desc { "checking if a crate is `#![profiler_runtime]`" }

compiler/rustc_middle/src/ty/context.rs

@@ -3370,10 +3370,6 @@ pub fn provide(providers: &mut Providers) {
         |tcx, LocalCrate| contains_name(tcx.hir_krate_attrs(), sym::panic_runtime);
     providers.is_compiler_builtins =
         |tcx, LocalCrate| contains_name(tcx.hir_krate_attrs(), sym::compiler_builtins);
-    providers.has_panic_handler = |tcx, LocalCrate| {
-        // We want to check if the panic handler was defined in this crate
-        tcx.lang_items().panic_impl().is_some_and(|did| did.is_local())
-    };
     providers.source_span = |tcx, def_id| tcx.untracked.source_span.get(def_id).unwrap_or(DUMMY_SP);
 }
 

compiler/rustc_mir_transform/src/shim.rs

@@ -78,22 +78,29 @@ 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 } => {
             let source = MirSource::from_instance(e);
 
-            let fn_sig = tcx.fn_sig(chosen_impl).instantiate_identity().skip_binder();
-            let func_ty = Ty::new_fn_def(tcx, chosen_impl, GenericArgs::empty());
+            // get the signature for the new function this shim is creating
+            let shim_fn_sig = tcx.fn_sig(extern_item).instantiate_identity();
+            let shim_fn_sig = tcx.instantiate_bound_regions_with_erased(shim_fn_sig);
 
             let span = tcx.def_span(chosen_impl);
             let source_info = SourceInfo::outermost(span);
 
+            // we want to generate a call to this function
+            let args = ty::GenericArgs::identity_for_item(tcx, chosen_impl);
+            let chosen_fn_ty = Ty::new_fn_def(tcx, chosen_impl, args);
+
             let func = Operand::Constant(Box::new(ConstOperand {
                 span,
                 user_ty: None,
-                const_: Const::zero_sized(func_ty),
+                const_: Const::zero_sized(chosen_fn_ty),
             }));
 
-            let locals = local_decls_for_sig(&fn_sig, span);
+            // println!("generating EII shim for extern item {extern_item:?} and impl {chosen_impl:?}");
+
+            let locals = local_decls_for_sig(&shim_fn_sig, span);
             let mut blocks = IndexVec::new();
 
             let return_block = BasicBlock::new(1);
@@ -126,7 +133,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
                 is_cleanup: false,
             });
 
-            new_body(source, blocks, locals, fn_sig.inputs().len(), span)
+            new_body(source, blocks, locals, shim_fn_sig.inputs().len(), span)
         }
 
         ty::InstanceKind::DropGlue(def_id, ty) => {

compiler/rustc_monomorphize/src/collector.rs

@@ -207,7 +207,7 @@
 
 use std::path::PathBuf;
 
-use rustc_attr_parsing::{AttributeKind, EIIDecl, InlineAttr, find_attr};
+use rustc_attr_parsing::InlineAttr;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::{MTLock, par_for_each_in};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
@@ -216,6 +216,7 @@ use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
 use rustc_hir::lang_items::LangItem;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
+use rustc_middle::middle::eii::EiiMapping;
 use rustc_middle::mir::interpret::{AllocId, ErrorHandled, GlobalAlloc, Scalar};
 use rustc_middle::mir::mono::{CollectionMode, InstantiationMode, MonoItem};
 use rustc_middle::mir::visit::Visitor as MirVisitor;
@@ -1593,26 +1594,20 @@ 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 (decl, (chosen_impl, shim_did)) in self.tcx.get_externally_implementable_item_impls(())
+        for (shim_did, &EiiMapping { extern_item, chosen_impl, .. }) in
+            self.tcx.get_externally_implementable_item_impls(())
         {
-            let Some((eii_extern_item, span)) = find_attr!(
-                self.tcx.get_all_attrs(*decl),
-                AttributeKind::EiiMacroFor(EIIDecl { eii_extern_item, span, .. }) => (*eii_extern_item, *span)
-            ) else {
-                bug!("missing attr on EII macro");
-            };
-
             self.output.push(create_fn_mono_item(
                 self.tcx,
                 ty::Instance {
                     def: ty::InstanceKind::EiiShim {
                         def_id: (*shim_did).into(),
-                        extern_item: eii_extern_item,
-                        chosen_impl: *chosen_impl,
+                        extern_item,
+                        chosen_impl,
                     },
                     args: ty::GenericArgs::empty(),
                 },
-                span,
+                DUMMY_SP,
             ));
         }
     }