Struct rustc_infer::infer::nll_relate::TypeRelating
source · 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>,
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
sourcefn push_outlives(
&mut self,
sup: Region<'tcx>,
sub: Region<'tcx>,
info: VarianceDiagInfo<'tcx>
)
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.
sourcefn relate_ty_var<PAIR: VidValuePair<'tcx>>(
&mut self,
pair: PAIR
) -> RelateResult<'tcx, Ty<'tcx>>
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.
fn generalize( &mut self, ty: Ty<'tcx>, for_vid: TyVid ) -> RelateResult<'tcx, Ty<'tcx>>
fn relate_opaques( &mut self, a: Ty<'tcx>, b: Ty<'tcx> ) -> RelateResult<'tcx, Ty<'tcx>>
fn instantiate_binder_with_placeholders<T>( &mut self, binder: Binder<'tcx, T> ) -> Twhere T: TypeFoldable<TyCtxt<'tcx>> + Copy,
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>,
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>>
)
fn register_predicates( &mut self, obligations: impl IntoIterator<Item: ToPredicate<'tcx>> )
ObligationEmittingRelation::register_obligations
should
be used if control over the obligation causes is required.source§fn register_obligations(&mut self, obligations: PredicateObligations<'tcx>)
fn register_obligations(&mut self, obligations: PredicateObligations<'tcx>)
source§fn alias_relate_direction(&self) -> AliasRelationDirection
fn alias_relate_direction(&self) -> AliasRelationDirection
AliasRelate
predicates, corresponding to the direction
of the relation.source§fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>)
fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>)
ty::AliasRelationDirection
given by ObligationEmittingRelation::alias_relate_direction
source§impl<'tcx, D> TypeRelation<'tcx> for TypeRelating<'_, 'tcx, D>where
D: TypeRelatingDelegate<'tcx>,
impl<'tcx, D> TypeRelation<'tcx> for TypeRelating<'_, 'tcx, D>where D: TypeRelatingDelegate<'tcx>,
fn tcx(&self) -> TyCtxt<'tcx>
fn param_env(&self) -> ParamEnv<'tcx>
source§fn a_is_expected(&self) -> bool
fn a_is_expected(&self) -> bool
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>
fn relate_with_variance<T: Relate<'tcx>>( &mut self, variance: Variance, info: VarianceDiagInfo<'tcx>, a: T, b: T ) -> RelateResult<'tcx, T>
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) -> Rwhere F: FnOnce(&mut Self) -> R,
source§fn relate<T>(&mut self, a: T, b: T) -> Result<T, TypeError<'tcx>>where
T: Relate<'tcx>,
fn relate<T>(&mut self, a: T, b: T) -> Result<T, TypeError<'tcx>>where T: Relate<'tcx>,
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>>
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>>
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> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
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.