Use SolverRelating in new solver

Author: compiler-errors

compiler/rustc_infer/src/infer/context.rs

@@ -1,13 +1,12 @@
 ///! Definition of `InferCtxtLike` from the librarified type layer.
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::infer::unify_key::EffectVarValue;
-use rustc_middle::traits::solve::{Goal, NoSolution, SolverMode};
+use rustc_middle::traits::solve::SolverMode;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::fold::TypeFoldable;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::{ErrorGuaranteed, DUMMY_SP};
 use rustc_type_ir::relate::combine::PredicateEmittingRelation;
-use rustc_type_ir::relate::Relate;
 use rustc_type_ir::InferCtxtLike;
 
 use super::{BoundRegionConversionTime, InferCtxt, SubregionOrigin};
@@ -134,26 +133,6 @@ impl<'tcx> InferCtxtLike for InferCtxt<'tcx> {
         self.enter_forall(value, f)
     }
 
-    fn relate<T: Relate<TyCtxt<'tcx>>>(
-        &self,
-        param_env: ty::ParamEnv<'tcx>,
-        lhs: T,
-        variance: ty::Variance,
-        rhs: T,
-    ) -> Result<Vec<Goal<'tcx, ty::Predicate<'tcx>>>, NoSolution> {
-        self.at(&ObligationCause::dummy(), param_env).relate_no_trace(lhs, variance, rhs)
-    }
-
-    fn eq_structurally_relating_aliases<T: Relate<TyCtxt<'tcx>>>(
-        &self,
-        param_env: ty::ParamEnv<'tcx>,
-        lhs: T,
-        rhs: T,
-    ) -> Result<Vec<Goal<'tcx, ty::Predicate<'tcx>>>, NoSolution> {
-        self.at(&ObligationCause::dummy(), param_env)
-            .eq_structurally_relating_aliases_no_trace(lhs, rhs)
-    }
-
     fn shallow_resolve(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
         self.shallow_resolve(ty)
     }

compiler/rustc_next_trait_solver/src/relate.rs

@@ -1,12 +1,58 @@
 use rustc_type_ir::error::{ExpectedFound, TypeError};
 use rustc_type_ir::inherent::*;
 pub use rustc_type_ir::relate::*;
-use rustc_type_ir::solve::Goal;
+use rustc_type_ir::solve::{Goal, NoSolution};
 use rustc_type_ir::{self as ty, InferCtxtLike, Interner};
 use tracing::{debug, instrument};
 
 use self::combine::PredicateEmittingRelation;
 
+pub trait RelateExt: InferCtxtLike {
+    fn relate<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        variance: ty::Variance,
+        rhs: T,
+    ) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>;
+
+    fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        rhs: T,
+    ) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>;
+}
+
+impl<Infcx: InferCtxtLike> RelateExt for Infcx {
+    fn relate<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        variance: ty::Variance,
+        rhs: T,
+    ) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>
+    {
+        let mut relate =
+            SolverRelating::new(self, StructurallyRelateAliases::No, variance, param_env);
+        relate.relate(lhs, rhs)?;
+        Ok(relate.goals)
+    }
+
+    fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
+        &self,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        lhs: T,
+        rhs: T,
+    ) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>
+    {
+        let mut relate =
+            SolverRelating::new(self, StructurallyRelateAliases::Yes, ty::Invariant, param_env);
+        relate.relate(lhs, rhs)?;
+        Ok(relate.goals)
+    }
+}
+
 #[allow(unused)]
 /// Enforce that `a` is equal to or a subtype of `b`.
 pub struct SolverRelating<'infcx, Infcx, I: Interner> {
@@ -22,6 +68,20 @@ where
     Infcx: InferCtxtLike<Interner = I>,
     I: Interner,
 {
+    fn new(
+        infcx: &'infcx Infcx,
+        structurally_relate_aliases: StructurallyRelateAliases,
+        ambient_variance: ty::Variance,
+        param_env: I::ParamEnv,
+    ) -> Self {
+        SolverRelating {
+            infcx,
+            structurally_relate_aliases,
+            ambient_variance,
+            param_env,
+            goals: vec![],
+        }
+    }
 }
 
 impl<Infcx, I> TypeRelation<I> for SolverRelating<'_, Infcx, I>

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

@@ -19,6 +19,7 @@ use tracing::{instrument, trace};
 
 use crate::canonicalizer::{CanonicalizeMode, Canonicalizer};
 use crate::delegate::SolverDelegate;
+use crate::relate::RelateExt;
 use crate::resolve::EagerResolver;
 use crate::solve::eval_ctxt::NestedGoals;
 use crate::solve::{

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

@@ -14,6 +14,7 @@ use tracing::{instrument, trace};
 
 use crate::coherence;
 use crate::delegate::SolverDelegate;
+use crate::relate::RelateExt;
 use crate::solve::inspect::{self, ProofTreeBuilder};
 use crate::solve::search_graph::SearchGraph;
 use crate::solve::{

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -1,7 +1,7 @@
 use crate::fold::TypeFoldable;
 use crate::relate::combine::PredicateEmittingRelation;
-use crate::relate::{Relate, RelateResult};
-use crate::solve::{Goal, NoSolution, SolverMode};
+use crate::relate::RelateResult;
+use crate::solve::SolverMode;
 use crate::{self as ty, Interner};
 
 pub trait InferCtxtLike: Sized {
@@ -90,21 +90,6 @@ pub trait InferCtxtLike: Sized {
 
     fn set_tainted_by_errors(&self, e: <Self::Interner as Interner>::ErrorGuaranteed);
 
-    fn relate<T: Relate<Self::Interner>>(
-        &self,
-        param_env: <Self::Interner as Interner>::ParamEnv,
-        lhs: T,
-        variance: ty::Variance,
-        rhs: T,
-    ) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>;
-
-    fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
-        &self,
-        param_env: <Self::Interner as Interner>::ParamEnv,
-        lhs: T,
-        rhs: T,
-    ) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>;
-
     fn shallow_resolve(
         &self,
         ty: <Self::Interner as Interner>::Ty,