Function rewrite_positional_shifts

atomic-core/src/diff/mod.rs:259–389

Rewrite diff ops to convert positional shifts into Replace operations. When a line appears at the same content but a different position, and there are insertions that "pushed" it down, this is better represented as a modification of the original line plus an insertion of the new copy.

(
    result: DiffResult,
    old: &[Line<'a>],
    new: &[Line<'a>],
)

/// there are insertions that "pushed" it down, this is better represented
/// as a modification of the original line plus an insertion of the new copy.
fn rewrite_positional_shifts<'a>(
    result: DiffResult,
    old: &[Line<'a>],
    new: &[Line<'a>],
) -> DiffResult {
    let ops = result.ops();
    if ops.len() < 2 {
        return result;
    }

    let mut new_ops: Vec<DiffOp> = Vec::with_capacity(ops.len());
    let mut i = 0;

    while i < ops.len() {
        // Look for pattern: Insert then Equal where the Equal's old_pos
        // matches where the Insert landed (the line "shifted down")
        if i + 1 < ops.len() {
            if let (
                DiffOp::Insert {
                    old_pos: ins_old_pos,
                    new_pos: ins_new_pos,
                    len: ins_len,
                },
                DiffOp::Equal {
                    old_pos: eq_old_pos,
                    new_pos: eq_new_pos,
                    len: eq_len,
                },
            ) = (&ops[i], &ops[i + 1])
            {
                // The Equal starts at the same old position as the Insert,
                // meaning the Insert "pushed" the Equal line to a new position.
                // AND the Equal maps to a different new position than old position
                // (the line shifted).
                if *eq_old_pos == *ins_old_pos && *eq_new_pos > *eq_old_pos {
                    // The Insert occupies the old position, and the Equal
                    // line was "pushed down". This MIGHT be a modification
                    // (user changed the line and a copy of the old content
                    // ended up below it). We only rewrite when the inserted
                    // content is SIMILAR to the old line — sharing tokens
                    // indicates a word-level edit (e.g. "line two" → "line three").
                    // If the content is completely different, it's a genuine
                    // insertion and we leave it alone.
                    let overlap = (*ins_len).min(*eq_len);

                    if overlap > 0 {
                        let mut rewrote = false;

                        for j in 0..overlap {
                            let o_idx = eq_old_pos + j;
                            let n_idx = ins_new_pos + j;
                            let eq_n_idx = eq_new_pos + j;

                            if o_idx < old.len() && n_idx < new.len() && old[o_idx] != new[n_idx] {
                                // Check similarity: the inserted line should share
                                // significant content with the old line to qualify
                                // as a modification. Compare tokens (words).
                                let old_content = old[o_idx].content_without_newline();