Struct LivenessContext

struct LivenessContext<'a, 'typeck, 'b, 'tcx> {
    typeck: &'a mut TypeChecker<'typeck, 'tcx>,
    elements: &'a DenseLocationMap,
    body: &'a Body<'tcx>,
    move_data: &'a MoveData<'tcx>,
    drop_data: FxIndexMap<Ty<'tcx>, DropData<'tcx>>,
    flow_inits: ResultsCursor<'b, 'tcx, MaybeInitializedPlaces<'b, '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.

elements: &'a DenseLocationMap

Defines the PointIndex mapping

body: &'a Body<'tcx>

MIR we are analyzing.

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: ResultsCursor<'b, 'tcx, MaybeInitializedPlaces<'b, 'tcx>>

Results of dataflow tracking which variables (and paths) have been initialized.

local_use_map: &'a LocalUseMap

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

Implementations

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

fn initialized_at_curr_loc(&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: impl TypeVisitable<TyCtxt<'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( elements: &DenseLocationMap, typeck: &mut TypeChecker<'_, 'tcx>, value: impl TypeVisitable<TyCtxt<'tcx>>, live_at: &IntervalSet<PointIndex>, )

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