Disqualify built-in trait impl if it seems likely to be overlap in an unsound way with a blanket impl

Author: compiler-errors

compiler/rustc_middle/src/query/mod.rs

@@ -1373,6 +1373,14 @@ rustc_queries! {
         desc { |tcx| "checking if trait `{}` is dyn-compatible", tcx.def_path_str(trait_id) }
     }
 
+    query trait_has_impl_which_may_shadow_dyn(trait_def_id: DefId) -> bool {
+        desc {
+            |tcx| "checking if trait `{}` has an impl which may overlap with \
+            the built-in impl for trait objects",
+            tcx.def_path_str(trait_def_id)
+        }
+    }
+
     /// Gets the ParameterEnvironment for a given item; this environment
     /// will be in "user-facing" mode, meaning that it is suitable for
     /// type-checking etc, and it does not normalize specializable

compiler/rustc_middle/src/ty/context.rs

@@ -589,6 +589,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.trait_def(trait_def_id).safety == hir::Safety::Unsafe
     }
 
+    fn trait_has_impl_which_may_shadow_dyn(self, trait_def_id: DefId) -> bool {
+        self.trait_has_impl_which_may_shadow_dyn(trait_def_id)
+    }
+
     fn is_impl_trait_in_trait(self, def_id: DefId) -> bool {
         self.is_impl_trait_in_trait(def_id)
     }

compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -82,6 +82,10 @@ where
         goal: Goal<I, Self>,
         assumption: I::Clause,
     ) -> Result<Candidate<I>, NoSolution> {
+        if ecx.cx().trait_has_impl_which_may_shadow_dyn(goal.predicate.trait_def_id(ecx.cx())) {
+            return Err(NoSolution);
+        }
+
         Self::probe_and_match_goal_against_assumption(ecx, source, goal, assumption, |ecx| {
             let cx = ecx.cx();
             let ty::Dynamic(bounds, _, _) = goal.predicate.self_ty().kind() else {

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -830,6 +830,7 @@ pub fn provide(providers: &mut Providers) {
         specialization_graph_of: specialize::specialization_graph_provider,
         specializes: specialize::specializes,
         specialization_enabled_in: specialize::specialization_enabled_in,
+        trait_has_impl_which_may_shadow_dyn: specialize::trait_has_impl_which_may_shadow_dyn,
         instantiate_and_check_impossible_predicates,
         is_impossible_associated_item,
         ..*providers

compiler/rustc_trait_selection/src/traits/project.rs

@@ -817,6 +817,7 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
     let env_predicates = data
         .projection_bounds()
         .filter(|bound| bound.item_def_id() == obligation.predicate.def_id)
+        .filter(|bound| !tcx.trait_has_impl_which_may_shadow_dyn(bound.trait_def_id(tcx)))
         .map(|p| p.with_self_ty(tcx, object_ty).upcast(tcx));
 
     assemble_candidates_from_predicates(

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -832,7 +832,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             "assemble_candidates_from_object_ty",
         );
 
-        if !self.tcx().trait_def(obligation.predicate.def_id()).implement_via_object {
+        let tcx = self.tcx();
+        if !tcx.trait_def(obligation.predicate.def_id()).implement_via_object {
             return;
         }
 
@@ -853,9 +854,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
                         if let Some(principal) = data.principal() {
                             if !self.infcx.tcx.features().dyn_compatible_for_dispatch() {
-                                principal.with_self_ty(self.tcx(), self_ty)
-                            } else if self.tcx().is_dyn_compatible(principal.def_id()) {
-                                principal.with_self_ty(self.tcx(), self_ty)
+                                principal.with_self_ty(tcx, self_ty)
+                            } else if tcx.is_dyn_compatible(principal.def_id()) {
+                                principal.with_self_ty(tcx, self_ty)
                             } else {
                                 return;
                             }
@@ -879,7 +880,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 // correct trait, but also the correct type parameters.
                 // For example, we may be trying to upcast `Foo` to `Bar<i32>`,
                 // but `Foo` is declared as `trait Foo: Bar<u32>`.
-                let candidate_supertraits = util::supertraits(self.tcx(), principal_trait_ref)
+                let candidate_supertraits = util::supertraits(tcx, principal_trait_ref)
                     .enumerate()
                     .filter(|&(_, upcast_trait_ref)| {
                         self.infcx.probe(|_| {
@@ -891,6 +892,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                             .is_ok()
                         })
                     })
+                    .filter(|(_, trait_ref)| {
+                        !tcx.trait_has_impl_which_may_shadow_dyn(trait_ref.def_id())
+                    })
                     .map(|(idx, _)| ObjectCandidate(idx));
 
                 candidates.vec.extend(candidate_supertraits);

compiler/rustc_trait_selection/src/traits/specialize/mod.rs

@@ -14,6 +14,7 @@ pub mod specialization_graph;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::codes::*;
 use rustc_errors::{Diag, EmissionGuarantee};
+use rustc_hir::LangItem;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_infer::traits::Obligation;
 use rustc_middle::bug;
@@ -595,3 +596,58 @@ fn report_conflicting_impls<'tcx>(
         }
     }
 }
+
+pub(super) fn trait_has_impl_which_may_shadow_dyn<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    trait_def_id: DefId,
+) -> bool {
+    // We only care about trait objects which have associated types.
+    if !tcx
+        .associated_items(trait_def_id)
+        .in_definition_order()
+        .any(|item| item.kind == ty::AssocKind::Type)
+    {
+        return false;
+    }
+
+    let mut has_impl = false;
+    tcx.for_each_impl(trait_def_id, |impl_def_id| {
+        if has_impl {
+            return;
+        }
+
+        let self_ty = tcx
+            .impl_trait_ref(impl_def_id)
+            .expect("impl must have trait ref")
+            .instantiate_identity()
+            .self_ty();
+        if self_ty.is_known_rigid() {
+            return;
+        }
+
+        let sized_trait = tcx.require_lang_item(LangItem::Sized, None);
+        if tcx
+            .param_env(impl_def_id)
+            .caller_bounds()
+            .iter()
+            .filter_map(|clause| clause.as_trait_clause())
+            .any(|bound| bound.def_id() == sized_trait && bound.self_ty().skip_binder() == self_ty)
+        {
+            return;
+        }
+
+        if let ty::Alias(ty::Projection, alias_ty) = self_ty.kind()
+            && tcx
+                .item_super_predicates(alias_ty.def_id)
+                .iter_identity()
+                .filter_map(|clause| clause.as_trait_clause())
+                .any(|bound| bound.def_id() == sized_trait)
+        {
+            return;
+        }
+
+        has_impl = true;
+    });
+
+    has_impl
+}

compiler/rustc_type_ir/src/interner.rs

@@ -273,6 +273,8 @@ pub trait Interner:
     /// Returns `true` if this is an `unsafe trait`.
     fn trait_is_unsafe(self, trait_def_id: Self::DefId) -> bool;
 
+    fn trait_has_impl_which_may_shadow_dyn(self, trait_def_id: Self::DefId) -> bool;
+
     fn is_impl_trait_in_trait(self, def_id: Self::DefId) -> bool;
 
     fn delay_bug(self, msg: impl ToString) -> Self::ErrorGuaranteed;

compiler/rustc_type_ir/src/predicate.rs

@@ -433,6 +433,10 @@ impl<I: Interner> ty::Binder<I, ExistentialProjection<I>> {
     pub fn item_def_id(&self) -> I::DefId {
         self.skip_binder().def_id
     }
+
+    pub fn trait_def_id(self, interner: I) -> I::DefId {
+        interner.parent(self.skip_binder().def_id)
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]

tests/ui/coherence/indirect-impl-for-trait-obj-coherence.current.stderr

@@ -0,0 +1,25 @@
+error[E0308]: mismatched types
+  --> $DIR/indirect-impl-for-trait-obj-coherence.rs:23:41
+   |
+LL | fn transmute<T, U>(x: T) -> U {
+   |              -  - expected type parameter
+   |              |
+   |              found type parameter
+LL |     foo::<dyn Object<U, Output = T>, U>(x)
+   |     ----------------------------------- ^ expected type parameter `U`, found type parameter `T`
+   |     |
+   |     arguments to this function are incorrect
+   |
+   = note: expected type parameter `U`
+              found type parameter `T`
+   = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
+   = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
+note: function defined here
+  --> $DIR/indirect-impl-for-trait-obj-coherence.rs:17:4
+   |
+LL | fn foo<T: ?Sized, U>(x: <T as Object<U>>::Output) -> U {
+   |    ^^^               ---------------------------
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.