Struct rustc_mir::dataflow::impls::EverInitializedPlaces

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

EverInitializedPlaces tracks all places that might have ever been initialized upon reaching a particular point in the control flow for a function, without an intervening Storage Dead.

This dataflow is used to determine if an immutable local variable may be assigned to.

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

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

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

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

    }                                      // {a, b,    d }

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

Fields

tcx: TyCtxt<'tcx>

body: &'a Body<'tcx>

mdpe: &'a MoveDataParamEnv<'tcx>

Implementations

impl<'a, 'tcx> EverInitializedPlaces<'a, 'tcx>

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

Trait Implementations

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

type Idx = InitIndex

The type of the elements in the state vector.

const NAME: &'static str

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

fn bits_per_block(&self, _: &Body<'tcx>) -> usize

The size of the state vector.

fn initialize_start_block(
    &self,
    body: &Body<'tcx>,
    state: &mut BitSet<Self::Idx>
)

Mutates the entry set of the START_BLOCK to contain the initial state for dataflow analysis.

type Direction: Direction = Forward

The direction of this analyis. Either Forward or Backward.

fn pretty_print_idx(&self, w: &mut impl Write, idx: Self::Idx) -> Result<()>

Prints an element in the state vector for debugging.

impl<'a, 'tcx> BottomValue for EverInitializedPlaces<'a, 'tcx>

const BOTTOM_VALUE: bool

bottom = no initialized variables by default

fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool

Merges in_set into inout_set, returning true if inout_set changed.

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

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

See Analysis::apply_statement_effect.

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

See Analysis::apply_terminator_effect.

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.

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

See Analysis::apply_before_statement_effect.

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

See Analysis::apply_before_terminator_effect.

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

See Analysis::apply_yield_resume_effect.

fn discriminant_switch_effect(
    &self,
    _state: &mut impl GenKill<Self::Idx>,
    _block: BasicBlock,
    _enum_place: Place<'tcx>,
    _adt: &AdtDef,
    _variant: VariantIdx
)

See Analysis::apply_discriminant_switch_effect.

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

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