Struct ModuleGraphSnapshot 

pub struct ModuleGraphSnapshot {
    pub graphs: Vec<ReadRef<SingleModuleGraph>>,
    /* private fields */
}

This struct provides traversal functionality for the module graph.

Some edges might be ignored during traversal: unused references listed in binding_usage are always skipped, and references with ChunkingType::Traced are skipped by default (can be overridden in some functions via the include_traced parameter).

The API across the functions is pretty consistent, apart from:

• traverse_edges_fixed_point_with_priority additionally provides the GraphEdgeIndex
• traverse_edges_dfs is the only function with include_traced

Fields

graphs: Vec<ReadRef<SingleModuleGraph>>

Implementations

impl ModuleGraphSnapshot

pub fn all_chunk_group_entries( &self, ) -> impl Iterator<Item = &ChunkGroupEntry> + '_

The entry modules of all chunk groups of all graphs.

pub fn all_chunk_group_entry_modules( &self, ) -> impl Iterator<Item = ResolvedVc<Box<dyn Module>>> + '_

The entry modules of all chunk groups of all graphs.

pub fn all_entry_modules( &self, ) -> impl Iterator<Item = ResolvedVc<Box<dyn Module>>> + '_

The entry modules of all chunk groups of all graphs. Includes traced entry modules

pub fn enumerate_nodes( &self, ) -> impl Iterator<Item = (NodeIndex, &SingleModuleGraphNode)> + '_

WARNING: using this is discouraged, as it doesn’t filter out unused or traced references. Use iter_reachable_modules or one of the .traverse_* functions instead.

pub fn iter_nodes( &self, ) -> impl Iterator<Item = ResolvedVc<Box<dyn Module>>> + '_

WARNING: using this is discouraged, as it doesn’t filter out unused or traced references. Use iter_reachable_modules or one of the .traverse_* functions instead.

pub async fn get_ids( &self, ) -> Result<FxHashMap<ResolvedVc<Box<dyn Module>>, ReadRef<RcStr>>>

Returns a map of all modules in the graphs to their identifiers. This is primarily useful for debugging.

pub fn traverse_nodes_dfs<S>( &self, entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>, state: &mut S, visit_preorder: impl Fn(ResolvedVc<Box<dyn Module>>, &mut S) -> Result<GraphTraversalAction>, visit_postorder: impl FnMut(ResolvedVc<Box<dyn Module>>, &mut S) -> Result<()>, ) -> Result<()>

Traverses all reachable nodes exactly once and calls the visitor.

• entries - The entry modules to start the traversal from
• state mutable state to be shared across the visitors
• visit_preorder - Called before visiting the children of a node.
  • Receives the module and the state
  • Can return GraphTraversalActions to control the traversal
• visit_postorder - Called after visiting children of a node.

pub fn traverse_edges_bfs( &self, entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>, visitor: impl FnMut(Option<(ResolvedVc<Box<dyn Module>>, &RefData)>, ResolvedVc<Box<dyn Module>>) -> Result<GraphTraversalAction>, ) -> Result<()>

Traverses all reachable edges exactly once and calls the visitor with the edge source and target.

This means that target nodes can be revisited (once per incoming edge).

• entry - The entry module to start the traversal from
• visitor - Called before visiting the children of a node.
  • Receives (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Can return GraphTraversalActions to control the traversal

pub fn traverse_edges_unordered( &self, visitor: impl FnMut(Option<(ResolvedVc<Box<dyn Module>>, &RefData)>, ResolvedVc<Box<dyn Module>>) -> Result<()>, ) -> Result<()>

Traverses all edges exactly once (in an unspecified order) and calls the visitor with the edge source and target.

This means that target nodes can be revisited (once per incoming edge).

• visitor - Called before visiting the children of a node.
  • Receives (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode

pub fn traverse_edges_dfs<S>( &self, entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>, state: &mut S, visit_preorder: impl FnMut(Option<(ResolvedVc<Box<dyn Module>>, &RefData)>, ResolvedVc<Box<dyn Module>>, &mut S) -> Result<GraphTraversalAction>, visit_postorder: impl FnMut(Option<(ResolvedVc<Box<dyn Module>>, &RefData)>, ResolvedVc<Box<dyn Module>>, &mut S) -> Result<()>, include_traced: bool, ) -> Result<()>

Traverses all reachable edges in dfs order. The preorder visitor can be used to forward state down the graph, and to skip subgraphs

Use this to collect modules in evaluation order.

Target nodes can be revisited (once per incoming edge) in the preorder_visitor, in the post order visitor they are visited exactly once with the first edge they were discovered with. Edges are traversed in normal order, so should correspond to reference order.

• entries - The entry modules to start the traversal from
• state - The state to be passed to the visitors
• visit_preorder - Called before visiting the children of a node.
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Can return GraphTraversalActions to control the traversal
• visit_postorder - Called after visiting the children of a node. Return
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S

pub fn traverse_edges_reverse_dfs<S>( &self, entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>, state: &mut S, visit_preorder: impl FnMut(Option<(ResolvedVc<Box<dyn Module>>, &RefData)>, ResolvedVc<Box<dyn Module>>, &mut S) -> Result<GraphTraversalAction>, visit_postorder: impl FnMut(Option<(ResolvedVc<Box<dyn Module>>, &RefData)>, ResolvedVc<Box<dyn Module>>, &mut S) -> Result<()>, ) -> Result<()>

Traverses all reachable edges in dfs order over the reversed graph. The preorder visitor can be used to forward state up the graph, and to skip subgraphs

Target nodes can be revisited (once per incoming edge) in the preorder_visitor, in the post order visitor they are visited exactly once with the first edge they were discovered with. Edges are traversed in normal order, so should correspond to reference order.

• entries - The entry modules to start the traversal from
• state - The state to be passed to the visitors
• visit_preorder - Called before visiting the children of a node.
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Can return GraphTraversalActions to control the traversal
• visit_postorder - Called after visiting the parents of a node. Return
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S

pub fn traverse_cycles( &self, edge_filter: impl Fn(&RefData) -> bool, visit_cycle: impl FnMut(&[&ResolvedVc<Box<dyn Module>>]) -> Result<()>, ) -> Result<()>

Traverse all cycles in the graph (where the edge filter returns true for the whole cycle) and call the visitor with the nodes in the cycle. Notably, module self-references are also treated as cycles.

pub fn traverse_edges_fixed_point_with_priority<S, P: Ord>( &self, entries: impl IntoIterator<Item = (ResolvedVc<Box<dyn Module>>, P)>, state: &mut S, visit: impl FnMut(Option<(ResolvedVc<Box<dyn Module>>, &RefData, GraphEdgeIndex)>, ResolvedVc<Box<dyn Module>>, &mut S) -> Result<GraphTraversalAction>, priority: impl Fn(ResolvedVc<Box<dyn Module>>, &mut S) -> Result<P>, ) -> Result<usize>

Traverses all reachable nodes and also continue revisiting them as long the visitor returns GraphTraversalAction::Continue. The visitor is responsible for the runtime complexity and eventual termination of the traversal. This corresponds to computing a fixed point state for the graph.

Nodes are (re)visited according to the returned priority of the node, prioritizing high values. This priority is intended to be used a heuristic to reduce the number of retraversals.

• entries - The entry modules to start the traversal from
• state - The state to be passed to the callbacks
• visit - Called for a specific edge
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Return GraphTraversalActions to control the traversal
• priority - Called for before visiting the children of a node to determine its priority.
  • Receives: target &SingleModuleGraphNode, state &S
  • Return a priority value for the node

Returns the number of node visits (i.e. higher than the node count if there are retraversals).

pub fn iter_reachable_modules( &self, ) -> Result<impl Iterator<Item = ResolvedVc<Box<dyn Module>>>>

Iterates all reachable modules in the graph, ignoring unused and traced references.

pub fn iter_reachable_nodes<'a>( &'a self, ) -> Result<impl Iterator<Item = &'a SingleModuleGraphNode> + 'a>

Iterates all reachable nodes in the graph, ignoring unused and traced references. This includes VisitedModule nodes (which means that some modules are returned twice).

Trait Implementations

impl TraceRawVcs for ModuleGraphSnapshot

fn trace_raw_vcs(&self, __context__: &mut TraceRawVcsContext)

fn get_raw_vcs(&self) -> Vec<RawVc>

impl ValueDebugFormat for ModuleGraphSnapshot

Available on debug-assertions enabled only.

fn value_debug_format<'a>(&'a self, depth: usize) -> ValueDebugFormatString<'a>

impl NonLocalValue for ModuleGraphSnapshot