Struct rustc_mir::borrow_check::type_check::relate_tys::NllTypeRelatingDelegate

struct NllTypeRelatingDelegate<'me, 'bccx, 'tcx> {
    infcx: &'me InferCtxt<'me, 'tcx>,
    borrowck_context: Option<&'me mut BorrowCheckContext<'bccx, 'tcx>>,
    param_env: ParamEnv<'tcx>,
    locations: Locations,
    category: ConstraintCategory,
}

Fields

infcx: &'me InferCtxt<'me, 'tcx>

borrowck_context: Option<&'me mut BorrowCheckContext<'bccx, 'tcx>>

param_env: ParamEnv<'tcx>

locations: Locations

Where (and why) is this relation taking place?

category: ConstraintCategory

What category do we assign the resulting 'a: 'b relationships?

Implementations

impl<'me, 'bccx, 'tcx> NllTypeRelatingDelegate<'me, 'bccx, 'tcx>

fn new(
    infcx: &'me InferCtxt<'me, 'tcx>,
    borrowck_context: Option<&'me mut BorrowCheckContext<'bccx, 'tcx>>,
    param_env: ParamEnv<'tcx>,
    locations: Locations,
    category: ConstraintCategory
) -> Self

Trait Implementations

impl<'tcx> TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx>

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

fn create_next_universe(&mut self) -> UniverseIndex

Creates a new universe index. Used when instantiating placeholders.

fn next_existential_region_var(&mut self, from_forall: bool) -> Region<'tcx>

Creates a new region variable representing a higher-ranked region that is instantiated existentially. This creates an inference variable, typically.

fn next_placeholder_region(
    &mut self,
    placeholder: PlaceholderRegion
) -> Region<'tcx>

Creates a new region variable representing a higher-ranked region that is instantiated universally. This creates a new region placeholder, typically.

fn generalize_existential(&mut self, universe: UniverseIndex) -> Region<'tcx>

Creates a new existential region in the given universe. This is used when handling subtyping and type variables – if we have that ?X <: Foo<'a>, for example, we would instantiate ?X with a type like Foo<'?0> where '?0 is a fresh existential variable created by this function. We would then relate Foo<'?0> with Foo<'a> (and probably add an outlives relation stating that '?0: 'a).

fn push_outlives(&mut self, sup: Region<'tcx>, sub: Region<'tcx>)

Push a constraint sup: sub – this constraint must be satisfied for the two types to be related. sub and sup may be regions from the type or new variables created through the delegate.

fn const_equate(&mut self, _a: &'tcx Const<'tcx>, _b: &'tcx Const<'tcx>)

fn normalization() -> NormalizationStrategy

Define the normalization strategy to use, eager or lazy.

fn forbid_inference_vars() -> bool

Enables some optimizations if we do not expect inference variables in the RHS of the relation.