Struct rustc_mir_dataflow::framework::cursor::ResultsCursor

pub struct ResultsCursor<'mir, 'tcx, A, R = Results<'tcx, A>>where
    A: Analysis<'tcx>,{
    body: &'mir Body<'tcx>,
    results: R,
    state: A::Domain,
    pos: CursorPosition,
    state_needs_reset: bool,
    reachable_blocks: BitSet<BasicBlock>,
}

Allows random access inspection of the results of a dataflow analysis.

This cursor only has linear performance within a basic block when its statements are visited in the same order as the DIRECTION of the analysis. In the worst case—when statements are visited in reverse order—performance will be quadratic in the number of statements in the block. The order in which basic blocks are inspected has no impact on performance.

A ResultsCursor can either own (the default) or borrow the dataflow results it inspects. The type of ownership is determined by R (see ResultsRefCursor above).

Fields

body: &'mir Body<'tcx>

results: R

state: A::Domain

pos: CursorPosition

state_needs_reset: bool

Indicates that state has been modified with a custom effect.

When this flag is set, we need to reset to an entry set before doing a seek.

reachable_blocks: BitSet<BasicBlock>

Implementations

impl<'mir, 'tcx, A, R> ResultsCursor<'mir, 'tcx, A, R>where A: Analysis<'tcx>,

pub fn get(&self) -> &A::Domain

Returns the dataflow state at the current location.

pub fn body(&self) -> &'mir Body<'tcx>

Returns the body this analysis was run on.

pub fn into_results(self) -> R

Unwraps this cursor, returning the underlying Results.

impl<'res, 'mir, 'tcx, A> ResultsCursor<'mir, 'tcx, A, ResultsCloned<'res, 'tcx, A>>where A: Analysis<'tcx> + CloneAnalysis,

pub fn new_cursor(&self) -> Self

Creates a new cursor over the same Results. Note that the cursor’s position is not copied.

impl<'mir, 'tcx, A, R> ResultsCursor<'mir, 'tcx, A, R>where A: Analysis<'tcx>, R: AnalysisResults<'tcx, A>,

pub fn new(body: &'mir Body<'tcx>, results: R) -> Self

Returns a new cursor that can inspect results.

pub fn results(&mut self) -> &Results<'tcx, A, R::EntrySets>

Returns the underlying Results.

pub fn mut_results(&mut self) -> &mut Results<'tcx, A, R::EntrySets>

Returns the underlying Results.

pub fn analysis(&self) -> &A

Returns the Analysis used to generate the underlying Results.

pub fn mut_analysis(&mut self) -> &mut A

Returns the Analysis used to generate the underlying Results.

pub fn get_with_analysis(&mut self) -> (&A::Domain, &mut A)

Returns both the dataflow state at the current location and the Analysis.

pub(super) fn seek_to_block_entry(&mut self, block: BasicBlock)

Resets the cursor to hold the entry set for the given basic block.

For forward dataflow analyses, this is the dataflow state prior to the first statement.

For backward dataflow analyses, this is the dataflow state after the terminator.

pub fn seek_to_block_start(&mut self, block: BasicBlock)

Resets the cursor to hold the state prior to the first statement in a basic block.

For forward analyses, this is the entry set for the given block.

For backward analyses, this is the state that will be propagated to its predecessors (ignoring edge-specific effects).

pub fn seek_to_block_end(&mut self, block: BasicBlock)

Resets the cursor to hold the state after the terminator in a basic block.

For backward analyses, this is the entry set for the given block.

For forward analyses, this is the state that will be propagated to its successors (ignoring edge-specific effects).

pub fn seek_before_primary_effect(&mut self, target: Location)

Advances the cursor to hold the dataflow state at target before its “primary” effect is applied.

The “before” effect at the target location will be applied.

pub fn seek_after_primary_effect(&mut self, target: Location)

Advances the cursor to hold the dataflow state at target after its “primary” effect is applied.

The “before” effect at the target location will be applied as well.

fn seek_after(&mut self, target: Location, effect: Effect)

pub fn apply_custom_effect(&mut self, f: impl FnOnce(&mut A, &mut A::Domain))

Applies f to the cursor’s internal state.

This can be used, e.g., to apply the call return effect directly to the cursor without creating an extra copy of the dataflow state.

impl<'mir, 'tcx, A, R> ResultsCursor<'mir, 'tcx, A, R>where A: GenKillAnalysis<'tcx>, A::Domain: BitSetExt<A::Idx>,

pub fn contains(&self, elem: A::Idx) -> bool

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.