Struct rustc_borrowck::type_check::relate_tys::NllTypeRelatingDelegate

struct NllTypeRelatingDelegate<'me, 'bccx, 'tcx> {
    type_checker: &'me mut TypeChecker<'bccx, 'tcx>,
    locations: Locations,
    category: ConstraintCategory<'tcx>,
    universe_info: UniverseInfo<'tcx>,
}

Fields

type_checker: &'me mut TypeChecker<'bccx, 'tcx>

locations: Locations

Where (and why) is this relation taking place?

category: ConstraintCategory<'tcx>

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

universe_info: UniverseInfo<'tcx>

Information so that error reporting knows what types we are relating when reporting a bound region error.

Implementations

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

fn new(
    type_checker: &'me mut TypeChecker<'bccx, 'tcx>,
    locations: Locations,
    category: ConstraintCategory<'tcx>,
    universe_info: UniverseInfo<'tcx>
) -> Self

Trait Implementations

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

fn span(&self) -> Span

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>,
    info: VarianceDiagInfo<'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: Const<'tcx>, _b: 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.

fn register_opaque_type(
    &mut self,
    a: Ty<'tcx>,
    b: Ty<'tcx>,
    a_is_expected: bool
) -> Result<(), TypeError<'tcx>>

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: 72 bytes