Function diff_with_options

atomic-core/src/diff/mod.rs:188–252

(
    old: &[Line<'a>],
    new: &[Line<'a>],
    algorithm: Algorithm,
    rewrite_shifts: bool,
)

}

fn diff_with_options<'a>(
    old: &[Line<'a>],
    new: &[Line<'a>],
    algorithm: Algorithm,
    rewrite_shifts: bool,
) -> DiffResult {
    // Optimization: strip common prefix and suffix.
    //
    // When `rewrite_shifts == false` (i.e. `diff_raw`, used by the
    // record/patch-theory path) we use the **strict** form that never
    // reduces the suffix to artificially force Replace detection.  This
    // preserves pure insertions/deletions, which is what graph
    // operations need.
    let (prefix_len, suffix_len) = if rewrite_shifts {
        common_affixes(old, new)
    } else {
        common_affixes_strict(old, new)
    };

    let old_mid = &old[prefix_len..old.len().saturating_sub(suffix_len)];
    let new_mid = &new[prefix_len..new.len().saturating_sub(suffix_len)];

    // If everything is equal, return early
    if old_mid.is_empty() && new_mid.is_empty() {
        return DiffResult::equal(old.len());
    }

    // Dispatch to the selected algorithm
    let mut ops = match algorithm {
        Algorithm::Myers => myers::diff(old_mid, new_mid),
        Algorithm::Patience => patience::diff(old_mid, new_mid),
    };

    // Adjust offsets for the stripped prefix
    ops.adjust_offsets(prefix_len);

    // Add the equal prefix and suffix
    if prefix_len > 0 {
        ops.prepend_equal(0, prefix_len);
    }
    if suffix_len > 0 {
        let old_start = old.len() - suffix_len;
        let new_start = new.len() - suffix_len;
        ops.append_equal(old_start, new_start, suffix_len);
    }

    // Post-process: detect positional shifts that should be Replace ops.
    //
    // Myers finds the minimal edit (LCS), which can match identical lines
    // at different positions. For example:
    //   old: [A, B]  new: [A, C, B]
    // Myers says: Equal(A), Insert(C), Equal(B) — treating B as "moved down".
    //
    // But if the user modified line 2 (B→C) and added a new line 3 (B),
    // the intent is: Equal(A), Replace(B→C), Insert(B).
    //
    // We detect this pattern: when an Equal op maps old_pos N to new_pos M
    // where M > N (line shifted down), AND there's an Insert immediately