Struct rustc_infer::infer::InferCtxtInner[][src]

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<(HirId, RegionObligation<'tcx>)>,
    undo_log: InferCtxtUndoLogs<'tcx>,
    pub opaque_types: OpaqueTypeMap<'tcx>,
    pub opaque_types_vars: FxHashMap<Ty<'tcx>, Ty<'tcx>>,
Expand description

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.


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<(HirId, 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 process_region_obligations (defined in self::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_types: OpaqueTypeMap<'tcx>opaque_types_vars: FxHashMap<Ty<'tcx>, Ty<'tcx>>

A map from inference variables created from opaque type instantiations (ty::Infer) to the actual opaque type (ty::Opaque). Used during fallback to map unconstrained opaque type inference variables to their corresponding opaque type.


Trait Implementations

The Rollback trait defines how to rollback a particular action.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.


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