ryo-analysis 0.1.0

//! BorrowTrackerV2 - VarId-based borrow tracking for DataFlowGraphV2.
//!
//! Key improvements over V1:
//! - Uses VarId instead of petgraph::NodeIndex
//! - Integrates seamlessly with DataFlowGraphV2
//! - Same borrow conflict detection semantics

use super::var_id::VarId;
use smallvec::SmallVec;
use std::collections::HashMap;
use std::fmt;

// ============================================================================
// Borrow Kind (shared vocabulary)
// ============================================================================

/// Kind of borrow.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BorrowKind {
    /// Shared/immutable borrow (&T).
    Shared,
    /// Mutable borrow (&mut T).
    Mutable,
}

impl BorrowKind {
    /// Check if this borrow conflicts with another.
    ///
    /// Mutable borrows conflict with everything.
    /// Shared borrows only conflict with mutable borrows.
    pub fn conflicts_with(&self, other: BorrowKind) -> bool {
        matches!(
            (self, other),
            (BorrowKind::Mutable, _) | (_, BorrowKind::Mutable)
        )
    }
}

// ============================================================================
// Borrow State V2
// ============================================================================

/// The ownership/borrow state of a variable (V2 - uses VarId).
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub enum BorrowStateV2 {
    /// Variable owns its value (T).
    #[default]
    Owned,

    /// Variable is a shared reference (&T).
    SharedRef {
        /// The variable being borrowed from.
        source: VarId,
        /// Line where the borrow started.
        start_line: u32,
    },

    /// Variable is a mutable reference (&mut T).
    MutRef {
        /// The variable being borrowed from.
        source: VarId,
        /// Line where the borrow started.
        start_line: u32,
    },

    /// Ownership has been moved to another variable.
    Moved {
        /// The variable that now owns the value.
        to: VarId,
        /// Line where the move occurred.
        at_line: u32,
    },

    /// Variable has been dropped (out of scope).
    Dropped {
        /// Line where the drop occurred.
        at_line: u32,
    },

    /// Copy semantics - value was copied, original still valid.
    Copied {
        /// The variable that received the copy.
        to: VarId,
        /// Line where the copy occurred.
        at_line: u32,
    },
}

impl BorrowStateV2 {
    /// Check if the variable can be used (read).
    pub fn can_read(&self) -> bool {
        matches!(
            self,
            BorrowStateV2::Owned
                | BorrowStateV2::SharedRef { .. }
                | BorrowStateV2::MutRef { .. }
                | BorrowStateV2::Copied { .. }
        )
    }

    /// Check if the variable can be mutated.
    pub fn can_mutate(&self) -> bool {
        matches!(self, BorrowStateV2::Owned | BorrowStateV2::MutRef { .. })
    }

    /// Check if the variable has been invalidated (moved or dropped).
    pub fn is_invalidated(&self) -> bool {
        matches!(
            self,
            BorrowStateV2::Moved { .. } | BorrowStateV2::Dropped { .. }
        )
    }

    /// Check if this is a reference (shared or mutable).
    pub fn is_reference(&self) -> bool {
        matches!(
            self,
            BorrowStateV2::SharedRef { .. } | BorrowStateV2::MutRef { .. }
        )
    }

    /// Get the source variable if this is a reference.
    pub fn borrow_source(&self) -> Option<VarId> {
        match self {
            BorrowStateV2::SharedRef { source, .. } | BorrowStateV2::MutRef { source, .. } => {
                Some(*source)
            }
            _ => None,
        }
    }
}

// ============================================================================
// Active Borrow V2
// ============================================================================

/// Represents an active borrow of a variable (V2 - uses VarId).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ActiveBorrowV2 {
    /// The variable that holds the borrow (the reference variable).
    pub borrower: VarId,
    /// The kind of borrow.
    pub kind: BorrowKind,
    /// Line where the borrow started.
    pub start_line: u32,
    /// Line where the borrow ended (None = still active).
    pub end_line: Option<u32>,
}

impl ActiveBorrowV2 {
    /// Create a new active borrow.
    pub fn new(borrower: VarId, kind: BorrowKind, start_line: u32) -> Self {
        Self {
            borrower,
            kind,
            start_line,
            end_line: None,
        }
    }

    /// Check if this borrow is still active at the given line.
    pub fn is_active_at(&self, line: u32) -> bool {
        line >= self.start_line && self.end_line.is_none_or(|end| line < end)
    }

    /// End this borrow at the given line.
    pub fn end_at(&mut self, line: u32) {
        self.end_line = Some(line);
    }

    /// Check if this borrow conflicts with a new borrow.
    pub fn conflicts_with(&self, new_kind: BorrowKind, at_line: u32) -> bool {
        self.is_active_at(at_line) && self.kind.conflicts_with(new_kind)
    }
}

// ============================================================================
// Borrow Conflict
// ============================================================================

/// A detected borrow conflict.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BorrowConflict {
    /// The variable being borrowed.
    pub variable: VarId,
    /// The existing borrow that conflicts.
    pub existing: ActiveBorrowV2,
    /// The new borrow kind that was attempted.
    pub new_kind: BorrowKind,
    /// Line where the new borrow was attempted.
    pub new_line: u32,
}

impl BorrowConflict {
    /// Create a new borrow conflict.
    pub fn new(
        variable: VarId,
        existing: ActiveBorrowV2,
        new_kind: BorrowKind,
        new_line: u32,
    ) -> Self {
        Self {
            variable,
            existing,
            new_kind,
            new_line,
        }
    }
}

impl fmt::Display for BorrowConflict {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let existing_kind = match self.existing.kind {
            BorrowKind::Shared => "shared",
            BorrowKind::Mutable => "mutable",
        };
        let new_kind = match self.new_kind {
            BorrowKind::Shared => "shared",
            BorrowKind::Mutable => "mutable",
        };

        if self.existing.kind == BorrowKind::Mutable && self.new_kind == BorrowKind::Mutable {
            write!(
                f,
                "cannot borrow as mutable more than once: \
                 first borrow at line {}, second borrow at line {}",
                self.existing.start_line, self.new_line
            )
        } else {
            write!(
                f,
                "cannot borrow as {} because already borrowed as {}: \
                 existing borrow at line {}, new borrow at line {}",
                new_kind, existing_kind, self.existing.start_line, self.new_line
            )
        }
    }
}

// ============================================================================
// Move Error
// ============================================================================

/// A use-after-move error.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MoveError {
    /// The variable that was moved.
    pub variable: VarId,
    /// Line where the move occurred.
    pub moved_at: u32,
    /// Line where the invalid use occurred.
    pub used_at: u32,
}

impl fmt::Display for MoveError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "use of moved value: moved at line {}, used at line {}",
            self.moved_at, self.used_at
        )
    }
}

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

/// Result of borrow analysis for a symbol.
#[derive(Debug, Clone)]
pub struct BorrowAnalysis {
    /// Borrow conflicts found.
    pub conflicts: Vec<BorrowConflict>,
    /// Use-after-move errors found.
    pub move_errors: Vec<MoveError>,
}

impl BorrowAnalysis {
    /// Check if there are any issues.
    pub fn has_issues(&self) -> bool {
        !self.conflicts.is_empty() || !self.move_errors.is_empty()
    }

    /// Get total issue count.
    pub fn issue_count(&self) -> usize {
        self.conflicts.len() + self.move_errors.len()
    }
}

// ============================================================================
// Borrow Tracker V2
// ============================================================================

/// Tracks active borrows for a set of variables (V2 - uses VarId).
///
/// Integrates with DataFlowGraphV2 for borrow conflict detection.
#[derive(Debug, Clone, Default)]
pub struct BorrowTrackerV2 {
    /// Active borrows indexed by the borrowed variable.
    /// Uses SmallVec since most variables have 0-2 borrows.
    borrows: HashMap<VarId, SmallVec<[ActiveBorrowV2; 2]>>,
}

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

    /// Create with pre-allocated capacity.
    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            borrows: HashMap::with_capacity(capacity),
        }
    }

    /// Add a borrow.
    ///
    /// Returns any conflicts with existing borrows.
    pub fn add_borrow(
        &mut self,
        source: VarId,
        borrower: VarId,
        kind: BorrowKind,
        line: u32,
    ) -> Vec<BorrowConflict> {
        let conflicts = self.conflicts(source, kind, line);

        self.borrows
            .entry(source)
            .or_default()
            .push(ActiveBorrowV2::new(borrower, kind, line));

        conflicts
    }

    /// End a borrow.
    pub fn end_borrow(&mut self, borrower: VarId, line: u32) {
        for borrows in self.borrows.values_mut() {
            for borrow in borrows.iter_mut() {
                if borrow.borrower == borrower && borrow.end_line.is_none() {
                    borrow.end_at(line);
                }
            }
        }
    }

    /// Query conflicts with a potential new borrow.
    pub fn conflicts(&self, source: VarId, kind: BorrowKind, at_line: u32) -> Vec<BorrowConflict> {
        self.borrows
            .get(&source)
            .map(|borrows| {
                borrows
                    .iter()
                    .filter(|b| b.conflicts_with(kind, at_line))
                    .map(|b| BorrowConflict::new(source, b.clone(), kind, at_line))
                    .collect()
            })
            .unwrap_or_default()
    }

    /// Get all active borrows of a variable at a given line.
    pub fn active_borrows_at(&self, source: VarId, line: u32) -> Vec<&ActiveBorrowV2> {
        self.borrows
            .get(&source)
            .map(|borrows| borrows.iter().filter(|b| b.is_active_at(line)).collect())
            .unwrap_or_default()
    }

    /// Get all active borrows of a variable (regardless of line).
    pub fn active_borrows(&self, source: VarId) -> &[ActiveBorrowV2] {
        self.borrows
            .get(&source)
            .map(|v| v.as_slice())
            .unwrap_or(&[])
    }

    /// Clear all borrows.
    pub fn clear(&mut self) {
        self.borrows.clear();
    }

    /// Check if any borrows are currently active for a variable.
    pub fn has_active_borrows(&self, source: VarId, at_line: u32) -> bool {
        self.borrows
            .get(&source)
            .map(|borrows| borrows.iter().any(|b| b.is_active_at(at_line)))
            .unwrap_or(false)
    }

    /// Check if a mutable borrow is active for a variable.
    pub fn has_active_mut_borrow(&self, source: VarId, at_line: u32) -> bool {
        self.borrows
            .get(&source)
            .map(|borrows| {
                borrows
                    .iter()
                    .any(|b| b.is_active_at(at_line) && b.kind == BorrowKind::Mutable)
            })
            .unwrap_or(false)
    }

    /// Get the number of tracked variables.
    pub fn tracked_var_count(&self) -> usize {
        self.borrows.len()
    }

    /// Get the total number of borrows (active and ended).
    pub fn total_borrow_count(&self) -> usize {
        self.borrows.values().map(|v| v.len()).sum()
    }
}

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

    /// Test helper to create VarIds from a shared mapping.
    struct TestVars {
        symbols: SlotMap<SymbolId, &'static str>,
        mapping: super::super::var_id::VarSymbolMapping,
    }

    impl TestVars {
        fn new() -> Self {
            Self {
                symbols: SlotMap::with_key(),
                mapping: super::super::var_id::VarSymbolMapping::new(),
            }
        }

        fn var(&mut self, name: &'static str) -> VarId {
            let sym = self.symbols.insert(name);
            self.mapping.register(sym)
        }
    }

    #[test]
    fn test_borrow_state_can_read() {
        let mut vars = TestVars::new();
        let v = vars.var("v");

        assert!(BorrowStateV2::Owned.can_read());
        assert!(BorrowStateV2::SharedRef {
            source: v,
            start_line: 1
        }
        .can_read());
        assert!(BorrowStateV2::MutRef {
            source: v,
            start_line: 1
        }
        .can_read());
        assert!(!BorrowStateV2::Moved { to: v, at_line: 1 }.can_read());
        assert!(!BorrowStateV2::Dropped { at_line: 1 }.can_read());
    }

    #[test]
    fn test_borrow_state_can_mutate() {
        let mut vars = TestVars::new();
        let v = vars.var("v");

        assert!(BorrowStateV2::Owned.can_mutate());
        assert!(BorrowStateV2::MutRef {
            source: v,
            start_line: 1
        }
        .can_mutate());
        assert!(!BorrowStateV2::SharedRef {
            source: v,
            start_line: 1
        }
        .can_mutate());
        assert!(!BorrowStateV2::Moved { to: v, at_line: 1 }.can_mutate());
    }

    #[test]
    fn test_active_borrow_is_active_at() {
        let mut vars = TestVars::new();
        let borrower = vars.var("borrower");
        let mut borrow = ActiveBorrowV2::new(borrower, BorrowKind::Shared, 10);

        assert!(borrow.is_active_at(10));
        assert!(borrow.is_active_at(15));
        assert!(borrow.is_active_at(100));
        assert!(!borrow.is_active_at(5));

        borrow.end_at(20);
        assert!(borrow.is_active_at(10));
        assert!(borrow.is_active_at(15));
        assert!(!borrow.is_active_at(20));
        assert!(!borrow.is_active_at(25));
    }

    #[test]
    fn test_borrow_tracker_no_conflict_shared() {
        let mut tracker = BorrowTrackerV2::new();
        let mut vars = TestVars::new();
        let source = vars.var("source");
        let b1 = vars.var("b1");
        let b2 = vars.var("b2");

        // Multiple shared borrows should not conflict
        let conflicts = tracker.add_borrow(source, b1, BorrowKind::Shared, 10);
        assert!(conflicts.is_empty());

        let conflicts = tracker.add_borrow(source, b2, BorrowKind::Shared, 15);
        assert!(conflicts.is_empty());
    }

    #[test]
    fn test_borrow_tracker_conflict_mut_mut() {
        let mut tracker = BorrowTrackerV2::new();
        let mut vars = TestVars::new();
        let source = vars.var("source");
        let b1 = vars.var("b1");
        let b2 = vars.var("b2");

        let conflicts = tracker.add_borrow(source, b1, BorrowKind::Mutable, 10);
        assert!(conflicts.is_empty());

        // Second mutable borrow should conflict
        let conflicts = tracker.add_borrow(source, b2, BorrowKind::Mutable, 15);
        assert_eq!(conflicts.len(), 1);
        assert_eq!(conflicts[0].existing.borrower, b1);
        assert_eq!(conflicts[0].new_kind, BorrowKind::Mutable);
    }

    #[test]
    fn test_borrow_tracker_conflict_shared_then_mut() {
        let mut tracker = BorrowTrackerV2::new();
        let mut vars = TestVars::new();
        let source = vars.var("source");
        let b1 = vars.var("b1");
        let b2 = vars.var("b2");

        let conflicts = tracker.add_borrow(source, b1, BorrowKind::Shared, 10);
        assert!(conflicts.is_empty());

        // Mutable borrow while shared borrow is active should conflict
        let conflicts = tracker.add_borrow(source, b2, BorrowKind::Mutable, 15);
        assert_eq!(conflicts.len(), 1);
    }

    #[test]
    fn test_borrow_tracker_end_borrow() {
        let mut tracker = BorrowTrackerV2::new();
        let mut vars = TestVars::new();
        let source = vars.var("source");
        let borrower = vars.var("borrower");
        let b2 = vars.var("b2");

        tracker.add_borrow(source, borrower, BorrowKind::Mutable, 10);
        tracker.end_borrow(borrower, 20);

        // After ending the borrow, new mutable borrow should not conflict
        let conflicts = tracker.add_borrow(source, b2, BorrowKind::Mutable, 25);
        assert!(conflicts.is_empty());
    }

    #[test]
    fn test_borrow_tracker_has_active_borrows() {
        let mut tracker = BorrowTrackerV2::new();
        let mut vars = TestVars::new();
        let source = vars.var("source");
        let borrower = vars.var("borrower");

        assert!(!tracker.has_active_borrows(source, 10));

        tracker.add_borrow(source, borrower, BorrowKind::Shared, 10);
        assert!(tracker.has_active_borrows(source, 15));

        tracker.end_borrow(borrower, 20);
        assert!(!tracker.has_active_borrows(source, 25));
    }

    #[test]
    fn test_borrow_tracker_stats() {
        let mut tracker = BorrowTrackerV2::new();
        let mut vars = TestVars::new();
        let s1 = vars.var("s1");
        let s2 = vars.var("s2");
        let b1 = vars.var("b1");
        let b2 = vars.var("b2");
        let b3 = vars.var("b3");

        tracker.add_borrow(s1, b1, BorrowKind::Shared, 10);
        tracker.add_borrow(s1, b2, BorrowKind::Shared, 15);
        tracker.add_borrow(s2, b3, BorrowKind::Mutable, 20);

        assert_eq!(tracker.tracked_var_count(), 2);
        assert_eq!(tracker.total_borrow_count(), 3);
    }
}