Struct LatticeOp 

pub(crate) struct LatticeOp<'infcx, 'db> {
    infcx: &'infcx InferCtxt<'db>,
    trace: TypeTrace<'db>,
    param_env: ParamEnv<'db>,
    kind: LatticeOpKind,
    obligations: Vec<Obligation<'db, Predicate<'db>>>,
}

A greatest lower bound“ (common subtype) or least upper bound (common supertype).

Fields

infcx: &'infcx InferCtxt<'db>

trace: TypeTrace<'db>

param_env: ParamEnv<'db>

kind: LatticeOpKind

obligations: Vec<Obligation<'db, Predicate<'db>>>

Implementations

impl<'infcx, 'db> LatticeOp<'infcx, 'db>

pub(crate) fn new( infcx: &'infcx InferCtxt<'db>, trace: TypeTrace<'db>, param_env: ParamEnv<'db>, kind: LatticeOpKind, ) -> LatticeOp<'infcx, 'db>

pub(crate) fn into_obligations(self) -> Vec<Obligation<'db, Predicate<'db>>>

impl<'infcx, 'db> LatticeOp<'infcx, 'db>

fn relate_bound( &mut self, v: Ty<'db>, a: Ty<'db>, b: Ty<'db>, ) -> RelateResult<'db, ()>

Trait Implementations

impl<'db> PredicateEmittingRelation<InferCtxt<'db>> for LatticeOp<'_, 'db>

fn span(&self) -> Span

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 param_env(&self) -> ParamEnv<'db>

fn register_predicates( &mut self, preds: impl IntoIterator<Item: Upcast<DbInterner<'db>, Predicate<'db>>>, )

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, goals: impl IntoIterator<Item = Goal<'db, Predicate<'db>>>, )

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

fn register_alias_relate_predicate(&mut self, a: Ty<'db>, b: Ty<'db>)

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

impl<'db> TypeRelation<DbInterner<'db>> for LatticeOp<'_, 'db>

fn tys(&mut self, a: Ty<'db>, b: Ty<'db>) -> RelateResult<'db, Ty<'db>>

Relates two types using a given lattice.

fn cx(&self) -> DbInterner<'db>

fn relate_ty_args( &mut self, a_ty: Ty<'db>, b_ty: Ty<'db>, def_id: SolverDefId<'db>, a_args: GenericArgs<'db>, b_args: GenericArgs<'db>, mk: impl FnOnce(GenericArgs<'db>) -> Ty<'db>, ) -> RelateResult<'db, Ty<'db>>

fn relate_with_variance<T: Relate<DbInterner<'db>>>( &mut self, variance: Variance, _info: VarianceDiagInfo<DbInterner<'db>>, a: T, b: T, ) -> RelateResult<'db, T>

Switch variance for the purpose of relating a and b.

fn regions( &mut self, a: Region<'db>, b: Region<'db>, ) -> RelateResult<'db, Region<'db>>

fn consts( &mut self, a: Const<'db>, b: Const<'db>, ) -> RelateResult<'db, Const<'db>>

fn binders<T>( &mut self, a: Binder<'db, T>, b: Binder<'db, T>, ) -> RelateResult<'db, Binder<'db, T>>

where T: Relate<DbInterner<'db>>,

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

where T: Relate<I>,

Generic relation routine suitable for most anything.