Struct ModuleGraph 

pub struct ModuleGraph { /* private fields */ }

The ReadRef version of ModuleGraphBase. This is better for eventual consistency, as the graphs aren’t awaited multiple times within the same task.

Implementations

impl ModuleGraph

pub fn cell(self) -> Vc<Self>

Places a value in a cell of the current task.

Cell is selected based on the value type and call order of cell.

pub fn resolved_cell(self) -> ResolvedVc<Self>

Places a value in a cell of the current task. Returns a ResolvedVc.

Cell is selected based on the value type and call order of cell.

impl ModuleGraph

pub fn from_single_graph( graph: OperationVc<SingleModuleGraph>, ) -> OperationVc<Self>

pub fn from_graphs( graphs: Vec<OperationVc<SingleModuleGraph>>, ) -> OperationVc<Self>

pub fn from_single_graph_without_unused_references( graph: OperationVc<SingleModuleGraph>, binding_usage: OperationVc<BindingUsageInfo>, ) -> OperationVc<Self>

Analyze the module graph and remove unused references (by determining the used exports and removing unused imports).

In particular, this removes ModuleReference-s that list only unused exports in the import_usage()

pub fn from_graphs_without_unused_references( graphs: Vec<OperationVc<SingleModuleGraph>>, binding_usage: OperationVc<BindingUsageInfo>, ) -> OperationVc<Self>

Analyze the module graph and remove unused references (by determining the used exports and removing unused imports).

In particular, this removes ModuleReference-s that list only unused exports in the import_usage()

pub fn chunk_group_info(self: Vc<Self>) -> Vc<ChunkGroupInfo>

pub fn merged_modules(self: Vc<Self>) -> Vc<MergedModuleInfo>

pub fn module_batches( self: Vc<Self>, config: Vc<BatchingConfig>, ) -> Vc<ModuleBatchesGraph>

pub fn style_groups( self: Vc<Self>, chunking_context: Vc<Box<dyn ChunkingContext>>, config: StyleGroupsConfig, ) -> Vc<StyleGroups>

pub fn async_module_info(self: Vc<Self>) -> Vc<AsyncModulesInfo>

pub fn referenced_async_modules( self: Vc<Self>, module: Vc<Box<dyn Module>>, ) -> Vc<AsyncModuleInfo>

pub fn iter_graphs(self: Vc<Self>) -> Vc<ModuleGraphLayers>

Returns the underlying graphs as a list, to be used for individual graph traversals.

Methods from Deref<Target = ModuleGraphSnapshot>

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

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

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

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<()>, ) -> 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).

Trait Implementations

impl Deref for ModuleGraph

type Target = ModuleGraphSnapshot

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl ShrinkToFit for ModuleGraph

fn shrink_to_fit(&mut self)

impl TraceRawVcs for ModuleGraph

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

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

impl ValueDebug for ModuleGraph

fn dbg(self: Vc<Self>) -> Vc<ValueDebugString>

fn dbg_depth(self: Vc<Self>, depth: usize) -> Vc<ValueDebugString>

Like dbg, but with a depth limit.

impl ValueDebugFormat for ModuleGraph

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

impl VcValueType for ModuleGraph

type Read = VcDefaultRead<ModuleGraph>

How to read the value.

type CellMode = VcCellNewMode<ModuleGraph>

How to update cells of this value type.

fn get_value_type_id() -> ValueTypeId

Returns the type id of the value type.

fn has_serialization() -> bool

impl NonLocalValue for ModuleGraph

impl Upcast<Box<dyn ValueDebug>> for ModuleGraph

impl UpcastStrict<Box<dyn ValueDebug>> for ModuleGraph