Function common_affixes

atomic-core/src/diff/mod.rs:471–515

Find the length of common prefix and suffix between two sequences, applying the **suffix-limiting heuristic** used by the display path. This optimization significantly speeds up diffing when changes are localized to a small portion of the file. # Suffix Limiting The suffix is reduced if stripping it would leave one middle section empty while the other still has content. In that case, the diff a

(old: &[T], new: &[T])

/// heuristic is helpful for displaying diffs to users but corrupts
/// patch-theory graph semantics.
fn common_affixes<T: PartialEq>(old: &[T], new: &[T]) -> (usize, usize) {
    // Common prefix
    let prefix_len = old
        .iter()
        .zip(new.iter())
        .take_while(|(a, b)| a == b)
        .count();

    // Common suffix (but don't overlap with prefix)
    let remaining_old = old.len() - prefix_len;
    let remaining_new = new.len() - prefix_len;
    let max_suffix = remaining_old.min(remaining_new);

    let suffix_len = old[prefix_len..]
        .iter()
        .rev()
        .zip(new[prefix_len..].iter().rev())
        .take(max_suffix)
        .take_while(|(a, b)| a == b)
        .count();

    // Don't let the suffix strip make one middle section empty while the
    // other still has content. That hides modifications as pure inserts
    // or pure deletes — the diff algorithm needs both sides non-empty
    // to detect Replace operations.
    let old_mid = remaining_old - suffix_len;
    let new_mid = remaining_new - suffix_len;

    if (old_mid == 0) != (new_mid == 0) {
        // One side is empty, the other isn't. Reduce suffix until both
        // sides have content (or suffix is zero).
        let mut reduced = suffix_len;
        while reduced > 0 {
            reduced -= 1;
            let om = remaining_old - reduced;
            let nm = remaining_new - reduced;
            if (om > 0 && nm > 0) || reduced == 0 {
                return (prefix_len, reduced);
            }
        }
        return (prefix_len, 0);
    }

    (prefix_len, suffix_len)
}

/// Diff two byte slices as text, splitting on newlines.
///