mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use SolverRelating in favor of TypeRelating in the old solver where possible

Browse Source
This commit is contained in:
Michael Goulet 2024-10-04 13:30:51 -04:00
parent 30a2ecddb4
commit a4cd2202ef
4 changed files with 92 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
compiler/rustc_infer/src/infer/at.rs
View File

@ -27,11 +27,14 @@
use relate::lattice::{LatticeOp, LatticeOpKind};
use rustc_middle::bug;
use rustc_middle::ty::relate::solver_relating::RelateExt as NextSolverRelate;
use rustc_middle::ty::{Const, ImplSubject};
use super::*;
use crate::infer::relate::type_relating::TypeRelating;
use crate::infer::relate::{Relate, TypeRelation};
use crate::traits::Obligation;
use crate::traits::solve::Goal;
/// Whether we should define opaque types or just treat them opaquely.
///
@ -109,15 +112,26 @@ pub fn sup<T>(
where
T: ToTrace<'tcx>,
{
let mut op = TypeRelating::new(
self.infcx,
ToTrace::to_trace(self.cause, expected, actual),
self.param_env,
define_opaque_types,
ty::Contravariant,
);
op.relate(expected, actual)?;
Ok(InferOk { value: (), obligations: op.into_obligations() })
if self.infcx.next_trait_solver {
NextSolverRelate::relate(
self.infcx,
self.param_env,
expected,
ty::Contravariant,
actual,
)
.map(|goals| self.goals_to_obligations(goals))
} else {
let mut op = TypeRelating::new(
self.infcx,
ToTrace::to_trace(self.cause, expected, actual),
self.param_env,
define_opaque_types,
ty::Contravariant,
);
op.relate(expected, actual)?;
Ok(InferOk { value: (), obligations: op.into_obligations() })
}
}
/// Makes `expected <: actual`.
@ -130,15 +144,20 @@ pub fn sub<T>(
where
T: ToTrace<'tcx>,
{
let mut op = TypeRelating::new(
self.infcx,
ToTrace::to_trace(self.cause, expected, actual),
self.param_env,
define_opaque_types,
ty::Covariant,
);
op.relate(expected, actual)?;
Ok(InferOk { value: (), obligations: op.into_obligations() })
if self.infcx.next_trait_solver {
NextSolverRelate::relate(self.infcx, self.param_env, expected, ty::Covariant, actual)
.map(|goals| self.goals_to_obligations(goals))
} else {
let mut op = TypeRelating::new(
self.infcx,
ToTrace::to_trace(self.cause, expected, actual),
self.param_env,
define_opaque_types,
ty::Covariant,
);
op.relate(expected, actual)?;
Ok(InferOk { value: (), obligations: op.into_obligations() })
}
}
/// Makes `expected == actual`.
@ -170,15 +189,20 @@ pub fn eq_trace<T>(
where
T: Relate<TyCtxt<'tcx>>,
{
let mut op = TypeRelating::new(
self.infcx,
trace,
self.param_env,
define_opaque_types,
ty::Invariant,
);
op.relate(expected, actual)?;
Ok(InferOk { value: (), obligations: op.into_obligations() })
if self.infcx.next_trait_solver {
NextSolverRelate::relate(self.infcx, self.param_env, expected, ty::Invariant, actual)
.map(|goals| self.goals_to_obligations(goals))
} else {
let mut op = TypeRelating::new(
self.infcx,
trace,
self.param_env,
define_opaque_types,
ty::Invariant,
);
op.relate(expected, actual)?;
Ok(InferOk { value: (), obligations: op.into_obligations() })
}
}
pub fn relate<T>(
@ -223,6 +247,26 @@ pub fn lub<T>(self, expected: T, actual: T) -> InferResult<'tcx, T>
let value = op.relate(expected, actual)?;
Ok(InferOk { value, obligations: op.into_obligations() })
}
fn goals_to_obligations(
&self,
goals: Vec<Goal<'tcx, ty::Predicate<'tcx>>>,
) -> InferOk<'tcx, ()> {
InferOk {
value: (),
obligations: goals
.into_iter()
.map(|goal| {
Obligation::new(
self.infcx.tcx,
self.cause.clone(),
goal.param_env,
goal.predicate,
)
})
.collect(),
}
}
}
impl<'tcx> ToTrace<'tcx> for ImplSubject<'tcx> {

5
compiler/rustc_infer/src/infer/relate/type_relating.rs
View File

@ -58,6 +58,7 @@ pub(crate) fn new(
define_opaque_types: DefineOpaqueTypes,
ambient_variance: ty::Variance,
) -> TypeRelating<'infcx, 'tcx> {
assert!(!infcx.next_trait_solver);
TypeRelating {
infcx,
trace,
@ -190,9 +191,7 @@ fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
(&ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }), _)
| (_, &ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }))
if self.define_opaque_types == DefineOpaqueTypes::Yes
&& def_id.is_local()
&& !infcx.next_trait_solver() =>
if self.define_opaque_types == DefineOpaqueTypes::Yes && def_id.is_local() =>
{
self.register_goals(infcx.handle_opaque_type(
a,

2
compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
View File

@ -836,7 +836,7 @@ pub(super) fn eq_and_get_goals<T: Relate<I>>(
lhs: T,
rhs: T,
) -> Result<Vec<Goal<I, I::Predicate>>, NoSolution> {
self.delegate.relate(param_env, lhs, ty::Variance::Invariant, rhs)
Ok(self.delegate.relate(param_env, lhs, ty::Variance::Invariant, rhs)?)
}
pub(super) fn instantiate_binder_with_infer<T: TypeFoldable<I> + Copy>(

26
compiler/rustc_type_ir/src/relate/solver_relating.rs
View File

@ -1,5 +1,5 @@
pub use rustc_type_ir::relate::*;
use rustc_type_ir::solve::{Goal, NoSolution};
use rustc_type_ir::solve::Goal;
use rustc_type_ir::{self as ty, InferCtxtLike, Interner};
use tracing::{debug, instrument};
@ -13,14 +13,20 @@ fn relate<T: Relate<Self::Interner>>(
lhs: T,
variance: ty::Variance,
rhs: T,
) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>;
) -> Result<
Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
TypeError<Self::Interner>,
>;
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>;
) -> Result<
Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
TypeError<Self::Interner>,
>;
}
impl<Infcx: InferCtxtLike> RelateExt for Infcx {
@ -30,8 +36,10 @@ fn relate<T: Relate<Self::Interner>>(
lhs: T,
variance: ty::Variance,
rhs: T,
) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>
{
) -> Result<
Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
TypeError<Self::Interner>,
> {
let mut relate =
SolverRelating::new(self, StructurallyRelateAliases::No, variance, param_env);
relate.relate(lhs, rhs)?;
@ -43,8 +51,10 @@ fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
param_env: <Self::Interner as Interner>::ParamEnv,
lhs: T,
rhs: T,
) -> Result<Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>, NoSolution>
{
) -> Result<
Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
TypeError<Self::Interner>,
> {
let mut relate =
SolverRelating::new(self, StructurallyRelateAliases::Yes, ty::Invariant, param_env);
relate.relate(lhs, rhs)?;
@ -91,7 +101,7 @@ impl<'infcx, Infcx, I> SolverRelating<'infcx, Infcx, I>
Infcx: InferCtxtLike<Interner = I>,
I: Interner,
{
fn new(
pub fn new(
infcx: &'infcx Infcx,
structurally_relate_aliases: StructurallyRelateAliases,
ambient_variance: ty::Variance,