Struct rustc_infer::infer::InferCtxtInner

pub struct InferCtxtInner<'tcx> {
    pub projection_cache: ProjectionCacheStorage<'tcx>,
    type_variable_storage: TypeVariableStorage<'tcx>,
    const_unification_storage: UnificationTableStorage<ConstVid<'tcx>>,
    int_unification_storage: UnificationTableStorage<IntVid>,
    float_unification_storage: UnificationTableStorage<FloatVid>,
    region_constraint_storage: Option<RegionConstraintStorage<'tcx>>,
    region_obligations: Vec<RegionObligation<'tcx>>,
    undo_log: InferCtxtUndoLogs<'tcx>,
    pub opaque_type_storage: OpaqueTypeStorage<'tcx>,
}

This type contains all the things within InferCtxt that sit within a RefCell and are involved with taking/rolling back snapshots. Snapshot operations are hot enough that we want only one call to borrow_mut per call to start_snapshot and rollback_to.

Fields

projection_cache: ProjectionCacheStorage<'tcx>

Cache for projections. This cache is snapshotted along with the infcx.

Public so that traits::project can use it.

type_variable_storage: TypeVariableStorage<'tcx>

We instantiate UnificationTable with bounds<Ty> because the types that might instantiate a general type variable have an order, represented by its upper and lower bounds.

const_unification_storage: UnificationTableStorage<ConstVid<'tcx>>

Map from const parameter variable to the kind of const it represents.

int_unification_storage: UnificationTableStorage<IntVid>

Map from integral variable to the kind of integer it represents.

float_unification_storage: UnificationTableStorage<FloatVid>

Map from floating variable to the kind of float it represents.

region_constraint_storage: Option<RegionConstraintStorage<'tcx>>

Tracks the set of region variables and the constraints between them. This is initially Some(_) but when resolve_regions_and_report_errors is invoked, this gets set to None – further attempts to perform unification, etc., may fail if new region constraints would’ve been added.

region_obligations: Vec<RegionObligation<'tcx>>

A set of constraints that regionck must validate. Each constraint has the form T:'a, meaning “some type T must outlive the lifetime ’a”. These constraints derive from instantiated type parameters. So if you had a struct defined like

    struct Foo<T:'static> { ... }

then in some expression let x = Foo { ... } it will instantiate the type parameter T with a fresh type $0. At the same time, it will record a region obligation of $0:'static. This will get checked later by regionck. (We can’t generally check these things right away because we have to wait until types are resolved.)

These are stored in a map keyed to the id of the innermost enclosing fn body / static initializer expression. This is because the location where the obligation was incurred can be relevant with respect to which sublifetime assumptions are in place. The reason that we store under the fn-id, and not something more fine-grained, is so that it is easier for regionck to be sure that it has found all the region obligations (otherwise, it’s easy to fail to walk to a particular node-id).

Before running resolve_regions_and_report_errors, the creator of the inference context is expected to invoke InferCtxt::process_registered_region_obligations for each body-id in this map, which will process the obligations within. This is expected to be done ‘late enough’ that all type inference variables have been bound and so forth.

undo_log: InferCtxtUndoLogs<'tcx>

opaque_type_storage: OpaqueTypeStorage<'tcx>

Caches for opaque type inference.

Implementations

impl<'tcx> InferCtxtInner<'tcx>

pub fn rollback_to(&mut self, snapshot: Snapshot<'tcx>)

pub fn commit(&mut self, snapshot: Snapshot<'tcx>)

impl<'tcx> InferCtxtInner<'tcx>

fn new() -> InferCtxtInner<'tcx>

pub fn region_obligations(&self) -> &[RegionObligation<'tcx>]

pub fn projection_cache(&mut self) -> ProjectionCache<'_, 'tcx>

fn type_variables(&mut self) -> TypeVariableTable<'_, 'tcx>

pub fn opaque_types(&mut self) -> OpaqueTypeTable<'_, 'tcx>

fn int_unification_table(
    &mut self
) -> UnificationTable<InPlace<IntVid, &mut UnificationStorage<IntVid>, &mut InferCtxtUndoLogs<'tcx>>>

fn float_unification_table(
    &mut self
) -> UnificationTable<InPlace<FloatVid, &mut UnificationStorage<FloatVid>, &mut InferCtxtUndoLogs<'tcx>>>

fn const_unification_table(
    &mut self
) -> UnificationTable<InPlace<ConstVid<'tcx>, &mut UnificationStorage<ConstVid<'tcx>>, &mut InferCtxtUndoLogs<'tcx>>>

pub fn unwrap_region_constraints(
    &mut self
) -> RegionConstraintCollector<'_, 'tcx>

Trait Implementations

impl<'tcx> Clone for InferCtxtInner<'tcx>

fn clone(&self) -> InferCtxtInner<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Rollback<UndoLog<'tcx>> for InferCtxtInner<'tcx>

The Rollback trait defines how to rollback a particular action.

fn reverse(&mut self, undo: UndoLog<'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: 504 bytes