Type Alias rustc_mir_dataflow::ResultsClonedCursor

pub type ResultsClonedCursor<'res, 'mir, 'tcx, A> = ResultsCursor<'mir, 'tcx, A, ResultsCloned<'res, 'tcx, A>>;

A ResultsCursor which uses a cloned Analysis while borrowing the underlying Results. This allows multiple cursors over the same Results.

Aliased Type

struct ResultsClonedCursor<'res, 'mir, 'tcx, A> {
    body: &'mir Body<'tcx>,
    results: Results<'tcx, A, &'res IndexVec<BasicBlock, <A as AnalysisDomain<'tcx>>::Domain>>,
    state: <A as AnalysisDomain<'tcx>>::Domain,
    pos: CursorPosition,
    state_needs_reset: bool,
    reachable_blocks: BitSet<BasicBlock>,
}

Fields

body: &'mir Body<'tcx>

results: Results<'tcx, A, &'res IndexVec<BasicBlock, <A as AnalysisDomain<'tcx>>::Domain>>

state: <A as AnalysisDomain<'tcx>>::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: Encountered an error during type layout; the type failed to be normalized.