Struct PartialGraph

pub struct PartialGraph<'tcx> {
    pub(crate) nodes: FxHashSet<DepNode<'tcx>>,
    pub(crate) edges: FxHashSet<(DepNode<'tcx>, DepNode<'tcx>, DepEdge)>,
    pub(crate) generics: GenericArgsRef<'tcx>,
    def_id: DefId,
    arg_count: usize,
    local_decls: IndexVec<Local, LocalDecl<'tcx>>,
}

Fields

nodes: FxHashSet<DepNode<'tcx>>

edges: FxHashSet<(DepNode<'tcx>, DepNode<'tcx>, DepEdge)>

generics: GenericArgsRef<'tcx>

def_id: DefId

arg_count: usize

local_decls: IndexVec<Local, LocalDecl<'tcx>>

Implementations

impl<'tcx> PartialGraph<'tcx>

fn modular_mutation_visitor<'a, 'mir>( &'a mut self, results: &'a Results<'tcx, &'mir LocalAnalysis<'tcx, 'mir>>, state: &'a InstructionState<'tcx>, ) -> ModularMutationVisitor<'a, 'tcx, impl FnMut(Location, Mutation<'tcx>) + use<'a, 'tcx, 'mir>>

fn handle_as_inline<'a>( &mut self, results: &Results<'tcx, &'a LocalAnalysis<'tcx, 'a>>, state: &InstructionState<'tcx>, terminator: &Terminator<'tcx>, location: Location, ) -> bool

returns whether we were able to successfully handle this as inline

impl<'tcx> PartialGraph<'tcx>

fn register_mutation( &mut self, results: &Results<'tcx, &'_ LocalAnalysis<'tcx, '_>>, state: &InstructionState<'tcx>, inputs: Inputs<'tcx>, mutated: Either<Place<'tcx>, DepNode<'tcx>>, location: Location, target_use: TargetUse, )

impl<'tcx> PartialGraph<'tcx>

pub fn to_petgraph(&self) -> DepGraph<'tcx>

fn check_invariants(&self)

impl<'tcx> PartialGraph<'tcx>

pub fn mentioned_call_string<'a>( &'a self, ) -> impl Iterator<Item = CallString> + Captures<'tcx> + 'a

pub fn new( generics: GenericArgsRef<'tcx>, def_id: DefId, arg_count: usize, local_decls: &LocalDecls<'tcx>, ) -> Self

pub(crate) fn parentable_srcs<'a>( &'a self, is_at_root: impl Fn(CallString) -> bool, ) -> FxHashSet<(DepNode<'tcx>, Option<u8>)>

Returns the set of source places that the parent can access (write to)

Parameterized by a is_at_root function which returns whether a given call string refers to a location in the outermost function. This is necessary, because consumers of PartialGraph manipulate the call string and as such we cannot assume that .len() == 1 necessarily refers to a root location. (TODO we probably should maintain that invariant)

pub(crate) fn parentable_dsts<'a>( &'a self, is_at_root: impl Fn(CallString) -> bool, ) -> FxHashSet<(DepNode<'tcx>, Option<u8>)>

Returns the set of destination places that the parent can access (read from)

Parameterized by a is_at_root function which returns whether a given call string refers to a location in the outermost function. This is necessary, because consumers of PartialGraph manipulate the call string and as such we cannot assume that .len() == 1 necessarily refers to a root location. (TODO we probably should maintain that invariant)

Trait Implementations

impl<'tcx> Clone for PartialGraph<'tcx>

fn clone(&self) -> PartialGraph<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Debug for PartialGraph<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> HasLocalDecls<'tcx> for PartialGraph<'tcx>

fn local_decls(&self) -> &LocalDecls<'tcx>

impl<'mir, 'tcx> ResultsVisitor<'mir, 'tcx, &'mir LocalAnalysis<'tcx, 'mir>> for PartialGraph<'tcx>

fn visit_after_early_terminator_effect( &mut self, results: &mut Results<'tcx, &'mir LocalAnalysis<'tcx, 'mir>>, state: &InstructionState<'tcx>, terminator: &'mir Terminator<'tcx>, location: Location, )

We handle terminators during graph construction generally in the before state, because we’re interested in what the dependencies of our read places are before the modification pass overwrites the read places from any mutable arguments.

There is one exception which is that non-inlined function calls are handled in two steps. Before the primary effects we generate edges from the dependencies to the input arguments. After the primary effect we insert edges from each argument to each modified location. It is cleaner to do this afterwards, because the logic that resolves a place to a graph node assumes that you are reading all of your inputs from the “last_modification”. In the “before” state that map contains the “original” dependencies of each argument, e.g. we haven’t combined them with the reachable places yet. So this ordering means we can reuse the same logic but just have to run it twice for every non-inlined function call site.

fn visit_after_early_statement_effect( &mut self, results: &mut Results<'tcx, &'mir LocalAnalysis<'tcx, 'mir>>, state: &InstructionState<'tcx>, statement: &'mir Statement<'tcx>, location: Location, )

// njn: grep for “before”, “primary”, etc. Called after the “early” effect of the given statement is applied to state.

fn visit_after_primary_terminator_effect( &mut self, results: &mut Results<'tcx, &'mir LocalAnalysis<'tcx, 'mir>>, state: &InstructionState<'tcx>, terminator: &'mir Terminator<'tcx>, location: Location, )

Called after the “primary” effect of the given terminator is applied to state.

fn visit_block_start(&mut self, _state: &<A as Analysis<'tcx>>::Domain)

fn visit_after_primary_statement_effect( &mut self, _results: &mut Results<'tcx, A>, _state: &<A as Analysis<'tcx>>::Domain, _statement: &'mir Statement<'tcx>, _location: Location, )

Called after the “primary” effect of the given statement is applied to state.

fn visit_block_end(&mut self, _state: &<A as Analysis<'tcx>>::Domain)

impl<'tcx> TransformCallString for PartialGraph<'tcx>

fn transform_call_string(&self, f: impl Fn(CallString) -> CallString) -> Self