generate obligations instead of reporting ambiguity

dingxiangfei2009 · dingxiangfei2009 · commit 47fe867591c1 · 2025-04-16T22:51:59.000+02:00
A new mode of type relating is introduced so that obligations
are generated instead of outright rejecting projection clauses.
This allows project candidates that are sourced from more than
one predicates, such as supertrait bounds, provided that they
do not conflict each other.
diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
@@ -238,6 +238,34 @@ impl<'a, 'tcx> At<'a, 'tcx> {
         }
     }
 
+    // FIXME(arbitrary_self_types): remove this interface
+    // when the new solver is stabilised.
+    /// Almost like `eq_trace` except this type relating procedure will
+    /// also generate the obligations arising from equating projection
+    /// candidates.
+    pub fn eq_with_proj<T>(
+        self,
+        define_opaque_types: DefineOpaqueTypes,
+        expected: T,
+        actual: T,
+    ) -> InferResult<'tcx, ()>
+    where
+        T: ToTrace<'tcx>,
+    {
+        assert!(!self.infcx.next_trait_solver);
+        let trace = ToTrace::to_trace(self.cause, expected, actual);
+        let mut op = TypeRelating::new(
+            self.infcx,
+            trace,
+            self.param_env,
+            define_opaque_types,
+            ty::Invariant,
+        )
+        .through_projections(true);
+        op.relate(expected, actual)?;
+        Ok(InferOk { value: (), obligations: op.into_obligations() })
+    }
+
     pub fn relate<T>(
         self,
         define_opaque_types: DefineOpaqueTypes,
@@ -369,6 +397,18 @@ impl<'tcx> ToTrace<'tcx> for ty::Term<'tcx> {
     }
 }
 
+impl<'tcx> ToTrace<'tcx> for ty::Binder<'tcx, ty::Term<'tcx>> {
+    fn to_trace(cause: &ObligationCause<'tcx>, a: Self, b: Self) -> TypeTrace<'tcx> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::Terms(ExpectedFound {
+                expected: a.skip_binder(),
+                found: b.skip_binder(),
+            }),
+        }
+    }
+}
+
 impl<'tcx> ToTrace<'tcx> for ty::TraitRef<'tcx> {
     fn to_trace(cause: &ObligationCause<'tcx>, a: Self, b: Self) -> TypeTrace<'tcx> {
         TypeTrace { cause: cause.clone(), values: ValuePairs::TraitRefs(ExpectedFound::new(a, b)) }
diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs b/compiler/rustc_infer/src/infer/relate/type_relating.rs
@@ -22,6 +22,11 @@ pub(crate) struct TypeRelating<'infcx, 'tcx> {
     param_env: ty::ParamEnv<'tcx>,
     define_opaque_types: DefineOpaqueTypes,
 
+    /// This indicates whether the relation should
+    /// report obligations arising from equating aliasing terms
+    /// involving associated types, instead of rejection.
+    through_projections: bool,
+
     // Mutable fields.
     ambient_variance: ty::Variance,
     obligations: PredicateObligations<'tcx>,
@@ -67,9 +72,15 @@ impl<'infcx, 'tcx> TypeRelating<'infcx, 'tcx> {
             ambient_variance,
             obligations: PredicateObligations::new(),
             cache: Default::default(),
+            through_projections: false,
         }
     }
 
+    pub(crate) fn through_projections(mut self, walk_through: bool) -> Self {
+        self.through_projections = walk_through;
+        self
+    }
+
     pub(crate) fn into_obligations(self) -> PredicateObligations<'tcx> {
         self.obligations
     }
@@ -128,6 +139,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for TypeRelating<'_, 'tcx> {
         if self.cache.contains(&(self.ambient_variance, a, b)) {
             return Ok(a);
         }
+        let mut relate_result = a;
 
         match (a.kind(), b.kind()) {
             (&ty::Infer(TyVar(a_id)), &ty::Infer(TyVar(b_id))) => {
@@ -201,14 +213,42 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for TypeRelating<'_, 'tcx> {
                 )?);
             }
 
+            (
+                ty::Alias(ty::Projection | ty::Opaque, _),
+                ty::Alias(ty::Projection | ty::Opaque, _),
+            ) => {
+                super_combine_tys(infcx, self, a, b)?;
+            }
+
+            (&ty::Alias(ty::Projection, ty::AliasTy { def_id, args, .. }), _)
+                if matches!(self.ambient_variance, ty::Variance::Invariant)
+                    && self.through_projections =>
+            {
+                self.register_predicates([ty::ProjectionPredicate {
+                    projection_term: ty::AliasTerm::new(self.cx(), def_id, args),
+                    term: b.into(),
+                }]);
+                relate_result = b;
+            }
+
+            (_, &ty::Alias(ty::Projection, ty::AliasTy { def_id, args, .. }))
+                if matches!(self.ambient_variance, ty::Variance::Invariant)
+                    && self.through_projections =>
+            {
+                self.register_predicates([ty::ProjectionPredicate {
+                    projection_term: ty::AliasTerm::new(self.cx(), def_id, args),
+                    term: a.into(),
+                }]);
+            }
+
             _ => {
                 super_combine_tys(infcx, self, a, b)?;
             }
         }
 
         assert!(self.cache.insert((self.ambient_variance, a, b)));
 
-        Ok(a)
+        Ok(relate_result)
     }
 
     #[instrument(skip(self), level = "trace")]
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1,5 +1,6 @@
 //! Code for projecting associated types out of trait references.
 
+use std::iter::Extend;
 use std::ops::ControlFlow;
 
 use rustc_data_structures::sso::SsoHashSet;
@@ -65,6 +66,7 @@ enum ProjectionCandidate<'tcx> {
     Select(Selection<'tcx>),
 }
 
+#[derive(Debug)]
 enum ProjectionCandidateSet<'tcx> {
     None,
     Single(ProjectionCandidate<'tcx>),
@@ -648,15 +650,26 @@ fn project<'cx, 'tcx>(
     }
 
     let mut candidates = ProjectionCandidateSet::None;
+    let mut derived_obligations = PredicateObligations::default();
 
     // Make sure that the following procedures are kept in order. ParamEnv
     // needs to be first because it has highest priority, and Select checks
     // the return value of push_candidate which assumes it's ran at last.
-    assemble_candidates_from_param_env(selcx, obligation, &mut candidates);
+    assemble_candidates_from_param_env(
+        selcx,
+        obligation,
+        &mut candidates,
+        &mut derived_obligations,
+    );
 
     assemble_candidates_from_trait_def(selcx, obligation, &mut candidates);
 
-    assemble_candidates_from_object_ty(selcx, obligation, &mut candidates);
+    assemble_candidates_from_object_ty(
+        selcx,
+        obligation,
+        &mut candidates,
+        &mut derived_obligations,
+    );
 
     if let ProjectionCandidateSet::Single(ProjectionCandidate::Object(_)) = candidates {
         // Avoid normalization cycle from selection (see
@@ -669,7 +682,13 @@ fn project<'cx, 'tcx>(
 
     match candidates {
         ProjectionCandidateSet::Single(candidate) => {
-            confirm_candidate(selcx, obligation, candidate)
+            confirm_candidate(selcx, obligation, candidate).map(move |proj| {
+                if let Projected::Progress(progress) = proj {
+                    Projected::Progress(progress.with_addl_obligations(derived_obligations))
+                } else {
+                    proj
+                }
+            })
         }
         ProjectionCandidateSet::None => {
             let tcx = selcx.tcx();
@@ -691,14 +710,15 @@ fn assemble_candidates_from_param_env<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionTermObligation<'tcx>,
     candidate_set: &mut ProjectionCandidateSet<'tcx>,
+    derived_obligations: &mut impl Extend<PredicateObligation<'tcx>>,
 ) {
     assemble_candidates_from_predicates(
         selcx,
         obligation,
         candidate_set,
         ProjectionCandidate::ParamEnv,
         obligation.param_env.caller_bounds().iter(),
-        false,
+        derived_obligations,
     );
 }
 
@@ -712,6 +732,7 @@ fn assemble_candidates_from_param_env<'cx, 'tcx>(
 /// ```
 ///
 /// Here, for example, we could conclude that the result is `i32`.
+#[instrument(level = "debug", skip(selcx))]
 fn assemble_candidates_from_trait_def<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionTermObligation<'tcx>,
@@ -774,6 +795,7 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionTermObligation<'tcx>,
     candidate_set: &mut ProjectionCandidateSet<'tcx>,
+    derived_obligations: &mut impl Extend<PredicateObligation<'tcx>>,
 ) {
     debug!("assemble_candidates_from_object_ty(..)");
 
@@ -806,21 +828,18 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
         candidate_set,
         ProjectionCandidate::Object,
         env_predicates,
-        false,
+        derived_obligations,
     );
 }
 
-#[instrument(
-    level = "debug",
-    skip(selcx, candidate_set, ctor, env_predicates, potentially_unnormalized_candidates)
-)]
+#[instrument(level = "debug", skip(selcx, env_predicates, derived_obligations))]
 fn assemble_candidates_from_predicates<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionTermObligation<'tcx>,
     candidate_set: &mut ProjectionCandidateSet<'tcx>,
     ctor: fn(ty::PolyProjectionPredicate<'tcx>) -> ProjectionCandidate<'tcx>,
     env_predicates: impl Iterator<Item = ty::Clause<'tcx>>,
-    potentially_unnormalized_candidates: bool,
+    derived_obligations: &mut impl Extend<PredicateObligation<'tcx>>,
 ) {
     let infcx = selcx.infcx;
     let drcx = DeepRejectCtxt::relate_rigid_rigid(selcx.tcx());
@@ -838,28 +857,39 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
                 continue;
             }
 
-            let is_match = infcx.probe(|_| {
-                selcx.match_projection_projections(
-                    obligation,
-                    data,
-                    potentially_unnormalized_candidates,
-                )
-            });
+            let is_match =
+                infcx.probe(|_| selcx.match_projection_projections(obligation, data, false));
 
             match is_match {
                 ProjectionMatchesProjection::Yes => {
-                    candidate_set.push_candidate(ctor(data));
-
-                    if potentially_unnormalized_candidates
-                        && !obligation.predicate.has_non_region_infer()
+                    debug!(?data, "push");
+                    if let ProjectionCandidateSet::Single(
+                        ProjectionCandidate::ParamEnv(proj)
+                        | ProjectionCandidate::Object(proj)
+                        | ProjectionCandidate::TraitDef(proj),
+                    ) = candidate_set
                     {
-                        // HACK: Pick the first trait def candidate for a fully
-                        // inferred predicate. This is to allow duplicates that
-                        // differ only in normalization.
-                        return;
+                        match infcx.commit_if_ok(|_| {
+                            infcx.at(&obligation.cause, obligation.param_env).eq_with_proj(
+                                DefineOpaqueTypes::No,
+                                data.term(),
+                                proj.term(),
+                            )
+                        }) {
+                            Ok(InferOk { value: (), obligations }) => {
+                                derived_obligations.extend(obligations);
+                            }
+                            Err(e) => {
+                                debug!(?e, "refuse to unify candidates");
+                                candidate_set.push_candidate(ctor(data));
+                            }
+                        }
+                    } else {
+                        candidate_set.push_candidate(ctor(data));
                     }
                 }
                 ProjectionMatchesProjection::Ambiguous => {
+                    debug!("mark ambiguous");
                     candidate_set.mark_ambiguous();
                 }
                 ProjectionMatchesProjection::No => {}
@@ -868,7 +898,7 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
     }
 }
 
-#[instrument(level = "debug", skip(selcx, obligation, candidate_set))]
+#[instrument(level = "debug", skip(selcx))]
 fn assemble_candidates_from_impls<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionTermObligation<'tcx>,
diff --git a/tests/ui/associated-types/associated-type-projection-nonambig-supertrait.rs b/tests/ui/associated-types/associated-type-projection-nonambig-supertrait.rs
@@ -0,0 +1,48 @@
+//@ revisions: traditional next_solver
+//@ [next_solver] compile-flags: -Znext-solver
+//@ check-pass
+
+use std::marker::PhantomData;
+
+pub trait Receiver {
+    type Target: ?Sized;
+}
+
+pub trait Deref: Receiver<Target = <Self as Deref>::Target> {
+    type Target: ?Sized;
+    fn deref(&self) -> &<Self as Deref>::Target;
+}
+
+impl<T: Deref> Receiver for T {
+    type Target = <T as Deref>::Target;
+}
+
+// ===
+pub struct Type<Id, T>(PhantomData<(Id, T)>);
+pub struct AliasRef<Id, T: TypePtr<Id = Id>>(PhantomData<(Id, T)>);
+
+pub trait TypePtr: Deref<Target = Type<<Self as TypePtr>::Id, Self>> + Sized {
+    // ^ the impl head here provides the first candidate
+    // <T as Deref>::Target := Type<<T as TypePtr>::Id>
+    type Id;
+}
+
+pub struct Alias<Id, T>(PhantomData<(Id, T)>);
+
+impl<Id, T> Deref for Alias<Id, T>
+where
+    T: TypePtr<Id = Id> + Deref<Target = Type<Id, T>>,
+    // ^ the impl head here provides the second candidate
+    // <T as Deref>::Target := Type<Id, T>
+    // and additionally a normalisation is mandatory due to
+    // the following supertrait relation trait
+    // Deref: Receiver<Target = <Self as Deref>::Target>
+{
+    type Target = AliasRef<Id, T>;
+
+    fn deref(&self) -> &<Self as Deref>::Target {
+        todo!()
+    }
+}
+
+fn main() {}
