Use SolverRelating in new solver

Author: compiler-errors

compiler/rustc_infer/src/infer/at.rs

@@ -208,49 +208,6 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 }
 }
 
-/// Used in the new solver since we don't care about tracking an `ObligationCause`.
-pubfnrelate_no_trace<T>(
-self,
-expected:T,
-variance: ty::Variance,
-actual:T,
-) -> Result<Vec<Goal<'tcx, ty::Predicate<'tcx>>>,NoSolution>
-where
-T:Relate<TyCtxt<'tcx>>,
-{
-letmut op = TypeRelating::new(
-self.infcx,
-TypeTrace::dummy(self.cause),
-self.param_env,
-DefineOpaqueTypes::Yes,
-StructurallyRelateAliases::No,
- variance,
-);
- op.relate(expected, actual)?;
-Ok(op.into_obligations().into_iter().map(|o| o.into()).collect())
-}
-
-/// Used in the new solver since we don't care about tracking an `ObligationCause`.
-pubfneq_structurally_relating_aliases_no_trace<T>(
-self,
-expected:T,
-actual:T,
-) -> Result<Vec<Goal<'tcx, ty::Predicate<'tcx>>>,NoSolution>
-where
-T:Relate<TyCtxt<'tcx>>,
-{
-letmut op = TypeRelating::new(
-self.infcx,
-TypeTrace::dummy(self.cause),
-self.param_env,
-DefineOpaqueTypes::Yes,
-StructurallyRelateAliases::Yes,
- ty::Invariant,
-);
- op.relate(expected, actual)?;
-Ok(op.into_obligations().into_iter().map(|o| o.into()).collect())
-}
-
 /// Computes the least-upper-bound, or mutual supertype, of two
 /// values. The order of the arguments doesn't matter, but since
 /// this can result in an error (e.g., if asked to compute LUB of

compiler/rustc_infer/src/infer/context.rs

@@ -2,10 +2,10 @@
 use rustc_hir::def_id::{DefId,LocalDefId};
 use rustc_middle::infer::unify_key::EffectVarValue;
 use rustc_middle::traits::ObligationCause;
-use rustc_middle::traits::solve::{Goal,NoSolution,SolverMode};
+use rustc_middle::traits::solve::SolverMode;
 use rustc_middle::ty::fold::TypeFoldable;
+use rustc_middle::ty::relate::RelateResult;
 use rustc_middle::ty::relate::combine::PredicateEmittingRelation;
-use rustc_middle::ty::relate::{Relate,RelateResult};
 use rustc_middle::ty::{self,Ty,TyCtxt};
 use rustc_span::{DUMMY_SP,ErrorGuaranteed};
 
@@ -210,26 +210,6 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
 self.set_tainted_by_errors(e)
 }
 
-fnrelate<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)
-}
-
-fneq_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)
-}
-
 fnshallow_resolve(&self,ty:Ty<'tcx>) -> Ty<'tcx>{
 self.shallow_resolve(ty)
 }

compiler/rustc_infer/src/infer/mod.rs

@@ -32,7 +32,6 @@ use rustc_middle::infer::unify_key::{
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::mir::interpret::{ErrorHandled,EvalToValTreeResult};
 use rustc_middle::traits::select;
-use rustc_middle::traits::solve::{Goal,NoSolution};
 pubuse rustc_middle::ty::IntVarValue;
 use rustc_middle::ty::error::{ExpectedFound,TypeError};
 use rustc_middle::ty::fold::{
@@ -340,7 +339,6 @@ pub enum ValuePairs<'tcx> {
 PolySigs(ExpectedFound<ty::PolyFnSig<'tcx>>),
 ExistentialTraitRef(ExpectedFound<ty::PolyExistentialTraitRef<'tcx>>),
 ExistentialProjection(ExpectedFound<ty::PolyExistentialProjection<'tcx>>),
-Dummy,
 }
 
 impl<'tcx>ValuePairs<'tcx>{
@@ -1638,10 +1636,6 @@ impl<'tcx> TypeTrace<'tcx> {
 values:ValuePairs::Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())),
 }
 }
-
-fndummy(cause:&ObligationCause<'tcx>) -> TypeTrace<'tcx>{
-TypeTrace{cause: cause.clone(),values:ValuePairs::Dummy}
-}
 }
 
 impl<'tcx>SubregionOrigin<'tcx>{

compiler/rustc_infer/src/infer/relate/mod.rs

@@ -6,7 +6,6 @@ pub use rustc_middle::ty::relate::RelateResult;
 pubuse rustc_type_ir::relate::combine::PredicateEmittingRelation;
 pubuse rustc_type_ir::relate::*;
 
-#[allow(hidden_glob_reexports)]
 mod generalize;
 mod higher_ranked;
 pub(super)mod lattice;

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

@@ -14,6 +14,7 @@ use std::iter;
 use rustc_index::IndexVec;
 use rustc_type_ir::fold::TypeFoldable;
 use rustc_type_ir::inherent::*;
+use rustc_type_ir::relate::solver_relating::RelateExt;
 use rustc_type_ir::{selfas ty,Canonical,CanonicalVarValues,InferCtxtLike,Interner};
 use tracing::{instrument, trace};
 

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

@@ -7,6 +7,7 @@ use rustc_type_ir::data_structures::{HashMap, HashSet, ensure_sufficient_stack};
 use rustc_type_ir::fold::{TypeFoldable,TypeFolder,TypeSuperFoldable};
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::Relate;
+use rustc_type_ir::relate::solver_relating::RelateExt;
 use rustc_type_ir::visit::{TypeSuperVisitable,TypeVisitable,TypeVisitableExt,TypeVisitor};
 use rustc_type_ir::{selfas ty,CanonicalVarValues,InferCtxtLike,Interner};
 use rustc_type_ir_macros::{Lift_Generic,TypeFoldable_Generic,TypeVisitable_Generic};

compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs

@@ -1285,9 +1285,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 ValuePairs::ExistentialProjection(_) => {
 (false,Mismatch::Fixed("existential projection"))
 }
-ValuePairs::Dummy => {
-bug!("do not expect to report a type error from a ValuePairs::Dummy")
-}
 };
 letSome(vals) = self.values_str(values)else{
 // Derived error. Cancel the emitter.
@@ -1853,9 +1850,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 let(exp, fnd) = self.cmp_fn_sig(&exp_found.expected,&exp_found.found);
 Some((exp, fnd,None))
 }
-ValuePairs::Dummy => {
-bug!("do not expect to report a type error from a ValuePairs::Dummy")
-}
 }
 }
 

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -1,7 +1,7 @@
 usecrate::fold::TypeFoldable;
+usecrate::relate::RelateResult;
 usecrate::relate::combine::PredicateEmittingRelation;
-usecrate::relate::{Relate,RelateResult};
-usecrate::solve::{Goal,NoSolution,SolverMode};
+usecrate::solve::SolverMode;
 usecrate::{selfas ty,Interner};
 
 pubtraitInferCtxtLike:Sized{
@@ -98,21 +98,6 @@ pub trait InferCtxtLike: Sized {
 
 fnset_tainted_by_errors(&self,e: <Self::InternerasInterner>::ErrorGuaranteed);
 
-fnrelate<T:Relate<Self::Interner>>(
-&self,
-param_env: <Self::InternerasInterner>::ParamEnv,
-lhs:T,
-variance: ty::Variance,
-rhs:T,
-) -> Result<Vec<Goal<Self::Interner, <Self::InternerasInterner>::Predicate>>,NoSolution>;
-
-fneq_structurally_relating_aliases<T:Relate<Self::Interner>>(
-&self,
-param_env: <Self::InternerasInterner>::ParamEnv,
-lhs:T,
-rhs:T,
-) -> Result<Vec<Goal<Self::Interner, <Self::InternerasInterner>::Predicate>>,NoSolution>;
-
 fnshallow_resolve(
 &self,
 ty: <Self::InternerasInterner>::Ty,

compiler/rustc_type_ir/src/relate/solver_relating.rs

@@ -1,12 +1,57 @@
 pubuse rustc_type_ir::relate::*;
-use rustc_type_ir::solve::Goal;
+use rustc_type_ir::solve::{Goal,NoSolution};
 use rustc_type_ir::{selfas ty,InferCtxtLike,Interner};
 use tracing::{debug, instrument};
 
 useself::combine::{InferCtxtCombineExt,PredicateEmittingRelation};
 usecrate::data_structures::DelayedSet;
 
-#[allow(unused)]
+pubtraitRelateExt:InferCtxtLike{
+fnrelate<T:Relate<Self::Interner>>(
+&self,
+param_env: <Self::InternerasInterner>::ParamEnv,
+lhs:T,
+variance: ty::Variance,
+rhs:T,
+) -> Result<Vec<Goal<Self::Interner, <Self::InternerasInterner>::Predicate>>,NoSolution>;
+
+fneq_structurally_relating_aliases<T:Relate<Self::Interner>>(
+&self,
+param_env: <Self::InternerasInterner>::ParamEnv,
+lhs:T,
+rhs:T,
+) -> Result<Vec<Goal<Self::Interner, <Self::InternerasInterner>::Predicate>>,NoSolution>;
+}
+
+impl<Infcx:InferCtxtLike>RelateExtforInfcx{
+fnrelate<T:Relate<Self::Interner>>(
+&self,
+param_env: <Self::InternerasInterner>::ParamEnv,
+lhs:T,
+variance: ty::Variance,
+rhs:T,
+) -> Result<Vec<Goal<Self::Interner, <Self::InternerasInterner>::Predicate>>,NoSolution>
+{
+letmut relate =
+SolverRelating::new(self,StructurallyRelateAliases::No, variance, param_env);
+ relate.relate(lhs, rhs)?;
+Ok(relate.goals)
+}
+
+fneq_structurally_relating_aliases<T:Relate<Self::Interner>>(
+&self,
+param_env: <Self::InternerasInterner>::ParamEnv,
+lhs:T,
+rhs:T,
+) -> Result<Vec<Goal<Self::Interner, <Self::InternerasInterner>::Predicate>>,NoSolution>
+{
+letmut relate =
+SolverRelating::new(self,StructurallyRelateAliases::Yes, ty::Invariant, param_env);
+ relate.relate(lhs, rhs)?;
+Ok(relate.goals)
+}
+}
+
 /// Enforce that `a` is equal to or a subtype of `b`.
 pubstructSolverRelating<'infcx,Infcx,I:Interner>{
 infcx:&'infcxInfcx,
@@ -46,6 +91,21 @@ where
 Infcx:InferCtxtLike<Interner = I>,
 I:Interner,
 {
+fnnew(
+infcx:&'infcxInfcx,
+structurally_relate_aliases:StructurallyRelateAliases,
+ambient_variance: ty::Variance,
+param_env:I::ParamEnv,
+) -> Self{
+SolverRelating{
+ infcx,
+ structurally_relate_aliases,
+ ambient_variance,
+ param_env,
+goals:vec![],
+cache:Default::default(),
+}
+}
 }
 
 impl<Infcx,I>TypeRelation<I>forSolverRelating<'_,Infcx,I>