Struct BorrowCheckRootCtxt 

pub(crate) struct BorrowCheckRootCtxt<'tcx> {
    pub tcx: TyCtxt<'tcx>,
    root_def_id: LocalDefId,
    concrete_opaque_types: ConcreteOpaqueTypes<'tcx>,
    collect_region_constraints_results: FxIndexMap<LocalDefId, CollectRegionConstraintsResult<'tcx>>,
    propagated_borrowck_results: FxHashMap<LocalDefId, PropagatedBorrowCheckResults<'tcx>>,
    tainted_by_errors: Option<ErrorGuaranteed>,
    pub consumer: Option<BorrowckConsumer<'tcx>>,
}

The shared context used by both the root as well as all its nested items.

Fields

tcx: TyCtxt<'tcx>

root_def_id: LocalDefId

concrete_opaque_types: ConcreteOpaqueTypes<'tcx>

collect_region_constraints_results: FxIndexMap<LocalDefId, CollectRegionConstraintsResult<'tcx>>

The region constraints computed by borrowck_collect_region_constraints. This uses an FxIndexMap to guarantee that iterating over it visits nested bodies before their parents.

propagated_borrowck_results: FxHashMap<LocalDefId, PropagatedBorrowCheckResults<'tcx>>

tainted_by_errors: Option<ErrorGuaranteed>

consumer: Option<BorrowckConsumer<'tcx>>

This should be None during normal compilation. See crate::consumers for more information on how this is used.

Implementations

impl<'tcx> BorrowCheckRootCtxt<'tcx>

pub(crate) fn new( tcx: TyCtxt<'tcx>, root_def_id: LocalDefId, consumer: Option<BorrowckConsumer<'tcx>>, ) -> BorrowCheckRootCtxt<'tcx>

pub(crate) fn root_def_id(&self) -> LocalDefId

pub(crate) fn set_tainted_by_errors(&mut self, guar: ErrorGuaranteed)

pub(crate) fn used_mut_upvars( &mut self, nested_body_def_id: LocalDefId, ) -> &SmallVec<[FieldIdx; 8]>

pub(crate) fn finalize( self, ) -> Result<&'tcx ConcreteOpaqueTypes<'tcx>, ErrorGuaranteed>

fn handle_opaque_type_uses(&mut self)

fn apply_closure_requirements_modulo_opaques(&mut self)

Computing defining uses of opaques may depend on the propagated region requirements of nested bodies, while applying defining uses may introduce additional region requirements we need to propagate.

This results in cyclic dependency. To compute the defining uses in parent bodies, we need the closure requirements of its nested bodies, but to check non-defining uses in nested bodies, we may rely on the defining uses in the parent.

We handle this issue by applying closure requirements twice. Once using the region constraints from before we’ve handled opaque types in the nested body

• which is used by the parent to handle its defining uses - and once after.

As a performance optimization, we also eagerly finish borrowck for bodies which don’t depend on opaque types. In this case they get removed from collect_region_constraints_results and the final result gets put into propagated_borrowck_results.

fn compute_closure_requirements_modulo_opaques( input: &CollectRegionConstraintsResult<'tcx>, ) -> Option<ClosureRegionRequirements<'tcx>>

fn apply_closure_requirements( input: &mut CollectRegionConstraintsResult<'tcx>, closure_requirements: &Option<ClosureRegionRequirements<'tcx>>, closure_def_id: LocalDefId, args: GenericArgsRef<'tcx>, locations: Locations, )

pub(crate) fn do_mir_borrowck(&mut self)

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