Reproduce direct solver region registration failures

Author: Dnreikronos

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

@@ -1270,19 +1270,12 @@ where
         lhs: T,
         rhs: T,
     ) -> Result<(), NoSolution> {
-        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)?
-        };
+        let result = self.delegate.eq_structurally_relating_aliases(
+            param_env,
+            lhs,
+            rhs,
+            self.origin_span,
+        )?;
         assert_eq!(result, vec![]);
         Ok(())
     }
@@ -1305,19 +1298,7 @@ where
         variance: ty::Variance,
         rhs: T,
     ) -> Result<(), NoSolution> {
-        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)?
-        };
+        let goals = 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(..) => {
@@ -1339,30 +1320,12 @@ where
     /// goals correctly.
     #[instrument(level = "trace", skip(self, param_env), ret)]
     pub(super) fn eq_and_get_goals<T: Relate<I>>(
-        &mut self,
+        &self,
         param_env: I::ParamEnv,
         lhs: T,
         rhs: T,
     ) -> Result<Vec<Goal<I, I::Predicate>>, NoSolution> {
-        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,
-            )?)
-        }
+        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>(

compiler/rustc_type_ir/src/relate/solver_relating.rs

@@ -31,70 +31,6 @@ 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 {
@@ -109,17 +45,10 @@ impl<Infcx: InferCtxtLike> RelateExt for Infcx {
         Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
         TypeError<Self::Interner>,
     > {
-        let (goals, _) = relate_with_options(
-            self,
-            StructurallyRelateAliases::No,
-            param_env,
-            lhs,
-            variance,
-            rhs,
-            span,
-            false,
-        )?;
-        Ok(goals)
+        let mut relate =
+            SolverRelating::new(self, StructurallyRelateAliases::No, variance, param_env, span);
+        relate.relate(lhs, rhs)?;
+        Ok(relate.goals)
     }
 
     fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
@@ -132,70 +61,15 @@ impl<Infcx: InferCtxtLike> RelateExt for Infcx {
         Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
         TypeError<Self::Interner>,
     > {
-        let (goals, _) = relate_with_options(
+        let mut relate = SolverRelating::new(
             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,
-            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()))
+        );
+        relate.relate(lhs, rhs)?;
+        Ok(relate.goals)
     }
 }
 
@@ -209,7 +83,6 @@ 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.
@@ -246,17 +119,6 @@ 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,
@@ -265,7 +127,6 @@ where
             ambient_variance,
             param_env,
             goals: vec![],
-            region_constraints,
             cache: Default::default(),
         }
     }
@@ -394,42 +255,43 @@ where
 
     #[instrument(skip(self), level = "trace")]
     fn regions(&mut self, a: I::Region, b: I::Region) -> RelateResult<I, I::Region> {
-        match self.ambient_variance {
-            // Subtype(&'a u8, &'b u8) => Outlives('a: 'b) => SubRegion('b, 'a)
-            ty::Covariant => self.infcx.sub_regions(b, a, VisibleForLeakCheck::Yes, self.span),
-            // Suptype(&'a u8, &'b u8) => Outlives('b: 'a) => SubRegion('a, 'b)
-            ty::Contravariant => self.infcx.sub_regions(a, b, VisibleForLeakCheck::Yes, self.span),
-            ty::Invariant => self.infcx.equate_regions(a, b, VisibleForLeakCheck::Yes, self.span),
-            ty::Bivariant => {
-                unreachable!("Expected bivariance to be handled in relate_with_variance")
-            }
-        }
-
-        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 self.cx().assumptions_on_binders() {
             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")
-                    }
+            }
+
+            match self.ambient_variance {
+                ty::Covariant => {
+                    self.infcx
+                        .register_solver_region_constraint(RegionConstraint::RegionOutlives(a, b));
+                }
+                ty::Contravariant => {
+                    self.infcx
+                        .register_solver_region_constraint(RegionConstraint::RegionOutlives(b, a));
+                }
+                ty::Invariant => {
+                    self.infcx
+                        .register_solver_region_constraint(RegionConstraint::RegionOutlives(a, b));
+                    self.infcx
+                        .register_solver_region_constraint(RegionConstraint::RegionOutlives(b, a));
+                }
+                ty::Bivariant => {
+                    unreachable!("Expected bivariance to be handled in relate_with_variance")
+                }
+            }
+        } else {
+            match self.ambient_variance {
+                // Subtype(&'a u8, &'b u8) => Outlives('a: 'b) => SubRegion('b, 'a)
+                ty::Covariant => self.infcx.sub_regions(b, a, VisibleForLeakCheck::Yes, self.span),
+                // Suptype(&'a u8, &'b u8) => Outlives('b: 'a) => SubRegion('a, 'b)
+                ty::Contravariant => {
+                    self.infcx.sub_regions(a, b, VisibleForLeakCheck::Yes, self.span)
+                }
+                ty::Invariant => {
+                    self.infcx.equate_regions(a, b, VisibleForLeakCheck::Yes, self.span)
+                }
+                ty::Bivariant => {
+                    unreachable!("Expected bivariance to be handled in relate_with_variance")
                 }
             }
         }