Struct PointsToAnalysis

struct PointsToAnalysis<'a> {
    fn_sig: Option<&'a EarlyBinder<PolyFnSig>>,
    map: &'a Map,
}

This implement a points to analysis for mutable references over a [FlatSet]. The analysis is a may analysis. If you want to know if a reference definitively points to a location you have to combine it with the result of a definitely initialized analysis. See module level documentation for more details.

Fields

fn_sig: Option<&'a EarlyBinder<PolyFnSig>>

map: &'a Map

Implementations

impl<'a> PointsToAnalysis<'a>

fn new(map: &'a Map, fn_sig: Option<&'a EarlyBinder<PolyFnSig>>) -> Self

fn handle_statement(&self, statement: &Statement<'_>, state: &mut State)

fn handle_assign( &self, target: Place<'_>, rvalue: &Rvalue<'_>, state: &mut State, )

fn handle_ref(&self, place: &Place<'_>, state: &State) -> FlatSet<Loc>

fn handle_operand(&self, operand: &Operand<'_>) -> Option<PlaceIndex>

fn handle_terminator<'mir, 'tcx>( &self, terminator: &'mir Terminator<'tcx>, state: &mut State, ) -> TerminatorEdges<'mir, 'tcx>

The effect of a successful function call return should not be applied here, see [Analysis::apply_terminator_effect].

fn handle_call_return( &self, return_places: CallReturnPlaces<'_, '_>, state: &mut State, )

Trait Implementations

impl<'tcx> Analysis<'tcx> for PointsToAnalysis<'_>

const NAME: &'static str = "PointsToAnalysis"

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

type Domain = State

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

fn bottom_value(&self, _: &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.

fn apply_statement_effect( &mut 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<'mir>( &mut self, state: &mut Self::Domain, terminator: &'mir Terminator<'tcx>, _location: Location, ) -> TerminatorEdges<'mir, 'tcx>

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

fn apply_call_return_effect( &mut 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( &mut 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.

type Direction = Forward

The direction of this analysis. Either Forward or Backward.

fn apply_before_statement_effect( &mut 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( &mut 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 iterate_to_fixpoint<'mir>( self, tcx: TyCtxt<'tcx>, body: &'mir Body<'tcx>, pass_name: Option<&'static str>, ) -> Results<'tcx, Self>

where Self: Sized, Self::Domain: DebugWithContext<Self>,

Finds the fixpoint for this dataflow problem.

impl DebugWithContext<PointsToAnalysis<'_>> for State

This is used to visualize the dataflow analysis.

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

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

Print the difference between self and old.