Struct rustc_mir::transform::check_consts::resolver::FlowSensitiveAnalysis

pub(super) struct FlowSensitiveAnalysis<'a, 'mir, 'tcx, Q> {
    ccx: &'a ConstCx<'mir, 'tcx>,
    _qualif: PhantomData<Q>,
}

The dataflow analysis used to propagate qualifs on arbitrary CFGs.

Fields

ccx: &'a ConstCx<'mir, 'tcx>

_qualif: PhantomData<Q>

Implementations

impl<'a, 'mir, 'tcx, Q> FlowSensitiveAnalysis<'a, 'mir, 'tcx, Q> where
    Q: Qualif, 

pub(super) fn new(
    _: Q,
    ccx: &'a ConstCx<'mir, 'tcx>
) -> Self

fn transfer_function(
    &self,
    state: &'a mut BitSet<Local>
) -> TransferFunction<'a, 'mir, 'tcx, Q>

Trait Implementations

impl<Q, 'tcx, '_, '_> Analysis<'tcx> for FlowSensitiveAnalysis<'_, '_, 'tcx, Q> where
    Q: Qualif, 

fn apply_statement_effect(
    &self,
    state: &mut BitSet<Self::Idx>,
    statement: &Statement<'tcx>,
    location: Location
)

Updates the current dataflow state with the effect of evaluating a statement.

fn apply_terminator_effect(
    &self,
    state: &mut BitSet<Self::Idx>,
    terminator: &Terminator<'tcx>,
    location: Location
)

Updates the current dataflow state with the effect of evaluating a terminator.

fn apply_call_return_effect(
    &self,
    state: &mut BitSet<Self::Idx>,
    block: BasicBlock,
    func: &Operand<'tcx>,
    args: &[Operand<'tcx>],
    return_place: Place<'tcx>
)

Updates the current dataflow state with the effect of a successful return from a Call terminator.

fn apply_before_statement_effect(
    &self,
    _state: &mut BitSet<Self::Idx>,
    _statement: &Statement<'tcx>,
    _location: Location
)

Updates the current dataflow state with an effect that occurs immediately before the given statement.

fn apply_before_terminator_effect(
    &self,
    _state: &mut BitSet<Self::Idx>,
    _terminator: &Terminator<'tcx>,
    _location: Location
)

Updates the current dataflow state with an effect that occurs immediately before the given terminator.

fn apply_yield_resume_effect(
    &self,
    _state: &mut BitSet<Self::Idx>,
    _resume_block: BasicBlock,
    _resume_place: Place<'tcx>
)

Updates the current dataflow state with the effect of resuming from a Yield terminator.

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

Updates the current dataflow state with the effect of taking a particular branch in a SwitchInt terminator.

fn into_engine<'mir>(
    self,
    tcx: TyCtxt<'tcx>,
    body: &'mir Body<'tcx>,
    def_id: DefId
) -> Engine<'mir, 'tcx, Self> where
    Self: Sized, 

Creates an Engine to find the fixpoint for this dataflow problem.

impl<Q, 'tcx, '_, '_> AnalysisDomain<'tcx> for FlowSensitiveAnalysis<'_, '_, 'tcx, Q> where
    Q: Qualif, 

type Idx = Local

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: &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<Q, '_, '_, '_> BottomValue for FlowSensitiveAnalysis<'_, '_, '_, Q>

const BOTTOM_VALUE: bool

Specifies the initial value for each bit in the entry set for each basic block.

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.