Struct rustc_infer::infer::combine::Generalizer

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>

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

fn param_env(&self) -> ParamEnv<'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 binders<T>(
    &mut self,
    a: Binder<'tcx, T>,
    b: Binder<'tcx, T>
) -> RelateResult<'tcx, Binder<'tcx, T>> where
    T: Relate<'tcx>, 

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.

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.

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: &'tcx Const<'tcx>,
    c2: &'tcx Const<'tcx>
) -> RelateResult<'tcx, &'tcx Const<'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.