Struct rustc_infer::infer::combine::Generalizer
source · struct Generalizer<'cx, 'tcx> {
infcx: &'cx InferCtxt<'cx, 'tcx>,
cause: &'cx ObligationCause<'tcx>,
for_vid_sub_root: TyVid,
for_universe: UniverseIndex,
ambient_variance: Variance,
needs_wf: bool,
root_ty: Ty<'tcx>,
param_env: ParamEnv<'tcx>,
cache: SsoHashMap<Ty<'tcx>, Ty<'tcx>>,
}
Fields
infcx: &'cx InferCtxt<'cx, 'tcx>
cause: &'cx ObligationCause<'tcx>
The span, used when creating new type variables and things.
for_vid_sub_root: TyVid
The vid of the type variable that is in the process of being instantiated; if we find this within the type we are folding, that means we would have created a cyclic type.
for_universe: UniverseIndex
The universe of the type variable that is in the process of being instantiated. Any fresh variables that we create in this process should be in that same universe.
ambient_variance: Variance
Track the variance as we descend into the type.
needs_wf: bool
See the field needs_wf
in Generalization
.
root_ty: Ty<'tcx>
The root type that we are generalizing. Used when reporting cycles.
param_env: ParamEnv<'tcx>
cache: SsoHashMap<Ty<'tcx>, Ty<'tcx>>
Trait Implementations
sourceimpl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx>
impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx>
fn tcx(&self) -> TyCtxt<'tcx>
fn param_env(&self) -> ParamEnv<'tcx>
sourcefn 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. Read morefn binders<T>(
&mut self,
a: Binder<'tcx, T>,
b: Binder<'tcx, T>
) -> RelateResult<'tcx, Binder<'tcx, T>>where
T: Relate<'tcx>,
sourcefn relate_item_substs(
&mut self,
item_def_id: DefId,
a_subst: SubstsRef<'tcx>,
b_subst: SubstsRef<'tcx>
) -> RelateResult<'tcx, SubstsRef<'tcx>>
fn relate_item_substs(
&mut self,
item_def_id: DefId,
a_subst: SubstsRef<'tcx>,
b_subst: SubstsRef<'tcx>
) -> RelateResult<'tcx, SubstsRef<'tcx>>
sourcefn 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, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>>
fn regions(
&mut self,
r: Region<'tcx>,
r2: Region<'tcx>
) -> RelateResult<'tcx, Region<'tcx>>
fn consts(
&mut self,
c: Const<'tcx>,
c2: Const<'tcx>
) -> RelateResult<'tcx, Const<'tcx>>
fn with_cause<F, R>(&mut self, _cause: Cause, f: F) -> Rwhere
F: FnOnce(&mut Self) -> R,
Auto Trait Implementations
impl<'cx, 'tcx> !RefUnwindSafe for Generalizer<'cx, 'tcx>
impl<'cx, 'tcx> !Send for Generalizer<'cx, 'tcx>
impl<'cx, 'tcx> !Sync for Generalizer<'cx, 'tcx>
impl<'cx, 'tcx> Unpin for Generalizer<'cx, 'tcx>where
'tcx: 'cx,
impl<'cx, 'tcx> !UnwindSafe for Generalizer<'cx, 'tcx>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
Layout
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.
Size: 192 bytes