Struct rustc_infer::infer::relate::nll::TypeRelating

pub struct TypeRelating<'me, 'tcx, D>
where
    D: TypeRelatingDelegate<'tcx>,
{
    infcx: &'me InferCtxt<'tcx>,
    delegate: D,
    ambient_variance: Variance,
    ambient_variance_info: VarianceDiagInfo<'tcx>,
}

Fields

infcx: &'me InferCtxt<'tcx>

delegate: D

Callback to use when we deduce an outlives relationship.

ambient_variance: Variance

How are we relating a and b?

• Covariant means a <: b.
• Contravariant means b <: a.
• Invariant means a == b.
• Bivariant means that it doesn’t matter.

ambient_variance_info: VarianceDiagInfo<'tcx>

Implementations

impl<'me, 'tcx, D> TypeRelating<'me, 'tcx, D>

where D: TypeRelatingDelegate<'tcx>,

pub fn new( infcx: &'me InferCtxt<'tcx>, delegate: D, ambient_variance: Variance ) -> Self

fn ambient_covariance(&self) -> bool

fn ambient_contravariance(&self) -> bool

fn push_outlives( &mut self, sup: Region<'tcx>, sub: Region<'tcx>, info: VarianceDiagInfo<'tcx> )

Push a new outlives requirement into our output set of constraints.

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

fn enter_forall<T, U>( &mut self, binder: Binder<'tcx, T>, f: impl FnOnce(&mut Self, T) -> U ) -> U

where T: TypeFoldable<TyCtxt<'tcx>> + Copy,

fn instantiate_binder_with_existentials<T>( &mut self, binder: Binder<'tcx, T> ) -> T

where T: TypeFoldable<TyCtxt<'tcx>> + Copy,

Trait Implementations

impl<'tcx, D> ObligationEmittingRelation<'tcx> for TypeRelating<'_, 'tcx, D>

where D: TypeRelatingDelegate<'tcx>,

fn span(&self) -> Span

fn param_env(&self) -> ParamEnv<'tcx>

fn register_predicates( &mut self, obligations: impl IntoIterator<Item: ToPredicate<'tcx>> )

Register predicates that must hold in order for this relation to hold. Uses a default obligation cause, ObligationEmittingRelation::register_obligations should be used if control over the obligation causes is required.

fn register_obligations(&mut self, obligations: PredicateObligations<'tcx>)

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

fn alias_relate_direction(&self) -> AliasRelationDirection

Relation direction emitted for AliasRelate predicates, corresponding to the direction of the relation.

fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>)

Register an obligation that both types must be related to each other according to the ty::AliasRelationDirection given by ObligationEmittingRelation::alias_relate_direction

impl<'tcx, D> TypeRelation<'tcx> for TypeRelating<'_, 'tcx, D>

where D: TypeRelatingDelegate<'tcx>,

fn tcx(&self) -> TyCtxt<'tcx>

fn tag(&self) -> &'static str

Returns a static string we can use for printouts.

fn a_is_expected(&self) -> bool

Returns true if the value a is the “expected” type in the relation. Just affects error messages.

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

Switch variance for the purpose of relating a and b.

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

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

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

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

where T: Relate<'tcx>,

fn with_cause<F, R>(&mut self, _cause: Cause, f: F) -> R

where F: FnOnce(&mut Self) -> R,

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

where T: Relate<'tcx>,

Generic relation routine suitable for most anything.

fn relate_item_args( &mut self, item_def_id: DefId, a_arg: &'tcx List<GenericArg<'tcx>>, b_arg: &'tcx List<GenericArg<'tcx>> ) -> Result<&'tcx List<GenericArg<'tcx>>, TypeError<'tcx>>

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

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.