Capture binder region constraints while relating

Dnreikronos · Dnreikronos · commit d78cef77177d · 2026-06-16T16:03:16.000-03:00
diff --git a/compiler/rustc_next_trait_solver/src/canonical/mod.rs b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
@@ -265,8 +265,17 @@ fn unify_query_var_values<D, I>(
     assert_eq!(original_values.len(), var_values.len());
 
     for (&orig, response) in iter::zip(original_values, var_values.var_values.iter()) {
-        let goals =
-            delegate.eq_structurally_relating_aliases(param_env, orig, response, span).unwrap();
+        let goals = if delegate.cx().assumptions_on_binders() {
+            let (goals, region_constraints) = delegate
+                .eq_structurally_relating_aliases_with_region_constraints(
+                    param_env, orig, response, span,
+                )
+                .unwrap();
+            delegate.register_solver_region_constraint(region_constraints);
+            goals
+        } else {
+            delegate.eq_structurally_relating_aliases(param_env, orig, response, span).unwrap()
+        };
         assert!(goals.is_empty());
     }
 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -1253,13 +1253,7 @@ where
             let identity_args = self.fresh_args_for_item(def_id);
             let rigid_ctor = alias.with_args(cx, identity_args);
             let ctor_term = rigid_ctor.to_term(cx);
-            let obligations = self.delegate.eq_structurally_relating_aliases(
-                param_env,
-                term,
-                ctor_term,
-                self.origin_span,
-            )?;
-            debug_assert!(obligations.is_empty());
+            self.eq_structurally_relating_aliases(param_env, term, ctor_term)?;
             self.relate(param_env, alias, variance, rigid_ctor)
         } else {
             Err(NoSolution)
@@ -1276,12 +1270,19 @@ where
         lhs: T,
         rhs: T,
     ) -> Result<(), NoSolution> {
-        let result = self.delegate.eq_structurally_relating_aliases(
-            param_env,
-            lhs,
-            rhs,
-            self.origin_span,
-        )?;
+        let result = if self.cx().assumptions_on_binders() {
+            let (goals, region_constraints) =
+                self.delegate.eq_structurally_relating_aliases_with_region_constraints(
+                    param_env,
+                    lhs,
+                    rhs,
+                    self.origin_span,
+                )?;
+            self.register_solver_region_constraint(region_constraints);
+            goals
+        } else {
+            self.delegate.eq_structurally_relating_aliases(param_env, lhs, rhs, self.origin_span)?
+        };
         assert_eq!(result, vec![]);
         Ok(())
     }
@@ -1304,7 +1305,19 @@ where
         variance: ty::Variance,
         rhs: T,
     ) -> Result<(), NoSolution> {
-        let goals = self.delegate.relate(param_env, lhs, variance, rhs, self.origin_span)?;
+        let goals = if self.cx().assumptions_on_binders() {
+            let (goals, region_constraints) = self.delegate.relate_with_region_constraints(
+                param_env,
+                lhs,
+                variance,
+                rhs,
+                self.origin_span,
+            )?;
+            self.register_solver_region_constraint(region_constraints);
+            goals
+        } else {
+            self.delegate.relate(param_env, lhs, variance, rhs, self.origin_span)?
+        };
         for &goal in goals.iter() {
             let source = match goal.predicate.kind().skip_binder() {
                 ty::PredicateKind::Subtype { .. } | ty::PredicateKind::AliasRelate(..) => {
@@ -1326,12 +1339,30 @@ where
     /// goals correctly.
     #[instrument(level = "trace", skip(self, param_env), ret)]
     pub(super) fn eq_and_get_goals<T: Relate<I>>(
-        &self,
+        &mut self,
         param_env: I::ParamEnv,
         lhs: T,
         rhs: T,
     ) -> Result<Vec<Goal<I, I::Predicate>>, NoSolution> {
-        Ok(self.delegate.relate(param_env, lhs, ty::Variance::Invariant, rhs, self.origin_span)?)
+        if self.cx().assumptions_on_binders() {
+            let (goals, region_constraints) = self.delegate.relate_with_region_constraints(
+                param_env,
+                lhs,
+                ty::Variance::Invariant,
+                rhs,
+                self.origin_span,
+            )?;
+            self.register_solver_region_constraint(region_constraints);
+            Ok(goals)
+        } else {
+            Ok(self.delegate.relate(
+                param_env,
+                lhs,
+                ty::Variance::Invariant,
+                rhs,
+                self.origin_span,
+            )?)
+        }
     }
 
     pub(super) fn instantiate_binder_with_infer<T: TypeFoldable<I> + Copy>(
diff --git a/compiler/rustc_type_ir/src/relate/solver_relating.rs b/compiler/rustc_type_ir/src/relate/solver_relating.rs
@@ -2,6 +2,7 @@ use tracing::{debug, instrument};
 
 use self::combine::{PredicateEmittingRelation, super_combine_consts, super_combine_tys};
 use crate::data_structures::DelayedSet;
+use crate::region_constraint::RegionConstraint;
 use crate::relate::combine::combine_ty_args;
 pub use crate::relate::*;
 use crate::solve::{Goal, VisibleForLeakCheck};
@@ -30,6 +31,70 @@ pub trait RelateExt: InferCtxtLike {
         Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
         TypeError<Self::Interner>,
     >;
+
+    fn eq_structurally_relating_aliases_with_region_constraints<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        rhs: T,
+        span: <Self::Interner as Interner>::Span,
+    ) -> Result<
+        (
+            Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
+            RegionConstraint<Self::Interner>,
+        ),
+        TypeError<Self::Interner>,
+    >;
+
+    fn relate_with_region_constraints<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        variance: ty::Variance,
+        rhs: T,
+        span: <Self::Interner as Interner>::Span,
+    ) -> Result<
+        (
+            Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
+            RegionConstraint<Self::Interner>,
+        ),
+        TypeError<Self::Interner>,
+    >;
+}
+
+fn relate_with_options<Infcx, T>(
+    infcx: &Infcx,
+    structurally_relate_aliases: StructurallyRelateAliases,
+    param_env: <Infcx::Interner as Interner>::ParamEnv,
+    lhs: T,
+    variance: ty::Variance,
+    rhs: T,
+    span: <Infcx::Interner as Interner>::Span,
+    collect_region_constraints: bool,
+) -> Result<
+    (
+        Vec<Goal<Infcx::Interner, <Infcx::Interner as Interner>::Predicate>>,
+        Option<RegionConstraint<Infcx::Interner>>,
+    ),
+    TypeError<Infcx::Interner>,
+>
+where
+    Infcx: InferCtxtLike,
+    T: Relate<Infcx::Interner>,
+{
+    let mut relate = SolverRelating::build(
+        infcx,
+        structurally_relate_aliases,
+        variance,
+        param_env,
+        span,
+        collect_region_constraints.then(Vec::new),
+    );
+    relate.relate(lhs, rhs)?;
+    Ok((
+        relate.goals,
+        relate.region_constraints.map(|c| RegionConstraint::And(c.into_boxed_slice())),
+    ))
 }
 
 impl<Infcx: InferCtxtLike> RelateExt for Infcx {
@@ -44,10 +109,17 @@ impl<Infcx: InferCtxtLike> RelateExt for Infcx {
         Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
         TypeError<Self::Interner>,
     > {
-        let mut relate =
-            SolverRelating::new(self, StructurallyRelateAliases::No, variance, param_env, span);
-        relate.relate(lhs, rhs)?;
-        Ok(relate.goals)
+        let (goals, _) = relate_with_options(
+            self,
+            StructurallyRelateAliases::No,
+            param_env,
+            lhs,
+            variance,
+            rhs,
+            span,
+            false,
+        )?;
+        Ok(goals)
     }
 
     fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
@@ -60,15 +132,70 @@ impl<Infcx: InferCtxtLike> RelateExt for Infcx {
         Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
         TypeError<Self::Interner>,
     > {
-        let mut relate = SolverRelating::new(
+        let (goals, _) = relate_with_options(
             self,
             StructurallyRelateAliases::Yes,
+            param_env,
+            lhs,
             ty::Invariant,
+            rhs,
+            span,
+            false,
+        )?;
+        Ok(goals)
+    }
+
+    fn eq_structurally_relating_aliases_with_region_constraints<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        rhs: T,
+        span: <Self::Interner as Interner>::Span,
+    ) -> Result<
+        (
+            Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
+            RegionConstraint<Self::Interner>,
+        ),
+        TypeError<Self::Interner>,
+    > {
+        let (goals, region_constraints) = relate_with_options(
+            self,
+            StructurallyRelateAliases::Yes,
             param_env,
+            lhs,
+            ty::Invariant,
+            rhs,
             span,
-        );
-        relate.relate(lhs, rhs)?;
-        Ok(relate.goals)
+            true,
+        )?;
+        Ok((goals, region_constraints.unwrap()))
+    }
+
+    fn relate_with_region_constraints<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        variance: ty::Variance,
+        rhs: T,
+        span: <Self::Interner as Interner>::Span,
+    ) -> Result<
+        (
+            Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
+            RegionConstraint<Self::Interner>,
+        ),
+        TypeError<Self::Interner>,
+    > {
+        let (goals, region_constraints) = relate_with_options(
+            self,
+            StructurallyRelateAliases::No,
+            param_env,
+            lhs,
+            variance,
+            rhs,
+            span,
+            true,
+        )?;
+        Ok((goals, region_constraints.unwrap()))
     }
 }
 
@@ -82,6 +209,7 @@ pub struct SolverRelating<'infcx, Infcx, I: Interner> {
     // Mutable fields.
     ambient_variance: ty::Variance,
     goals: Vec<Goal<I, I::Predicate>>,
+    region_constraints: Option<Vec<RegionConstraint<I>>>,
     /// The cache only tracks the `ambient_variance` as it's the
     /// only field which is mutable and which meaningfully changes
     /// the result when relating types.
@@ -118,6 +246,17 @@ where
         ambient_variance: ty::Variance,
         param_env: I::ParamEnv,
         span: I::Span,
+    ) -> Self {
+        Self::build(infcx, structurally_relate_aliases, ambient_variance, param_env, span, None)
+    }
+
+    fn build(
+        infcx: &'infcx Infcx,
+        structurally_relate_aliases: StructurallyRelateAliases,
+        ambient_variance: ty::Variance,
+        param_env: I::ParamEnv,
+        span: I::Span,
+        region_constraints: Option<Vec<RegionConstraint<I>>>,
     ) -> Self {
         SolverRelating {
             infcx,
@@ -126,6 +265,7 @@ where
             ambient_variance,
             param_env,
             goals: vec![],
+            region_constraints,
             cache: Default::default(),
         }
     }
@@ -265,6 +405,35 @@ where
             }
         }
 
+        let resolve_region = |r: I::Region| match r.kind() {
+            ty::ReVar(vid) => self.infcx.opportunistic_resolve_lt_var(vid),
+            _ => r,
+        };
+        let a = resolve_region(a);
+        let b = resolve_region(b);
+
+        if let Some(region_constraints) = &mut self.region_constraints {
+            if a == b {
+                return Ok(a);
+            } else {
+                match self.ambient_variance {
+                    ty::Covariant => {
+                        region_constraints.push(RegionConstraint::RegionOutlives(a, b));
+                    }
+                    ty::Contravariant => {
+                        region_constraints.push(RegionConstraint::RegionOutlives(b, a));
+                    }
+                    ty::Invariant => {
+                        region_constraints.push(RegionConstraint::RegionOutlives(a, b));
+                        region_constraints.push(RegionConstraint::RegionOutlives(b, a));
+                    }
+                    ty::Bivariant => {
+                        unreachable!("Expected bivariance to be handled in relate_with_variance")
+                    }
+                }
+            }
+        }
+
         Ok(a)
     }
 
diff --git a/tests/ui/assumptions_on_binders/principal-upcast-region-eq-issue-157859.rs b/tests/ui/assumptions_on_binders/principal-upcast-region-eq-issue-157859.rs
@@ -0,0 +1,19 @@
+//@compile-flags: -Zassumptions-on-binders  -Znext-solver=globally
+//@ dont-require-annotations: ERROR
+
+trait Super<U> {
+    fn a(&self) {
+        let a: &dyn Sub = &();
+        let b: &dyn Super<for<'a> fn(&'a ())> = a;
+    }
+}
+
+impl<T> Super<T> for () {}
+
+trait Sub: Super<fn(&'static ())> {}
+
+impl Sub for () {}
+
+fn main() {
+    let a: &dyn Sub = &();
+}
diff --git a/tests/ui/assumptions_on_binders/principal-upcast-region-eq-issue-157859.stderr b/tests/ui/assumptions_on_binders/principal-upcast-region-eq-issue-157859.stderr
@@ -0,0 +1,13 @@
+error[E0277]: the trait bound `&dyn Sub: CoerceUnsized<&dyn Super<for<'a> fn(&'a ())>>` is not satisfied
+  --> $DIR/principal-upcast-region-eq-issue-157859.rs:7:49
+   |
+LL |         let b: &dyn Super<for<'a> fn(&'a ())> = a;
+   |                                                 ^ the nightly-only, unstable trait `Unsize<dyn Super<for<'a> fn(&'a ())>>` is not implemented for `dyn Sub`
+   |
+   = note: all implementations of `Unsize` are provided automatically by the compiler, see <https://doc.rust-lang.org/stable/std/marker/trait.Unsize.html> for more information
+   = note: required for `&dyn Sub` to implement `CoerceUnsized<&dyn Super<for<'a> fn(&'a ())>>`
+   = note: required for the cast from `&dyn Sub` to `&dyn Super<for<'a> fn(&'a ())>`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/assumptions_on_binders/trait-upcast-projection-region-eq.rs b/tests/ui/assumptions_on_binders/trait-upcast-projection-region-eq.rs
diff --git a/tests/ui/assumptions_on_binders/trait-upcast-projection-region-eq.stderr b/tests/ui/assumptions_on_binders/trait-upcast-projection-region-eq.stderr
