Struct LivenessContext

struct LivenessContext<'a, 'typeck, 'tcx> {
    typeck: &'a mut TypeChecker<'typeck, 'tcx>,
    location_map: &'a DenseLocationMap,
    move_data: &'a MoveData<'tcx>,
    drop_data: FxIndexMap<Ty<'tcx>, DropData<'tcx>>,
    flow_inits: Option<ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>>,
    local_use_map: &'a LocalUseMap,
}

Contextual state for the type-liveness coroutine.

Fields

typeck: &'a mut TypeChecker<'typeck, 'tcx>

Current type-checker, giving us our inference context etc.

This also stores the body we’re currently analyzing.

location_map: &'a DenseLocationMap

Defines the PointIndex mapping

move_data: &'a MoveData<'tcx>

Mapping to/from the various indices used for initialization tracking.

drop_data: FxIndexMap<Ty<'tcx>, DropData<'tcx>>

Cache for the results of dropck_outlives query.

flow_inits: Option<ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>>

Results of dataflow tracking which variables (and paths) have been initialized. Computed lazily when needed by drop-liveness.

local_use_map: &'a LocalUseMap

Index indicating where each variable is assigned, used, or dropped.

Implementations

impl<'a, 'typeck, 'tcx> LivenessContext<'a, 'typeck, 'tcx>

fn flow_inits( &mut self, ) -> &mut ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>

Computes the MaybeInitializedPlaces dataflow analysis if it hasn’t been done already.

In practice, the results of this dataflow analysis are rarely needed but can be expensive to compute on big functions, so we compute them lazily as a fast path when:

• there are relevant live locals
• there are drop points for these relevant live locals.

This happens as part of the drop-liveness computation: it’s the only place checking for maybe-initializedness of MovePathIndexes.

impl<'tcx> LivenessContext<'_, '_, 'tcx>

fn body(&self) -> &Body<'tcx>

fn initialized_at_curr_loc(&mut self, mpi: MovePathIndex) -> bool

Returns true if the local variable (or some part of it) is initialized at the current cursor position. Callers should call one of the seek methods immediately before to point the cursor to the desired location.

fn initialized_at_terminator( &mut self, block: BasicBlock, mpi: MovePathIndex, ) -> bool

Returns true if the local variable (or some part of it) is initialized in the terminator of block. We need to check this to determine if a DROP of some local variable will have an effect – note that drops, as they may unwind, are always terminators.

fn initialized_at_exit(&mut self, block: BasicBlock, mpi: MovePathIndex) -> bool

Returns true if the path mpi (or some part of it) is initialized at the exit of block.

Warning: Does not account for the result of Call instructions.

fn add_use_live_facts_for( &mut self, value: Ty<'tcx>, live_at: &IntervalSet<PointIndex>, )

Stores the result that all regions in value are live for the points live_at.

fn add_drop_live_facts_for( &mut self, dropped_local: Local, dropped_ty: Ty<'tcx>, drop_locations: &[Location], live_at: &IntervalSet<PointIndex>, )

Some variable with type live_ty is “drop live” at location – i.e., it may be dropped later. This means that some of the regions in its type must be live at location. The precise set will depend on the dropck constraints, and in particular this takes #[may_dangle] into account.

fn make_all_regions_live( location_map: &DenseLocationMap, typeck: &mut TypeChecker<'_, 'tcx>, value: impl TypeVisitable<TyCtxt<'tcx>> + Relate<TyCtxt<'tcx>>, live_at: &IntervalSet<PointIndex>, )

fn compute_drop_data( typeck: &TypeChecker<'_, 'tcx>, dropped_ty: Ty<'tcx>, span: Span, ) -> DropData<'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: 224 bytes