Struct rustc_mir::dataflow::impls::MaybeInitializedPlaces

pub struct MaybeInitializedPlaces<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    mdpe: &'a MoveDataParamEnv<'tcx>,
}

MaybeInitializedPlaces tracks all places that might be initialized upon reaching a particular point in the control flow for a function.

For example, in code like the following, we have corresponding dataflow information shown in the right-hand comments.

struct S;
fn foo(pred: bool) {                       // maybe-init:
                                           // {}
    let a = S; let b = S; let c; let d;    // {a, b}

    if pred {
        drop(a);                           // {   b}
        b = S;                             // {   b}

    } else {
        drop(b);                           // {a}
        d = S;                             // {a,       d}

    }                                      // {a, b,    d}

    c = S;                                 // {a, b, c, d}
}

To determine whether a place must be initialized at a particular control-flow point, one can take the set-difference between this data and the data from MaybeUninitializedPlaces at the corresponding control-flow point.

Similarly, at a given drop statement, the set-intersection between this data and MaybeUninitializedPlaces yields the set of places that would require a dynamic drop-flag at that statement.

Fields

tcx: TyCtxt<'tcx>

body: &'a Body<'tcx>

mdpe: &'a MoveDataParamEnv<'tcx>

Implementations

impl<'a, 'tcx> MaybeInitializedPlaces<'a, 'tcx>

pub fn new(
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    mdpe: &'a MoveDataParamEnv<'tcx>
) -> Self

impl<'a, 'tcx> MaybeInitializedPlaces<'a, 'tcx>

pub(in dataflow::impls) fn update_bits(
    trans: &mut impl GenKill<MovePathIndex>,
    path: MovePathIndex,
    state: DropFlagState
)

Trait Implementations

impl<'tcx, '_> AnalysisDomain<'tcx> for MaybeInitializedPlaces<'_, 'tcx>

type Domain = BitSet<MovePathIndex>

The type that holds the dataflow state at any given point in the program.

pub const NAME: &'static str

A descriptive name for this analysis. Used only for debugging.

pub fn bottom_value(&self, _: &Body<'tcx>) -> Self::Domain

The initial value of the dataflow state upon entry to each basic block.

pub fn initialize_start_block(&self, _: &Body<'tcx>, state: &mut Self::Domain)

Mutates the initial value of the dataflow state upon entry to the START_BLOCK.

type Direction: Direction = Forward

The direction of this analysis. Either Forward or Backward.

impl<'tcx, '_> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx>

type Idx = MovePathIndex

pub fn statement_effect(
    &self,
    trans: &mut impl GenKill<Self::Idx>,
    _statement: &Statement<'tcx>,
    location: Location
)

See Analysis::apply_statement_effect.

pub fn terminator_effect(
    &self,
    trans: &mut impl GenKill<Self::Idx>,
    _terminator: &Terminator<'tcx>,
    location: Location
)

See Analysis::apply_terminator_effect.

pub fn call_return_effect(
    &self,
    trans: &mut impl GenKill<Self::Idx>,
    _block: BasicBlock,
    _func: &Operand<'tcx>,
    _args: &[Operand<'tcx>],
    dest_place: Place<'tcx>
)

See Analysis::apply_call_return_effect.

pub fn switch_int_edge_effects<G: GenKill<Self::Idx>>(
    &self,
    block: BasicBlock,
    discr: &Operand<'tcx>,
    edge_effects: &mut impl SwitchIntEdgeEffects<G>
)

See Analysis::apply_switch_int_edge_effects.

pub fn before_statement_effect(
    &self,
    _trans: &mut impl GenKill<Self::Idx>,
    _statement: &Statement<'tcx>,
    _location: Location
)

See Analysis::apply_before_statement_effect.

pub fn before_terminator_effect(
    &self,
    _trans: &mut impl GenKill<Self::Idx>,
    _terminator: &Terminator<'tcx>,
    _location: Location
)

See Analysis::apply_before_terminator_effect.

pub fn yield_resume_effect(
    &self,
    _trans: &mut impl GenKill<Self::Idx>,
    _resume_block: BasicBlock,
    _resume_place: Place<'tcx>
)

See Analysis::apply_yield_resume_effect.

impl<'a, 'tcx> HasMoveData<'tcx> for MaybeInitializedPlaces<'a, 'tcx>

pub fn move_data(&self) -> &MoveData<'tcx>