Struct rustc_mir_dataflow::value_analysis::ValueAnalysisWrapper

pub struct ValueAnalysisWrapper<T>(pub T);

Tuple Fields

0: T

Trait Implementations

impl<'tcx, T> Analysis<'tcx> for ValueAnalysisWrapper<T>where
    T: ValueAnalysis<'tcx>,

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.

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.

fn apply_call_return_effect(
    &self,
    state: &mut Self::Domain,
    _block: BasicBlock,
    return_places: CallReturnPlaces<'_, 'tcx>
)

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

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.

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.

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.

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.

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<'tcx, T: ValueAnalysis<'tcx>> AnalysisDomain<'tcx> for ValueAnalysisWrapper<T>

type Domain = State<<T as ValueAnalysis<'tcx>>::Value>

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

type Direction = Forward

The direction of this analysis. Either Forward or Backward.

const NAME: &'static str = T::NAME

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

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

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

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.

impl<'tcx, T> DebugWithContext<ValueAnalysisWrapper<T>> for State<T::Value>where
    T: ValueAnalysis<'tcx>,
    T::Value: Debug,

This is used to visualize the dataflow analysis.

fn fmt_with(
    &self,
    ctxt: &ValueAnalysisWrapper<T>,
    f: &mut Formatter<'_>
) -> Result

fn fmt_diff_with(
    &self,
    old: &Self,
    ctxt: &ValueAnalysisWrapper<T>,
    f: &mut Formatter<'_>
) -> Result

Print the difference between self and old.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.