ryo-analysis 0.1.0

//! DataFlowGraphV2 - Data-Oriented Design implementation of DataFlowGraph.
//!
//! Key improvements over V1:
//! - **String-free**: Uses SymbolId instead of String for variable names
//! - **SoA (Structure of Arrays)**: Cache-efficient data layout
//! - **Arena-based indexing**: No petgraph dependency
//! - **Inverted index**: O(1) symbol → variables lookup

use super::var_id::{VarId, VarSymbolMapping};
use crate::define_index;
use crate::symbol::{SymbolId, SymbolRegistry};
use serde::{Deserialize, Serialize};
use slotmap::SecondaryMap;
use smallvec::SmallVec;
use std::collections::{HashMap, HashSet};

// Import V2 trackers
use super::borrow_v2::{
    ActiveBorrowV2, BorrowAnalysis, BorrowConflict, BorrowKind, BorrowTrackerV2, MoveError,
};
use super::lock_v2::LockTrackerV2;

// ============================================================
// Shared Vocabulary Types
// ============================================================

/// Kind of data flow.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum FlowKind {
    // === Value Flow ===
    /// Value is assigned: `target = source`.
    Assign,
    /// Value is derived/computed: `target = f(source)`.
    Derive,
    /// Value is read from source.
    Read,
    /// Value is written to target.
    Write,
    /// Value is returned from function.
    Return,
    /// Value is passed as argument.
    Argument,
    /// Value flows through a reference (legacy, prefer SharedBorrow/MutBorrow).
    Reference,
    /// Value flows through a dereference.
    Dereference,
    /// Conditional flow (if/match guard).
    Conditional,

    // === Ownership/Borrow Flow (Rust-specific) ===
    /// Shared borrow: `&source`.
    SharedBorrow,
    /// Mutable borrow: `&mut source`.
    MutBorrow,
    /// Ownership transfer (move): `target = source` where source is not Copy.
    Move,
    /// Clone operation: `target = source.clone()`.
    Clone,
    /// Copy operation: `target = source` where source is Copy.
    Copy,
    /// Drop/scope end: value goes out of scope.
    Drop,
    /// Reborrow: borrowing from an existing reference.
    Reborrow,
    /// Index operation: `collection[index]`.
    Index,
}

impl FlowKind {
    /// Check if this flow kind transfers ownership.
    pub fn transfers_ownership(&self) -> bool {
        matches!(self, FlowKind::Move | FlowKind::Return)
    }

    /// Check if this flow kind creates a borrow.
    pub fn is_borrow(&self) -> bool {
        matches!(
            self,
            FlowKind::SharedBorrow | FlowKind::MutBorrow | FlowKind::Reborrow
        )
    }

    /// Check if this flow kind is a mutable operation.
    pub fn is_mutable(&self) -> bool {
        matches!(
            self,
            FlowKind::MutBorrow | FlowKind::Write | FlowKind::Assign
        )
    }
}

/// Kind of variable.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum VarKind {
    /// Local variable.
    Local,
    /// Function parameter.
    Parameter,
    /// Struct field.
    Field,
    /// Static or const.
    Static,
    /// Return value.
    Return,
    /// Temporary/intermediate value.
    Temp,
}

/// Edge in the data flow graph with detailed information.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct FlowEdge {
    /// Flow kind.
    pub kind: FlowKind,
    /// Line number where this flow occurs (0 if unknown).
    pub line: u32,
}

/// Variable node with name and metadata.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VarNode {
    /// Variable name.
    pub name: String,
    /// Variable kind.
    pub kind: VarKind,
    /// Line number where defined (0 if unknown).
    pub line: u32,
}

/// Statistics about the data flow graph.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DataFlowStats {
    /// Total number of variables.
    pub var_count: usize,
    /// Total number of flow edges.
    pub flow_count: usize,
    /// Variables by kind.
    pub vars_by_kind: HashMap<String, usize>,
    /// Flows by kind.
    pub flows_by_kind: HashMap<String, usize>,
}

/// A chain of flow steps from source to target.
#[derive(Debug, Clone)]
pub struct FlowChain {
    /// Steps in the chain (variable indices with flow kinds).
    pub steps: Vec<FlowStep>,
}

/// A single step in a flow chain.
#[derive(Debug, Clone)]
pub struct FlowStep {
    /// Variable index at this step.
    pub var_id: VarId,
    /// Flow kind to next step (None for last step).
    pub flow_kind: Option<FlowKind>,
}

// ============================================================
// Index Types
// ============================================================

define_index! {
    /// Index into the flows array.
    pub struct FlowId;
}

define_index! {
    /// Index into the scopes array.
    pub struct ScopeId;
}

// ============================================================
// Scope & Guard Types
// ============================================================

/// Kind of scope in control flow.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ScopeKind {
    /// Function / method body (root scope).
    Function,
    /// `if cond { ← here }`
    IfThen,
    /// `if cond { } else { ← here }`
    IfElse,
    /// `while cond { ← here }`
    WhileBody,
    /// `for pat in iter { ← here }`
    ForBody,
    /// `loop { ← here }`
    LoopBody,
    /// `match expr { pat => { ← here } }`
    MatchArm,
    /// Plain block `{ ← here }`
    Block,
    /// Closure `|x| { ← here }`
    Closure,
}

/// A scope node in the scope tree.
#[derive(Debug, Clone)]
pub struct ScopeData {
    /// Parent scope (None for root / Function scope).
    pub parent: Option<ScopeId>,
    /// What kind of scope this is.
    pub kind: ScopeKind,
    /// Guard constraint imposed by the enclosing condition (if any).
    pub guard: Option<Guard>,
}

/// A conditional guard that constrains variables within a scope.
#[derive(Debug, Clone)]
pub struct Guard {
    /// What kind of constraint.
    pub kind: GuardKind,
    /// Names of constrained variables (e.g., "i", "idx").
    pub var_names: SmallVec<[String; 2]>,
}

/// Kind of guard condition.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GuardKind {
    /// `left < right` (e.g., `i < arr.len()`)
    LessThan,
    /// `left <= right`
    LessEqual,
    /// `left > right`
    GreaterThan,
    /// `left >= right`
    GreaterEqual,
    /// `if let Some(x) = expr`
    LetSome,
    /// `if let Ok(x) = expr`
    LetOk,
    /// `expr.is_some()`
    IsSome,
    /// `expr.is_ok()`
    IsOk,
    /// Non-empty check (e.g., `!v.is_empty()`)
    NonEmpty,
}

// ============================================================
// Data Structures (SoA - Structure of Arrays)
// ============================================================

/// Variable data (12 bytes) - DOD optimized.
///
/// Each variable is identified by its SymbolId (registered via `SymbolRegistry::register_var`).
/// The parent symbol and variable name can be retrieved via the SymbolRegistry.
///
/// # DOD Design
///
/// - `parent`: Reference to containing symbol (function/method/struct)
/// - `kind`: Variable classification
/// - `line`: Source location for diagnostics
/// - `is_mut`: Whether binding was declared `let mut` (set by builder from
///   `PurePattern::Ident { is_mut }`, used by UnnecessaryClone to suppress FPs
///   on mutable working copies)
///
/// Variable's SymbolId is stored in `VarSymbolMapping` (VarId ↔ SymbolId).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct VarData {
    /// Parent symbol (function, method, struct, etc.) that contains this variable.
    pub parent: SymbolId,
    /// Variable kind (parameter, local, temp, field, etc.).
    pub kind: VarKind,
    /// Line number where defined (0 = unknown).
    pub line: u32,
    /// Whether the binding is declared `mut` (e.g. `let mut x = ...`).
    pub is_mut: bool,
}

/// Flow edge data (8 bytes).
///
/// Represents a directed edge from one variable to another.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FlowEdgeData {
    /// Source variable index.
    pub from: VarId,
    /// Target variable index.
    pub to: VarId,
}

/// Flow metadata.
///
/// Additional information about a flow edge.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FlowData {
    /// Flow kind.
    pub kind: FlowKind,
    /// Line number where this flow occurs (0 = unknown).
    pub line: u32,
    /// Scope in which this flow occurs.
    pub scope: ScopeId,
}

// ============================================================
// DataFlowGraphV2
// ============================================================

/// 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
///
/// ```text
/// 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
/// ```
#[derive(Debug, Clone, Default)]
pub struct DataFlowGraphV2 {
    // === Data Storage (SecondaryMap for stable VarId keys) ===
    /// Variable data (keyed by VarId from var_mapping).
    vars: SecondaryMap<VarId, VarData>,

    /// Variable names (keyed by VarId).
    var_names: SecondaryMap<VarId, String>,

    /// Flow metadata array.
    flows: Vec<FlowData>,

    /// Flow edge array (parallel to flows).
    edges: Vec<FlowEdgeData>,

    // === Scope Tree ===
    /// Scope hierarchy (control flow scopes with guards).
    scopes: Vec<ScopeData>,

    // === Adjacency Lists (SecondaryMap for stable VarId keys) ===
    /// Outgoing flows for each variable.
    outgoing: SecondaryMap<VarId, SmallVec<[FlowId; 4]>>,

    /// Incoming flows for each variable.
    incoming: SecondaryMap<VarId, SmallVec<[FlowId; 4]>>,

    // === Lookup Tables ===
    /// VarId ↔ SymbolId mapping (SlotMap-based, supports deletion).
    var_mapping: VarSymbolMapping,

    /// Containing symbol → variable list.
    symbol_to_vars: HashMap<SymbolId, SmallVec<[VarId; 8]>>,

    // === Trackers ===
    /// Borrow state tracking.
    borrow_tracker: BorrowTrackerV2,

    /// Lock acquisition tracking.
    lock_tracker: LockTrackerV2,
}

impl DataFlowGraphV2 {
    /// Create a new empty graph.
    pub fn new() -> Self {
        Self::default()
    }

    /// Create with pre-allocated capacity.
    pub fn with_capacity(var_capacity: usize, flow_capacity: usize) -> Self {
        Self {
            vars: SecondaryMap::new(),
            var_names: SecondaryMap::new(),
            flows: Vec::with_capacity(flow_capacity),
            edges: Vec::with_capacity(flow_capacity),
            scopes: Vec::new(),
            outgoing: SecondaryMap::new(),
            incoming: SecondaryMap::new(),
            var_mapping: VarSymbolMapping::with_capacity(var_capacity),
            symbol_to_vars: HashMap::with_capacity(var_capacity / 4),
            borrow_tracker: BorrowTrackerV2::new(),
            lock_tracker: LockTrackerV2::new(),
        }
    }

    // ========== Variable Operations ==========

    /// 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 add_var(
        &mut self,
        data: VarData,
        name: String,
        var_symbol_id: Option<SymbolId>,
    ) -> VarId {
        let var_id = match var_symbol_id {
            Some(sid) => self.var_mapping.register(sid),
            None => self.var_mapping.allocate(),
        };

        // Insert into SecondaryMaps (keyed by VarId)
        self.vars.insert(var_id, data);
        self.var_names.insert(var_id, name);
        self.outgoing.insert(var_id, SmallVec::new());
        self.incoming.insert(var_id, SmallVec::new());

        // Update symbol_to_vars index (group by parent symbol)
        self.symbol_to_vars
            .entry(data.parent)
            .or_default()
            .push(var_id);

        var_id
    }

    /// Get variable data by VarId.
    #[inline]
    pub fn var(&self, id: VarId) -> Option<&VarData> {
        self.vars.get(id)
    }

    /// Get variable name by VarId.
    #[inline]
    pub fn var_name(&self, id: VarId) -> Option<&str> {
        self.var_names.get(id).map(|s| s.as_str())
    }

    /// Get mutable variable data by VarId.
    #[inline]
    pub fn var_mut(&mut self, id: VarId) -> Option<&mut VarData> {
        self.vars.get_mut(id)
    }

    /// Get all variables for a containing symbol.
    #[inline]
    pub fn vars_in_symbol(&self, symbol: SymbolId) -> &[VarId] {
        self.symbol_to_vars
            .get(&symbol)
            .map(|v| v.as_slice())
            .unwrap_or(&[])
    }

    /// Get the number of variables.
    #[inline]
    pub fn var_count(&self) -> usize {
        self.vars.len()
    }

    // ========== Flow Operations ==========

    /// Add a flow edge between two variables.
    ///
    /// Returns the FlowId for the new flow.
    pub fn add_flow(&mut self, from: VarId, to: VarId, data: FlowData) -> FlowId {
        let flow_id = FlowId::from_raw(self.flows.len() as u32);

        self.flows.push(data);
        self.edges.push(FlowEdgeData { from, to });

        // Update adjacency lists (SecondaryMap - direct key access)
        if let Some(out) = self.outgoing.get_mut(from) {
            out.push(flow_id);
        }
        if let Some(inc) = self.incoming.get_mut(to) {
            inc.push(flow_id);
        }

        flow_id
    }

    /// Get flow data by FlowId.
    #[inline]
    pub fn flow(&self, id: FlowId) -> Option<&FlowData> {
        self.flows.get(id.as_usize())
    }

    /// Get flow edge by FlowId.
    #[inline]
    pub fn edge(&self, id: FlowId) -> Option<&FlowEdgeData> {
        self.edges.get(id.as_usize())
    }

    /// Get the number of flows.
    #[inline]
    pub fn flow_count(&self) -> usize {
        self.flows.len()
    }

    // ========== Graph Traversal ==========

    /// Get outgoing flows from a variable.
    #[inline]
    pub fn outgoing(&self, var: VarId) -> &[FlowId] {
        self.outgoing.get(var).map(|v| v.as_slice()).unwrap_or(&[])
    }

    /// Get incoming flows to a variable.
    #[inline]
    pub fn incoming(&self, var: VarId) -> &[FlowId] {
        self.incoming.get(var).map(|v| v.as_slice()).unwrap_or(&[])
    }

    /// Get target variables that receive values from this variable.
    pub fn successors(&self, var: VarId) -> impl Iterator<Item = VarId> + '_ {
        self.outgoing(var)
            .iter()
            .filter_map(|&flow_id| self.edges.get(flow_id.as_usize()).map(|e| e.to))
    }

    /// Get source variables that provide values to this variable.
    pub fn predecessors(&self, var: VarId) -> impl Iterator<Item = VarId> + '_ {
        self.incoming(var)
            .iter()
            .filter_map(|&flow_id| self.edges.get(flow_id.as_usize()).map(|e| e.from))
    }

    // ========== Analysis Helpers ==========

    /// Find all variables that this variable's value flows to (transitive).
    ///
    /// Impact analysis: "If I change this variable, what else is affected?"
    pub fn impact(&self, start: VarId) -> Vec<VarId> {
        let mut visited: HashSet<VarId> = HashSet::new();
        let mut result = Vec::new();
        let mut stack = vec![start];

        while let Some(var) = stack.pop() {
            if visited.contains(&var) {
                continue;
            }
            visited.insert(var);
            result.push(var);

            for next in self.successors(var) {
                if !visited.contains(&next) {
                    stack.push(next);
                }
            }
        }

        result
    }

    /// Find all variables that contribute to this variable's value (transitive).
    ///
    /// Provenance analysis: "Where does this value come from?"
    pub fn provenance(&self, start: VarId) -> Vec<VarId> {
        let mut visited: HashSet<VarId> = HashSet::new();
        let mut result = Vec::new();
        let mut stack = vec![start];

        while let Some(var) = stack.pop() {
            if visited.contains(&var) {
                continue;
            }
            visited.insert(var);
            result.push(var);

            for prev in self.predecessors(var) {
                if !visited.contains(&prev) {
                    stack.push(prev);
                }
            }
        }

        result
    }

    // ========== Lookup ==========

    /// Convert VarId to SymbolId.
    #[inline]
    pub fn var_to_symbol(&self, var: VarId) -> Option<SymbolId> {
        self.var_mapping.to_symbol(var)
    }

    /// Convert SymbolId to VarId.
    #[inline]
    pub fn symbol_to_var(&self, symbol: SymbolId) -> Option<VarId> {
        self.var_mapping.to_var(symbol)
    }

    /// Iterate over all variables.
    pub fn iter_vars(&self) -> impl Iterator<Item = (VarId, &VarData)> {
        self.vars.iter()
    }

    /// 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 resolve_vars(
        &self,
        symbol_id: Option<SymbolId>,
        name: Option<&str>,
        registry: &SymbolRegistry,
    ) -> Option<(Vec<VarId>, String)> {
        if let Some(sid) = symbol_id {
            let vars = self.vars_in_symbol(sid).to_vec();
            let display = registry
                .resolve(sid)
                .map(|p| p.name().to_string())
                .unwrap_or_else(|| format!("{:?}", sid));
            return Some((vars, display));
        }

        let name = name?;

        // Step 1: Registry name → SymbolId → vars_in_symbol (O(1) per symbol)
        let symbol_ids = registry.find_by_name(name);
        let mut vars = Vec::new();
        for &sid in &symbol_ids {
            vars.extend_from_slice(self.vars_in_symbol(sid));
        }
        if !vars.is_empty() {
            return Some((vars, name.to_string()));
        }

        // Step 2: Fallback to dataflow variable name substring search
        let vars: Vec<VarId> = self
            .iter_vars()
            .filter_map(|(var_id, _)| {
                self.var_name(var_id).and_then(|n| {
                    if n == name || n.contains(name) {
                        Some(var_id)
                    } else {
                        None
                    }
                })
            })
            .collect();
        Some((vars, name.to_string()))
    }

    /// Iterate over all flows.
    pub fn iter_flows(&self) -> impl Iterator<Item = (FlowId, &FlowData, &FlowEdgeData)> {
        self.flows
            .iter()
            .zip(self.edges.iter())
            .enumerate()
            .map(|(i, (data, edge))| (FlowId::from_raw(i as u32), data, edge))
    }

    /// Clear all data.
    pub fn clear(&mut self) {
        self.vars.clear();
        self.var_names.clear();
        self.flows.clear();
        self.edges.clear();
        self.scopes.clear();
        self.outgoing.clear();
        self.incoming.clear();
        self.var_mapping.clear();
        self.symbol_to_vars.clear();
        self.borrow_tracker.clear();
        self.lock_tracker.clear();
    }

    /// 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 clear_for_symbols(&mut self, symbols: &[SymbolId]) {
        for &symbol_id in symbols {
            // Get and remove the list of VarIds for this symbol
            if let Some(var_ids) = self.symbol_to_vars.remove(&symbol_id) {
                for var_id in var_ids {
                    // Remove variable data
                    self.vars.remove(var_id);
                    self.var_names.remove(var_id);
                    self.outgoing.remove(var_id);
                    self.incoming.remove(var_id);

                    // Remove from var_mapping (bidirectional)
                    self.var_mapping.remove(var_id);
                }
            }
        }

        // Note: We don't compact flows/edges arrays here.
        // Stale edges referencing removed VarIds are orphaned but harmless.
        // A full rebuild or periodic compaction can clean them up if needed.
    }

    // ========== Scope Operations ==========

    /// Add a scope to the scope tree. Returns the ScopeId.
    pub fn add_scope(&mut self, data: ScopeData) -> ScopeId {
        let id = ScopeId::from_raw(self.scopes.len() as u32);
        self.scopes.push(data);
        id
    }

    /// Get scope data by ScopeId.
    #[inline]
    pub fn scope(&self, id: ScopeId) -> Option<&ScopeData> {
        self.scopes.get(id.as_usize())
    }

    /// Get the number of scopes.
    #[inline]
    pub fn scope_count(&self) -> usize {
        self.scopes.len()
    }

    // ========== Guard Queries ==========

    /// 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 is_guarded(&self, var_name: &str, scope: ScopeId, kinds: &[GuardKind]) -> bool {
        let mut current = Some(scope);
        while let Some(sid) = current {
            if let Some(scope_data) = self.scopes.get(sid.as_usize()) {
                if let Some(guard) = &scope_data.guard {
                    if kinds.contains(&guard.kind) && guard.var_names.iter().any(|n| n == var_name)
                    {
                        return true;
                    }
                }
                current = scope_data.parent;
            } else {
                break;
            }
        }
        false
    }

    /// Collect all guards active in the scope chain (from scope up to root).
    pub fn active_guards(&self, scope: ScopeId) -> Vec<&Guard> {
        let mut guards = Vec::new();
        let mut current = Some(scope);
        while let Some(sid) = current {
            if let Some(scope_data) = self.scopes.get(sid.as_usize()) {
                if let Some(guard) = &scope_data.guard {
                    guards.push(guard);
                }
                current = scope_data.parent;
            } else {
                break;
            }
        }
        guards
    }

    /// Find all flows of a given kind within a symbol.
    pub fn flows_of_kind_in_symbol(
        &self,
        symbol_id: SymbolId,
        kind: FlowKind,
    ) -> Vec<(FlowId, &FlowData, &FlowEdgeData)> {
        let var_ids = self.vars_in_symbol(symbol_id);
        let mut result = Vec::new();
        for &var_id in var_ids {
            for &flow_id in self.outgoing(var_id) {
                if let (Some(flow), Some(edge)) = (self.flow(flow_id), self.edge(flow_id)) {
                    if flow.kind == kind {
                        result.push((flow_id, flow, edge));
                    }
                }
            }
        }
        result
    }

    // ========== Tracker Access ==========

    /// Get the borrow tracker.
    #[inline]
    pub fn borrow_tracker(&self) -> &BorrowTrackerV2 {
        &self.borrow_tracker
    }

    /// Get mutable access to the borrow tracker.
    #[inline]
    pub fn borrow_tracker_mut(&mut self) -> &mut BorrowTrackerV2 {
        &mut self.borrow_tracker
    }

    /// Get the lock tracker.
    #[inline]
    pub fn lock_tracker(&self) -> &LockTrackerV2 {
        &self.lock_tracker
    }

    /// Get mutable access to the lock tracker.
    #[inline]
    pub fn lock_tracker_mut(&mut self) -> &mut LockTrackerV2 {
        &mut self.lock_tracker
    }

    // ========== Borrow Tracking Convenience Methods ==========

    /// Add a borrow relationship.
    pub fn add_borrow(&mut self, source: VarId, borrow: VarId, kind: BorrowKind, line: u32) {
        self.borrow_tracker.add_borrow(source, borrow, kind, line);
    }

    /// End a borrow at a specific line.
    pub fn end_borrow(&mut self, borrow: VarId, line: u32) {
        self.borrow_tracker.end_borrow(borrow, line);
    }

    /// Query borrow conflicts for a variable.
    pub fn borrow_conflicts(
        &self,
        source: VarId,
        kind: BorrowKind,
        at_line: u32,
    ) -> Vec<BorrowConflict> {
        self.borrow_tracker.conflicts(source, kind, at_line)
    }

    // ========== Borrow Analysis ==========

    /// 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
    pub fn borrow_analysis(&self, symbol_id: SymbolId) -> BorrowAnalysis {
        let mut conflicts = Vec::new();
        let mut move_errors = Vec::new();

        let var_ids = self.vars_in_symbol(symbol_id);

        // Track active borrows and moves for each variable
        let mut active_borrows: HashMap<VarId, Vec<(VarId, BorrowKind, u32)>> = HashMap::new();
        let mut moved_vars: HashMap<VarId, u32> = HashMap::new();

        for &var_id in var_ids {
            for &flow_id in self.outgoing(var_id) {
                if let (Some(flow), Some(edge)) = (self.flow(flow_id), self.edge(flow_id)) {
                    match flow.kind {
                        FlowKind::SharedBorrow => {
                            let source = edge.from;
                            let borrower = edge.to;
                            if let Some(borrows) = active_borrows.get(&source) {
                                for &(existing_borrower, existing_kind, existing_line) in borrows {
                                    if existing_kind.conflicts_with(BorrowKind::Shared) {
                                        conflicts.push(BorrowConflict::new(
                                            source,
                                            ActiveBorrowV2::new(
                                                existing_borrower,
                                                existing_kind,
                                                existing_line,
                                            ),
                                            BorrowKind::Shared,
                                            flow.line,
                                        ));
                                    }
                                }
                            }
                            active_borrows.entry(source).or_default().push((
                                borrower,
                                BorrowKind::Shared,
                                flow.line,
                            ));
                        }
                        FlowKind::MutBorrow => {
                            let source = edge.from;
                            let borrower = edge.to;
                            if let Some(borrows) = active_borrows.get(&source) {
                                for &(existing_borrower, existing_kind, existing_line) in borrows {
                                    conflicts.push(BorrowConflict::new(
                                        source,
                                        ActiveBorrowV2::new(
                                            existing_borrower,
                                            existing_kind,
                                            existing_line,
                                        ),
                                        BorrowKind::Mutable,
                                        flow.line,
                                    ));
                                }
                            }
                            active_borrows.entry(source).or_default().push((
                                borrower,
                                BorrowKind::Mutable,
                                flow.line,
                            ));
                        }
                        FlowKind::Move => {
                            let source = edge.from;
                            moved_vars.insert(source, flow.line);
                        }
                        FlowKind::Read | FlowKind::Derive => {
                            let source = edge.from;
                            if let Some(&move_line) = moved_vars.get(&source) {
                                if flow.line > move_line {
                                    move_errors.push(MoveError {
                                        variable: source,
                                        moved_at: move_line,
                                        used_at: flow.line,
                                    });
                                }
                            }
                        }
                        FlowKind::Drop => {
                            let source = edge.from;
                            active_borrows.remove(&source);
                        }
                        _ => {}
                    }
                }
            }
        }

        BorrowAnalysis {
            conflicts,
            move_errors,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use slotmap::SlotMap;

    fn setup_symbols() -> (
        SlotMap<SymbolId, &'static str>,
        SymbolId,
        SymbolId,
        SymbolId,
    ) {
        let mut symbols: SlotMap<SymbolId, &str> = SlotMap::with_key();
        let fn_sym = symbols.insert("my_fn");
        let x_sym = symbols.insert("x");
        let y_sym = symbols.insert("y");
        (symbols, fn_sym, x_sym, y_sym)
    }

    #[test]
    fn test_add_var() {
        let (_symbols, fn_sym, x_sym, _y_sym) = setup_symbols();
        let mut graph = DataFlowGraphV2::new();

        let var_id = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 10,
                is_mut: false,
            },
            "x".to_string(),
            Some(x_sym),
        );

        assert_eq!(graph.var_count(), 1);
        let data = graph.var(var_id).unwrap();
        assert_eq!(data.parent, fn_sym);
        assert_eq!(data.kind, VarKind::Local);
        assert_eq!(data.line, 10);
        assert_eq!(graph.var_name(var_id), Some("x"));
        // var_symbol is now accessed via var_to_symbol()
        assert_eq!(graph.var_to_symbol(var_id), Some(x_sym));
    }

    #[test]
    fn test_add_flow() {
        let (_symbols, fn_sym, x_sym, y_sym) = setup_symbols();
        let mut graph = DataFlowGraphV2::new();

        let x = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 10,
                is_mut: false,
            },
            "x".to_string(),
            Some(x_sym),
        );

        let y = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 11,
                is_mut: false,
            },
            "y".to_string(),
            Some(y_sym),
        );

        let flow_id = graph.add_flow(
            x,
            y,
            FlowData {
                kind: FlowKind::Assign,
                line: 11,
                scope: ScopeId::from_raw(0),
            },
        );

        assert_eq!(graph.flow_count(), 1);

        let edge = graph.edge(flow_id).unwrap();
        assert_eq!(edge.from, x);
        assert_eq!(edge.to, y);

        let flow = graph.flow(flow_id).unwrap();
        assert_eq!(flow.kind, FlowKind::Assign);
    }

    #[test]
    fn test_successors_predecessors() {
        let (_symbols, fn_sym, x_sym, y_sym) = setup_symbols();
        let mut graph = DataFlowGraphV2::new();

        let x = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 10,
                is_mut: false,
            },
            "x".to_string(),
            Some(x_sym),
        );

        let y = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 11,
                is_mut: false,
            },
            "y".to_string(),
            Some(y_sym),
        );

        graph.add_flow(
            x,
            y,
            FlowData {
                kind: FlowKind::Assign,
                line: 11,
                scope: ScopeId::from_raw(0),
            },
        );

        // x → y
        let succs: Vec<_> = graph.successors(x).collect();
        assert_eq!(succs, vec![y]);

        let preds: Vec<_> = graph.predecessors(y).collect();
        assert_eq!(preds, vec![x]);
    }

    #[test]
    fn test_vars_in_symbol() {
        let (_symbols, fn_sym, x_sym, y_sym) = setup_symbols();
        let mut graph = DataFlowGraphV2::new();

        let x = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 10,
                is_mut: false,
            },
            "x".to_string(),
            Some(x_sym),
        );

        let y = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 11,
                is_mut: false,
            },
            "y".to_string(),
            Some(y_sym),
        );

        let vars = graph.vars_in_symbol(fn_sym);
        assert_eq!(vars.len(), 2);
        assert!(vars.contains(&x));
        assert!(vars.contains(&y));
    }

    #[test]
    fn test_impact_analysis() {
        let mut symbols: SlotMap<SymbolId, &str> = SlotMap::with_key();
        let fn_sym = symbols.insert("my_fn");
        let a_sym = symbols.insert("a");
        let b_sym = symbols.insert("b");
        let c_sym = symbols.insert("c");

        let mut graph = DataFlowGraphV2::new();

        let a = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 1,
                is_mut: false,
            },
            "a".to_string(),
            Some(a_sym),
        );
        let b = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 2,
                is_mut: false,
            },
            "b".to_string(),
            Some(b_sym),
        );
        let c = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 3,
                is_mut: false,
            },
            "c".to_string(),
            Some(c_sym),
        );

        // a → b → c
        graph.add_flow(
            a,
            b,
            FlowData {
                kind: FlowKind::Assign,
                line: 2,
                scope: ScopeId::from_raw(0),
            },
        );
        graph.add_flow(
            b,
            c,
            FlowData {
                kind: FlowKind::Assign,
                line: 3,
                scope: ScopeId::from_raw(0),
            },
        );

        let impact = graph.impact(a);
        assert_eq!(impact.len(), 3);
        assert!(impact.contains(&a));
        assert!(impact.contains(&b));
        assert!(impact.contains(&c));
    }

    #[test]
    fn test_provenance_analysis() {
        let mut symbols: SlotMap<SymbolId, &str> = SlotMap::with_key();
        let fn_sym = symbols.insert("my_fn");
        let a_sym = symbols.insert("a");
        let b_sym = symbols.insert("b");
        let c_sym = symbols.insert("c");

        let mut graph = DataFlowGraphV2::new();

        let a = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 1,
                is_mut: false,
            },
            "a".to_string(),
            Some(a_sym),
        );
        let b = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 2,
                is_mut: false,
            },
            "b".to_string(),
            Some(b_sym),
        );
        let c = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 3,
                is_mut: false,
            },
            "c".to_string(),
            Some(c_sym),
        );

        // a → b → c
        graph.add_flow(
            a,
            b,
            FlowData {
                kind: FlowKind::Assign,
                line: 2,
                scope: ScopeId::from_raw(0),
            },
        );
        graph.add_flow(
            b,
            c,
            FlowData {
                kind: FlowKind::Assign,
                line: 3,
                scope: ScopeId::from_raw(0),
            },
        );

        let provenance = graph.provenance(c);
        assert_eq!(provenance.len(), 3);
        assert!(provenance.contains(&a));
        assert!(provenance.contains(&b));
        assert!(provenance.contains(&c));
    }

    #[test]
    fn test_add_var_without_symbol_id_produces_distinct_vars() {
        let mut symbols: SlotMap<SymbolId, &str> = SlotMap::with_key();
        let fn_sym = symbols.insert("my_fn");

        let mut graph = DataFlowGraphV2::new();

        // Two local variables without their own SymbolId (e.g., lookup_var_symbol failed)
        let x = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 10,
                is_mut: false,
            },
            "x".to_string(),
            None,
        );
        let y = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 11,
                is_mut: false,
            },
            "y".to_string(),
            None,
        );

        // Must produce distinct VarIds
        assert_ne!(x, y, "Different variables must get different VarIds");

        // Each must retain its own name
        assert_eq!(graph.var_name(x), Some("x"));
        assert_eq!(graph.var_name(y), Some("y"));

        // Both should appear in the graph
        assert_eq!(graph.var_count(), 2);

        // No reverse SymbolId lookup for anonymous vars
        assert_eq!(graph.var_to_symbol(x), None);
        assert_eq!(graph.var_to_symbol(y), None);
    }

    #[test]
    fn test_add_var_with_symbol_id_still_works() {
        let mut symbols: SlotMap<SymbolId, &str> = SlotMap::with_key();
        let fn_sym = symbols.insert("my_fn");
        let x_sym = symbols.insert("x");

        let mut graph = DataFlowGraphV2::new();

        let var_id = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 10,
                is_mut: false,
            },
            "x".to_string(),
            Some(x_sym),
        );

        assert_eq!(graph.var_count(), 1);
        assert_eq!(graph.var_name(var_id), Some("x"));
        assert_eq!(graph.var_to_symbol(var_id), Some(x_sym));
    }

    #[test]
    fn test_vars_for_symbol_with_anonymous_vars() {
        let mut symbols: SlotMap<SymbolId, &str> = SlotMap::with_key();
        let fn_sym = symbols.insert("my_fn");

        let mut graph = DataFlowGraphV2::new();

        let x = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 10,
                is_mut: false,
            },
            "x".to_string(),
            None,
        );
        let y = graph.add_var(
            VarData {
                parent: fn_sym,
                kind: VarKind::Local,
                line: 11,
                is_mut: false,
            },
            "y".to_string(),
            None,
        );

        // Both vars should appear under the parent symbol
        let vars = graph.vars_in_symbol(fn_sym);
        assert_eq!(vars.len(), 2);
        assert!(vars.contains(&x));
        assert!(vars.contains(&y));
    }
}