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>;