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§

source§

impl<'me, 'tcx, D> TypeRelating<'me, 'tcx, D>where D: TypeRelatingDelegate<'tcx>,

source

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

source

fn ambient_covariance(&self) -> bool

source

fn ambient_contravariance(&self) -> bool

source

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.

source

fn relate_ty_var<PAIR: VidValuePair<'tcx>>( &mut self, pair: PAIR ) -> RelateResult<'tcx, Ty<'tcx>>

Relate a type inference variable with a value type. This works by creating a “generalization” G of the value where all the lifetimes are replaced with fresh inference values. This generalization G becomes the value of the inference variable, and is then related in turn to the value. So e.g. if you had vid = ?0 and value = &'a u32, we might first instantiate ?0 to a type like &'0 u32 where '0 is a fresh variable, and then relate &'0 u32 with &'a u32 (resulting in relations between '0 and 'a).

The variable pair can be either a (vid, ty) or (ty, vid) – in other words, it is always an (unresolved) inference variable vid and a type ty that are being related, but the vid may appear either as the “a” type or the “b” type, depending on where it appears in the tuple. The trait VidValuePair lets us work with the vid/type while preserving the “sidedness” when necessary – the sidedness is relevant in particular for the variance and set of in-scope things.

source

fn generalize( &mut self, ty: Ty<'tcx>, for_vid: TyVid ) -> RelateResult<'tcx, Ty<'tcx>>

source

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

source

fn instantiate_binder_with_placeholders<T>( &mut self, binder: Binder<'tcx, T> ) -> Twhere T: TypeFoldable<TyCtxt<'tcx>> + Copy,

source

fn instantiate_binder_with_existentials<T>( &mut self, binder: Binder<'tcx, T> ) -> Twhere T: TypeFoldable<TyCtxt<'tcx>> + Copy,

Trait Implementations§

source§

impl<'tcx, D> ObligationEmittingRelation<'tcx> for TypeRelating<'_, 'tcx, D>where D: TypeRelatingDelegate<'tcx>,

source§

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.
source§

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

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

fn alias_relate_direction(&self) -> AliasRelationDirection

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

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
source§

impl<'tcx, D> TypeRelation<'tcx> for TypeRelating<'_, 'tcx, D>where D: TypeRelatingDelegate<'tcx>,

source§

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

source§

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

source§

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

Returns a static string we can use for printouts.
source§

fn a_is_expected(&self) -> bool

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

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.
source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Generic relation routine suitable for most anything.
source§

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.

Auto Trait Implementations§

§

impl<'me, 'tcx, D> !RefUnwindSafe for TypeRelating<'me, 'tcx, D>

§

impl<'me, 'tcx, D> !Send for TypeRelating<'me, 'tcx, D>

§

impl<'me, 'tcx, D> !Sync for TypeRelating<'me, 'tcx, D>

§

impl<'me, 'tcx, D> Unpin for TypeRelating<'me, 'tcx, D>where D: Unpin,

§

impl<'me, 'tcx, D> !UnwindSafe for TypeRelating<'me, 'tcx, D>

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

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.