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

pub(in transform::check_consts) 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(in transform::check_consts) fn new(
    _: Q,
    ccx: &'a ConstCx<'mir, 'tcx>
) -> Self

pub(in transform::check_consts::resolver) 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, 

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

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

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

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

pub fn apply_call_return_effect(
    &self,
    state: &mut Self::Domain,
    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.

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

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

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

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

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

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

pub fn apply_switch_int_edge_effects(
    &self,
    _block: BasicBlock,
    _discr: &Operand<'tcx>,
    _apply_edge_effects: &mut impl SwitchIntEdgeEffects<Self::Domain>
)

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

pub fn into_engine<'mir>(
    self,
    tcx: TyCtxt<'tcx>,
    body: &'mir Body<'tcx>
) -> 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 Domain = BitSet<Local>

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: &Body<'tcx>) -> Self::Domain

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

pub fn initialize_start_block(
    &self,
    _body: &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.