Struct ModuleGraph 

pub struct ModuleGraph {
    pub modules: Vec<ModuleNode>,
    pub package_usage: HashMap<String, Vec<FileId>, FxBuildHasher>,
    pub type_only_package_usage: HashMap<String, Vec<FileId>, FxBuildHasher>,
    pub entry_points: HashSet<FileId, FxBuildHasher>,
    pub runtime_entry_points: HashSet<FileId, FxBuildHasher>,
    pub test_entry_points: HashSet<FileId, FxBuildHasher>,
    pub reverse_deps: Vec<Vec<FileId>>,
    /* private fields */
}

The core module dependency graph.

Fields

modules: Vec<ModuleNode>

All modules indexed by FileId.

Invariant: modules[file_id.0 as usize].file_id == file_id for every FileId in the graph. Holds because discover/walk.rs assigns FileIds sequentially via .enumerate() after path-sorting, and build::populate_edges pushes one ModuleNode per file in iteration order. Detectors rely on this for O(1) FileId-to-module lookup (graph.modules.get(file_id.0 as usize)) instead of building a per-call FxHashMap<FileId, &ModuleNode>.

package_usage: HashMap<String, Vec<FileId>, FxBuildHasher>

Maps npm package names to the set of FileIds that import them.

type_only_package_usage: HashMap<String, Vec<FileId>, FxBuildHasher>

Maps npm package names to the set of FileIds that import them with type-only imports. A package appearing here but not in package_usage (or only in both) indicates it’s only used for types and could be a devDependency.

entry_points: HashSet<FileId, FxBuildHasher>

All entry point FileIds.

runtime_entry_points: HashSet<FileId, FxBuildHasher>

Runtime/application entry point FileIds.

test_entry_points: HashSet<FileId, FxBuildHasher>

Test entry point FileIds.

reverse_deps: Vec<Vec<FileId>>

Reverse index: for each FileId, which files import it.

Implementations

impl ModuleGraph

pub fn find_cycles(&self) -> Vec<Vec<FileId>>

Find all circular dependency cycles in the module graph.

Uses an iterative implementation of Tarjan’s strongly connected components algorithm (O(V + E)) to find all SCCs with 2 or more nodes. Each such SCC represents a set of files involved in a circular dependency.

Returns cycles sorted by length (shortest first), with files within each cycle sorted by path for deterministic output.

Panics

Panics if the internal file-to-path lookup is inconsistent with the module list.

impl ModuleGraph

pub fn build( resolved_modules: &[ResolvedModule], entry_points: &[EntryPoint], files: &[DiscoveredFile], ) -> ModuleGraph

Build the module graph from resolved modules and entry points.

pub fn build_with_reachability_roots( resolved_modules: &[ResolvedModule], entry_points: &[EntryPoint], runtime_entry_points: &[EntryPoint], test_entry_points: &[EntryPoint], files: &[DiscoveredFile], ) -> ModuleGraph

Build the module graph with explicit runtime and test reachability roots.

pub const fn module_count(&self) -> usize

Total number of modules.

pub const fn edge_count(&self) -> usize

Total number of edges.

pub fn has_namespace_import(&self, file_id: FileId) -> bool

Check if any importer uses import * as ns for this module. Uses precomputed bitset — O(1) lookup.

pub fn edges_for(&self, file_id: FileId) -> Vec<FileId>

Get the target FileIds of all outgoing edges for a module.

pub fn find_import_span_start( &self, source: FileId, target: FileId, ) -> Option<u32>

Find the byte offset of the first import statement from source to target. Returns None if no edge exists or the edge has no symbols.

pub fn outgoing_edge_summaries( &self, file_id: FileId, ) -> impl Iterator<Item = (FileId, bool, Option<u32>)>

Iterate outgoing edges with the data the boundary detector needs in a single pass: target file id, whether every symbol on the edge is type-only (matches the predicate used by cycle detection), and the span start of the first value-carrying symbol (or the first symbol when every symbol is type-only).

The span pick differs from find_import_span_start (which always returns the first symbol’s span). When featureB has both import type { Foo } from './x' and import { bar } from './x', fallow groups them into ONE edge with the type-only symbol first and the value symbol second. The boundary detector needs the span of the value symbol so that the violation is anchored on the runtime import line; otherwise a // fallow-ignore-next-line above the type-only line would silently suppress the real violation (and conversely, the violation would point at a line that doesn’t actually carry the offending runtime dependency).

Returns an empty iterator for out-of-range file ids.

Trait Implementations

impl Debug for ModuleGraph

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

Formats the value using the given formatter.