Struct SolverRelating

pub struct SolverRelating<'infcx, Infcx, I>
where
    I: Interner,
{
    infcx: &'infcx Infcx,
    structurally_relate_aliases: StructurallyRelateAliases,
    param_env: <I as Interner>::ParamEnv,
    ambient_variance: Variance,
    goals: Vec<Goal<I, <I as Interner>::Predicate>>,
    cache: DelayedSet<(Variance, <I as Interner>::Ty, <I as Interner>::Ty)>,
}

Enforce that a is equal to or a subtype of b.

Fields

infcx: &'infcx Infcx

structurally_relate_aliases: StructurallyRelateAliases

param_env: <I as Interner>::ParamEnv

ambient_variance: Variance

goals: Vec<Goal<I, <I as Interner>::Predicate>>

cache: DelayedSet<(Variance, <I as Interner>::Ty, <I as Interner>::Ty)>

Implementations

impl<'infcx, Infcx, I> SolverRelating<'infcx, Infcx, I>

where Infcx: InferCtxtLike<Interner = I>, I: Interner,

pub fn new( infcx: &'infcx Infcx, structurally_relate_aliases: StructurallyRelateAliases, ambient_variance: Variance, param_env: <I as Interner>::ParamEnv, ) -> SolverRelating<'infcx, Infcx, I>

Trait Implementations

impl<Infcx, I> PredicateEmittingRelation<Infcx> for SolverRelating<'_, Infcx, I>

where Infcx: InferCtxtLike<Interner = I>, I: Interner,

fn span(&self) -> <I as Interner>::Span

fn param_env(&self) -> <I as Interner>::ParamEnv

fn structurally_relate_aliases(&self) -> StructurallyRelateAliases

Whether aliases should be related structurally. This is pretty much always No unless you’re equating in some specific locations of the new solver. See the comments in these use-cases for more details.

fn register_predicates( &mut self, obligations: impl IntoIterator>, )

where <impl IntoIterator as IntoIterator>::Item: Upcast<I, <I as Interner>::Predicate>,

Register predicates that must hold in order for this relation to hold. This uses the default param_env of the obligation.

fn register_goals( &mut self, obligations: impl IntoIterator<Item = Goal<I, <I as Interner>::Predicate>>, )

Register obligations that must hold in order for this relation to hold

fn register_alias_relate_predicate( &mut self, a: <I as Interner>::Ty, b: <I as Interner>::Ty, )

Register AliasRelate obligation(s) that both types must be related to each other.

impl<Infcx, I> TypeRelation<I> for SolverRelating<'_, Infcx, I>

where Infcx: InferCtxtLike<Interner = I>, I: Interner,

fn cx(&self) -> I

fn relate_item_args( &mut self, item_def_id: <I as Interner>::DefId, a_arg: <I as Interner>::GenericArgs, b_arg: <I as Interner>::GenericArgs, ) -> Result<<I as Interner>::GenericArgs, TypeError<I>>

Relate the two args for the given item. The default is to look up the variance for the item and proceed accordingly.

fn relate_with_variance<T>( &mut self, variance: Variance, _info: VarianceDiagInfo<I>, a: T, b: T, ) -> Result<T, TypeError<I>>

where T: Relate<I>,

Switch variance for the purpose of relating a and b.

fn tys( &mut self, a: <I as Interner>::Ty, b: <I as Interner>::Ty, ) -> Result<<I as Interner>::Ty, TypeError<I>>

fn regions( &mut self, a: <I as Interner>::Region, b: <I as Interner>::Region, ) -> Result<<I as Interner>::Region, TypeError<I>>

fn consts( &mut self, a: <I as Interner>::Const, b: <I as Interner>::Const, ) -> Result<<I as Interner>::Const, TypeError<I>>

fn binders<T>( &mut self, a: Binder<I, T>, b: Binder<I, T>, ) -> Result<Binder<I, T>, TypeError<I>>

where T: Relate<I>,

fn relate<T>(&mut self, a: T, b: T) -> Result<T, TypeError<I>>

where T: Relate<I>,

Generic relation routine suitable for most anything.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.