something

Author: compiler-errors

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs

@@ -134,6 +134,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             .into_iter()
             .filter(|(trait_ref, _)| !tcx.trait_is_auto(trait_ref.def_id()));
 
+        let mut implied_projection_bounds = vec![];
         for (base_trait_ref, original_span) in regular_traits_refs_spans {
             let base_pred: ty::Predicate<'tcx> = base_trait_ref.upcast(tcx);
             for ClauseWithSupertraitSpan { pred, supertrait_span } in
@@ -188,7 +189,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         // the discussion in #56288 for alternatives.
                         if !references_self {
                             // Include projections defined on supertraits.
-                            projection_bounds.push((pred, original_span));
+                            implied_projection_bounds.push(pred);
                         }
 
                         self.check_elaborated_projection_mentions_input_lifetimes(
@@ -221,6 +222,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
             }
         }
+        for projection_bound in &implied_projection_bounds {
+            let def_id = projection_bound.projection_def_id();
+            let trait_ref = tcx.anonymize_bound_vars(
+                projection_bound.map_bound(|p| p.projection_term.trait_ref(tcx)),
+            );
+            needed_associated_types.swap_remove(&(def_id, trait_ref));
+        }
 
         self.complain_about_missing_assoc_tys(
             principal_span,

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

@@ -3,6 +3,7 @@
 pub(super) mod structural_traits;
 
 use derive_where::derive_where;
+use rustc_type_ir::data_structures::HashSet;
 use rustc_type_ir::fold::TypeFoldable;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::TraitSolverLangItem;
@@ -664,13 +665,22 @@ where
         // Consider all of the auto-trait and projection bounds, which don't
         // need to be recorded as a `BuiltinImplSource::Object` since they don't
         // really have a vtable base...
+        let mut shadowed = HashSet::default();
         for bound in bounds.iter() {
             match bound.skip_binder() {
                 ty::ExistentialPredicate::Trait(_) => {
                     // Skip principal
                 }
-                ty::ExistentialPredicate::Projection(_)
-                | ty::ExistentialPredicate::AutoTrait(_) => {
+                ty::ExistentialPredicate::Projection(proj) => {
+                    shadowed.insert(proj.def_id);
+                    candidates.extend(G::probe_and_consider_object_bound_candidate(
+                        self,
+                        CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
+                        goal,
+                        bound.with_self_ty(cx, self_ty),
+                    ));
+                }
+                ty::ExistentialPredicate::AutoTrait(_) => {
                     candidates.extend(G::probe_and_consider_object_bound_candidate(
                         self,
                         CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
@@ -686,12 +696,19 @@ where
         // a projection goal.
         if let Some(principal) = bounds.principal() {
             let principal_trait_ref = principal.with_self_ty(cx, self_ty);
-            for (idx, assumption) in elaborate::supertraits(cx, principal_trait_ref).enumerate() {
+            let principal_clause: I::Clause = principal_trait_ref.upcast(cx);
+            for (idx, assumption) in elaborate::elaborate(cx, [principal_clause]).enumerate() {
+                if let Some(proj) = assumption.as_projection_clause() {
+                    if shadowed.contains(&proj.projection_def_id()) {
+                        continue;
+                    }
+                }
+
                 candidates.extend(G::probe_and_consider_object_bound_candidate(
                     self,
                     CandidateSource::BuiltinImpl(BuiltinImplSource::Object(idx)),
                     goal,
-                    assumption.upcast(cx),
+                    assumption,
                 ));
             }
         }

compiler/rustc_trait_selection/src/traits/project.rs

@@ -19,6 +19,7 @@ use rustc_middle::ty::visit::{MaxUniverse, TypeVisitable, TypeVisitableExt};
 use rustc_middle::ty::{self, Term, Ty, TyCtxt, TypingMode, Upcast};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::sym;
+use rustc_type_ir::elaborate;
 use tracing::{debug, instrument};
 
 use super::{
@@ -60,7 +61,7 @@ enum ProjectionCandidate<'tcx> {
     TraitDef(ty::PolyProjectionPredicate<'tcx>),
 
     /// Bounds specified on an object type
-    Object(ty::PolyProjectionPredicate<'tcx>),
+    Object(ty::PolyProjectionPredicate<'tcx>, bool),
 
     /// From an "impl" (or a "pseudo-impl" returned by select)
     Select(Selection<'tcx>),
@@ -683,7 +684,7 @@ fn project<'cx, 'tcx>(
 
     assemble_candidates_from_object_ty(selcx, obligation, &mut candidates);
 
-    if let ProjectionCandidateSet::Single(ProjectionCandidate::Object(_)) = candidates {
+    if let ProjectionCandidateSet::Single(ProjectionCandidate::Object(..)) = candidates {
         // Avoid normalization cycle from selection (see
         // `assemble_candidates_from_object_ty`).
         // FIXME(lazy_normalization): Lazy normalization should save us from
@@ -839,6 +840,7 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
         }
         _ => return,
     };
+
     let env_predicates = data
         .projection_bounds()
         .filter(|bound| bound.item_def_id() == obligation.predicate.def_id)
@@ -848,10 +850,30 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
         selcx,
         obligation,
         candidate_set,
-        ProjectionCandidate::Object,
+        |c| ProjectionCandidate::Object(c, false),
         env_predicates,
         false,
     );
+
+    let shadowed =
+        data.projection_bounds().any(|bound| bound.item_def_id() == obligation.predicate.def_id);
+
+    if !shadowed && let Some(principal) = data.principal() {
+        let principal: ty::Clause<'tcx> = principal.with_self_ty(tcx, self_ty).upcast(tcx);
+        let supertrait_projections = elaborate::elaborate(tcx, [principal]).filter(|clause| {
+            clause
+                .as_projection_clause()
+                .is_some_and(|proj| proj.projection_def_id() == obligation.predicate.def_id)
+        });
+        assemble_candidates_from_predicates(
+            selcx,
+            obligation,
+            candidate_set,
+            |c| ProjectionCandidate::Object(c, true),
+            supertrait_projections,
+            true,
+        );
+    }
 }
 
 #[instrument(
@@ -1258,10 +1280,12 @@ fn confirm_candidate<'cx, 'tcx>(
 ) -> Progress<'tcx> {
     debug!(?obligation, ?candidate, "confirm_candidate");
     let mut progress = match candidate {
-        ProjectionCandidate::ParamEnv(poly_projection)
-        | ProjectionCandidate::Object(poly_projection) => {
+        ProjectionCandidate::ParamEnv(poly_projection) => {
             confirm_param_env_candidate(selcx, obligation, poly_projection, false)
         }
+        ProjectionCandidate::Object(poly_projection, from_super) => {
+            confirm_param_env_candidate(selcx, obligation, poly_projection, from_super)
+        }
 
         ProjectionCandidate::TraitDef(poly_projection) => {
             confirm_param_env_candidate(selcx, obligation, poly_projection, true)

tests/ui/associated-types/issue-59324.stderr

@@ -43,18 +43,6 @@ help: consider further restricting this bound
 LL | pub trait ThriftService<Bug: NotFoo + Foo>:
    |                                     +++++
 
-error[E0277]: the trait bound `(): Foo` is not satisfied
-  --> $DIR/issue-59324.rs:23:29
-   |
-LL | fn with_factory<H>(factory: dyn ThriftService<()>) {}
-   |                             ^^^^^^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `()`
-   |
-help: this trait has no implementations, consider adding one
-  --> $DIR/issue-59324.rs:3:1
-   |
-LL | pub trait Foo: NotFoo {
-   | ^^^^^^^^^^^^^^^^^^^^^
-
 error[E0277]: the trait bound `Bug: Foo` is not satisfied
   --> $DIR/issue-59324.rs:19:10
    |
@@ -66,25 +54,13 @@ help: consider further restricting this bound
 LL | pub trait ThriftService<Bug: NotFoo + Foo>:
    |                                     +++++
 
-error[E0277]: the trait bound `(): Foo` is not satisfied
-  --> $DIR/issue-59324.rs:23:52
-   |
-LL | fn with_factory<H>(factory: dyn ThriftService<()>) {}
-   |                                                    ^^ the trait `Foo` is not implemented for `()`
-   |
-help: this trait has no implementations, consider adding one
-  --> $DIR/issue-59324.rs:3:1
-   |
-LL | pub trait Foo: NotFoo {
-   | ^^^^^^^^^^^^^^^^^^^^^
-
-error[E0277]: the size for values of type `(dyn ThriftService<(), AssocType = _> + 'static)` cannot be known at compilation time
+error[E0277]: the size for values of type `(dyn ThriftService<()> + 'static)` cannot be known at compilation time
   --> $DIR/issue-59324.rs:23:29
    |
 LL | fn with_factory<H>(factory: dyn ThriftService<()>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-   = help: the trait `Sized` is not implemented for `(dyn ThriftService<(), AssocType = _> + 'static)`
+   = help: the trait `Sized` is not implemented for `(dyn ThriftService<()> + 'static)`
    = help: unsized fn params are gated as an unstable feature
 help: you can use `impl Trait` as the argument type
    |
@@ -95,6 +71,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn with_factory<H>(factory: &dyn ThriftService<()>) {}
    |                             +
 
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

tests/ui/dyn-compatibility/multiple-supers-should-work.rs

@@ -0,0 +1,18 @@
+//@ check-pass
+
+trait Sup<T> {
+    type Assoc;
+}
+
+impl<T> Sup<T> for () {
+    type Assoc = T;
+}
+
+trait Trait<A, B>: Sup<A, Assoc = A> + Sup<B, Assoc = B> {}
+
+impl<T, U> Trait<T, U> for () {}
+
+fn main() {
+    let x: &dyn Trait<(), _> = &();
+    let y: &dyn Trait<_, ()> = x;
+}

tests/ui/traits/alias/dont-elaborate-non-self.stderr

@@ -1,10 +1,10 @@
-error[E0277]: the size for values of type `(dyn Fn() -> Fut + 'static)` cannot be known at compilation time
+error[E0277]: the size for values of type `(dyn Fn<()> + 'static)` cannot be known at compilation time
   --> $DIR/dont-elaborate-non-self.rs:7:14
    |
 LL | fn f<Fut>(a: dyn F<Fut>) {}
    |              ^^^^^^^^^^ doesn't have a size known at compile-time
    |
-   = help: the trait `Sized` is not implemented for `(dyn Fn() -> Fut + 'static)`
+   = help: the trait `Sized` is not implemented for `(dyn Fn<()> + 'static)`
    = help: unsized fn params are gated as an unstable feature
 help: you can use `impl Trait` as the argument type
    |