Struct rustc_infer::infer::combine::Generalizer

pub(in infer::combine) 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>, RelateResult<'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>, RelateResult<'tcx, Ty<'tcx>>>

Trait Implementations

impl<'tcx, '_> TypeRelation<'tcx> for Generalizer<'_, 'tcx>

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

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

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

Returns a static string we can use for printouts.

pub fn a_is_expected(&self) -> bool

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

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

pub fn relate_item_substs(
    &mut self,
    item_def_id: DefId,
    a_subst: SubstsRef<'tcx>,
    b_subst: SubstsRef<'tcx>
) -> RelateResult<'tcx, SubstsRef<'tcx>>

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

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

Switch variance for the purpose of relating a and b.

pub fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>>

pub fn regions(
    &mut self,
    r: Region<'tcx>,
    r2: Region<'tcx>
) -> RelateResult<'tcx, Region<'tcx>>

pub fn consts(
    &mut self,
    c: &'tcx Const<'tcx>,
    c2: &'tcx Const<'tcx>
) -> RelateResult<'tcx, &'tcx Const<'tcx>>

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

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

Generic relation routine suitable for most anything.