Struct DataFlowGraphV2 

pub struct DataFlowGraphV2 { /* private fields */ }

Data flow graph with Data-Oriented Design.

Design Principles

1. SoA Layout: Variables and flows stored in separate arrays
2. String-free: Variable names are SymbolIds
3. Inverted Index: O(1) lookup from containing symbol to variables
4. Cache-friendly: Dense arrays for iteration
5. Integrated Trackers: BorrowTrackerV2 and LockTrackerV2 built-in

Memory Layout

DataFlowGraphV2
├── vars: SecondaryMap<VarId, VarData>   // Variable metadata
├── var_names: SecondaryMap<VarId, String>
├── flows: Vec<FlowData>                 // Flow metadata (with scope)
├── edges: Vec<FlowEdgeData>             // Flow edges (parallel to flows)
├── scopes: Vec<ScopeData>               // Scope tree
├── Adjacency Lists
│   ├── outgoing / incoming
├── Lookup Tables
│   ├── var_mapping: VarSymbolMapping
│   └── symbol_to_vars
└── Trackers
    ├── borrow_tracker
    └── lock_tracker

Implementations

impl DataFlowGraphV2

pub fn new() -> DataFlowGraphV2

Create a new empty graph.

pub fn with_capacity( var_capacity: usize, flow_capacity: usize, ) -> DataFlowGraphV2

Create with pre-allocated capacity.

pub fn add_var( &mut self, data: VarData, name: String, var_symbol_id: Option<SymbolId>, ) -> VarId

Add a variable to the graph.

Arguments

• data: Variable metadata (parent, kind, line)
• name: Variable name (for display/debugging)
• var_symbol_id: The variable’s SymbolId if registered in SymbolRegistry, or None for local variables not in the registry.

Returns

The VarId for referencing this variable in the dataflow graph.

pub fn var(&self, id: VarId) -> Option<&VarData>

Get variable data by VarId.

pub fn var_name(&self, id: VarId) -> Option<&str>

Get variable name by VarId.

pub fn var_mut(&mut self, id: VarId) -> Option<&mut VarData>

Get mutable variable data by VarId.

pub fn vars_in_symbol(&self, symbol: SymbolId) -> &[VarId]

Get all variables for a containing symbol.

pub fn var_count(&self) -> usize

Get the number of variables.

pub fn add_flow(&mut self, from: VarId, to: VarId, data: FlowData) -> FlowId

Add a flow edge between two variables.

Returns the FlowId for the new flow.

pub fn flow(&self, id: FlowId) -> Option<&FlowData>

Get flow data by FlowId.

pub fn edge(&self, id: FlowId) -> Option<&FlowEdgeData>

Get flow edge by FlowId.

pub fn flow_count(&self) -> usize

Get the number of flows.

pub fn outgoing(&self, var: VarId) -> &[FlowId]

Get outgoing flows from a variable.

pub fn incoming(&self, var: VarId) -> &[FlowId]

Get incoming flows to a variable.

pub fn successors(&self, var: VarId) -> impl Iterator<Item = VarId>

Get target variables that receive values from this variable.

pub fn predecessors(&self, var: VarId) -> impl Iterator<Item = VarId>

Get source variables that provide values to this variable.

pub fn impact(&self, start: VarId) -> Vec<VarId>

Find all variables that this variable’s value flows to (transitive).

Impact analysis: “If I change this variable, what else is affected?”

pub fn provenance(&self, start: VarId) -> Vec<VarId>

Find all variables that contribute to this variable’s value (transitive).

Provenance analysis: “Where does this value come from?”

pub fn var_to_symbol(&self, var: VarId) -> Option<SymbolId>

Convert VarId to SymbolId.

pub fn symbol_to_var(&self, symbol: SymbolId) -> Option<VarId>

Convert SymbolId to VarId.

pub fn iter_vars(&self) -> impl Iterator<Item = (VarId, &VarData)>

Iterate over all variables.

pub fn resolve_vars( &self, symbol_id: Option<SymbolId>, name: Option<&str>, registry: &SymbolRegistry, ) -> Option<(Vec<VarId>, String)>

Resolve variables by SymbolId or name with tiered fallback.

Resolution order:

1. symbol_id → O(1) lookup via vars_in_symbol
2. name → registry name lookup → vars_in_symbol for each match
3. name → fallback to dataflow variable name substring search

Returns (matching_vars, display_name) or None if neither input is provided.

pub fn iter_flows( &self, ) -> impl Iterator<Item = (FlowId, &FlowData, &FlowEdgeData)>

Iterate over all flows.

pub fn clear(&mut self)

Clear all data.

pub fn clear_for_symbols(&mut self, symbols: &[SymbolId])

Clear variables and flows for the given parent symbols.

Used for incremental updates: clear data for modified functions, then rebuild from the updated AST.

Note: This doesn’t compact the flow arrays (they may contain stale edges referencing removed VarIds). The edges are effectively orphaned and ignored since the VarIds no longer exist in var_mapping.

pub fn add_scope(&mut self, data: ScopeData) -> ScopeId

Add a scope to the scope tree. Returns the ScopeId.

pub fn scope(&self, id: ScopeId) -> Option<&ScopeData>

Get scope data by ScopeId.

pub fn scope_count(&self) -> usize

Get the number of scopes.

pub fn is_guarded( &self, var_name: &str, scope: ScopeId, kinds: &[GuardKind], ) -> bool

Check if a variable (by name) has a matching guard in the given scope or any ancestor.

Walks up the scope tree from scope looking for a guard whose kind is in kinds and whose var_names contains var_name.

pub fn active_guards(&self, scope: ScopeId) -> Vec<&Guard>

Collect all guards active in the scope chain (from scope up to root).

pub fn flows_of_kind_in_symbol( &self, symbol_id: SymbolId, kind: FlowKind, ) -> Vec<(FlowId, &FlowData, &FlowEdgeData)>

Find all flows of a given kind within a symbol.

pub fn borrow_tracker(&self) -> &BorrowTrackerV2

Get the borrow tracker.

pub fn borrow_tracker_mut(&mut self) -> &mut BorrowTrackerV2

Get mutable access to the borrow tracker.

pub fn lock_tracker(&self) -> &LockTrackerV2

Get the lock tracker.

pub fn lock_tracker_mut(&mut self) -> &mut LockTrackerV2

Get mutable access to the lock tracker.

pub fn add_borrow( &mut self, source: VarId, borrow: VarId, kind: BorrowKind, line: u32, )

Add a borrow relationship.

pub fn end_borrow(&mut self, borrow: VarId, line: u32)

End a borrow at a specific line.

pub fn borrow_conflicts( &self, source: VarId, kind: BorrowKind, at_line: u32, ) -> Vec<BorrowConflict>

Query borrow conflicts for a variable.

pub fn borrow_analysis(&self, symbol_id: SymbolId) -> BorrowAnalysis

Analyze borrow conflicts and use-after-move errors for a symbol.

Scans all flows within the symbol to detect:

• Simultaneous mutable borrows
• Mutable + shared borrow conflicts
• Use after move

Trait Implementations

impl Clone for DataFlowGraphV2

fn clone(&self) -> DataFlowGraphV2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataFlowGraphV2

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

Formats the value using the given formatter.

impl Default for DataFlowGraphV2

fn default() -> DataFlowGraphV2

Returns the “default value” for a type.