Function patience_diff_recursive

atomic-core/src/diff/patience.rs:108–151

Recursively apply patience diff to a region. # Arguments `old` - Slice of the old sequence for this region `new` - Slice of the new sequence for this region `old_offset` - Offset of this region in the original old sequence `new_offset` - Offset of this region in the original new sequence

(
    old: &[Line<'a>],
    new: &[Line<'a>],
    old_offset: usize,
    new_offset: usize,
)

/// * `old_offset` - Offset of this region in the original old sequence
/// * `new_offset` - Offset of this region in the original new sequence
fn patience_diff_recursive<'a>(
    old: &[Line<'a>],
    new: &[Line<'a>],
    old_offset: usize,
    new_offset: usize,
) -> DiffResult {
    // Base cases
    if old.is_empty() && new.is_empty() {
        return DiffResult::new();
    }
    if old.is_empty() {
        let mut result = DiffResult::new();
        result.push(DiffOp::insert(old_offset, new_offset, new.len()));
        return result;
    }
    if new.is_empty() {
        let mut result = DiffResult::new();
        result.push(DiffOp::delete(old_offset, new_offset, old.len()));
        return result;
    }

    // Find unique lines and their matches
    let matches = find_unique_matches(old, new);

    if matches.is_empty() {
        // No unique matches - fall back to Myers
        let mut result = myers::diff(old, new);
        result.adjust_offsets(old_offset);
        return result;
    }

    // Find the Longest Increasing Subsequence of matches
    let lis = longest_increasing_subsequence(&matches);

    if lis.is_empty() {
        // No LIS (shouldn't happen if matches is non-empty, but be safe)
        let mut result = myers::diff(old, new);
        result.adjust_offsets(old_offset);
        return result;
    }

    // Build the diff by processing regions between LIS anchors
    diff_with_anchors(old, new, old_offset, new_offset, &lis)
}

/// A match between unique lines in old and new sequences.
#[derive(Debug, Clone, Copy)]