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

Use SolverRelating in new solver

Browse Source
This commit is contained in:
Michael Goulet 2024-08-06 12:50:18 -04:00
parent efb1c23ff6
commit 3da257a98d
9 changed files with 68 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -208,49 +208,6 @@ pub fn relate<T>(
}
}
/// Used in the new solver since we don't care about tracking an `ObligationCause`.
pub fn relate_no_trace<T>(
self,
expected: T,
variance: ty::Variance,
actual: T,
) -> Result<Vec<Goal<'tcx, ty::Predicate<'tcx>>>, NoSolution>
where
T: Relate<TyCtxt<'tcx>>,
{
let mut 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`.
pub fn eq_structurally_relating_aliases_no_trace<T>(
self,
expected: T,
actual: T,
) -> Result<Vec<Goal<'tcx, ty::Predicate<'tcx>>>, NoSolution>
where
T: Relate<TyCtxt<'tcx>>,
{
let mut 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

24
compiler/rustc_infer/src/infer/context.rs
View File

@ -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 @@ fn set_tainted_by_errors(&self, e: ErrorGuaranteed) {
self.set_tainted_by_errors(e)
}
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)
}

6
compiler/rustc_infer/src/infer/mod.rs
View File

@ -32,7 +32,6 @@
use rustc_middle::mir::ConstraintCategory;
use rustc_middle::mir::interpret::{ErrorHandled, EvalToValTreeResult};
use rustc_middle::traits::select;
use rustc_middle::traits::solve::{Goal, NoSolution};
pub use 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 @@ pub fn consts(
values: ValuePairs::Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())),
}
}
fn dummy(cause: &ObligationCause<'tcx>) -> TypeTrace<'tcx> {
TypeTrace { cause: cause.clone(), values: ValuePairs::Dummy }
}
}
impl<'tcx> SubregionOrigin<'tcx> {

1
compiler/rustc_infer/src/infer/relate/mod.rs
View File

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

1
compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
View File

@ -14,6 +14,7 @@
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::{self as ty, Canonical, CanonicalVarValues, InferCtxtLike, Interner};
use tracing::{instrument, trace};

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

@ -7,6 +7,7 @@
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::{self as ty, CanonicalVarValues, InferCtxtLike, Interner};
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};

6
compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
View File

@ -1285,9 +1285,6 @@ enum Mismatch<'a> {
ValuePairs::ExistentialProjection(_) => {
(false, Mismatch::Fixed("existential projection"))
}
ValuePairs::Dummy => {
bug!("do not expect to report a type error from a ValuePairs::Dummy")
}
};
let Some(vals) = self.values_str(values) else {
// Derived error. Cancel the emitter.
@ -1853,9 +1850,6 @@ fn values_str(
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")
}
}
}

19
compiler/rustc_type_ir/src/infer_ctxt.rs
View File

@ -1,7 +1,7 @@
use crate::fold::TypeFoldable;
use crate::relate::RelateResult;
use crate::relate::combine::PredicateEmittingRelation;
use crate::relate::{Relate, RelateResult};
use crate::solve::{Goal, NoSolution, SolverMode};
use crate::solve::SolverMode;
use crate::{self as ty, Interner};
pub trait InferCtxtLike: Sized {
@ -98,21 +98,6 @@ fn instantiate_const_var_raw<R: PredicateEmittingRelation<Self>>(
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,

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

@ -1,12 +1,57 @@
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::{InferCtxtCombineExt, PredicateEmittingRelation};
use crate::data_structures::DelayedSet;
#[allow(unused)]
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)
}
}
/// Enforce that `a` is equal to or a subtype of `b`.
pub struct SolverRelating<'infcx, Infcx, I: Interner> {
infcx: &'infcx Infcx,
@ -46,6 +91,21 @@ impl<'infcx, Infcx, I> SolverRelating<'infcx, Infcx, I>
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![],
cache: Default::default(),
}
}
}
impl<Infcx, I> TypeRelation<I> for SolverRelating<'_, Infcx, I>