fix(compact): normalize stale diff op cursors

Author: mitsuhiko

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to similar are documented here.
 
 ## Unreleased
 
+* Fixed `Compact` emitting inconsistent `DiffOp` cursor positions after
+  compaction, which could leave `Delete`/`Insert` operations with stale
+  `new_index`/`old_index` values.
+
 ## 3.0.0
 
 * Added a Git-style Histogram diff implementation exposed as

src/algorithms/compact.rs

@@ -142,6 +142,56 @@ where
         }
         pointer += 1;
     }
+
+    normalize_diff_op_cursors(ops);
+}
+
+fn normalize_diff_op_cursors(ops: &mut [DiffOp]) {
+    let mut old_cursor = 0;
+    let mut new_cursor = 0;
+
+    if let Some(op) = ops.first() {
+        old_cursor = op.old_range().start;
+        new_cursor = op.new_range().start;
+    }
+
+    for op in ops.iter_mut() {
+        match op {
+            DiffOp::Equal {
+                old_index,
+                new_index,
+                len,
+            } => {
+                old_cursor = *old_index + *len;
+                new_cursor = *new_index + *len;
+            }
+            DiffOp::Delete {
+                old_index,
+                old_len,
+                new_index,
+            } => {
+                *new_index = new_cursor;
+                old_cursor = *old_index + *old_len;
+            }
+            DiffOp::Insert {
+                old_index,
+                new_index,
+                new_len,
+            } => {
+                *old_index = old_cursor;
+                new_cursor = *new_index + *new_len;
+            }
+            DiffOp::Replace {
+                old_index,
+                old_len,
+                new_index,
+                new_len,
+            } => {
+                old_cursor = *old_index + *old_len;
+                new_cursor = *new_index + *new_len;
+            }
+        }
+    }
 }
 
 fn shift_diff_ops_up<Old, New>(

src/common.rs

@@ -190,6 +190,28 @@ fn test_non_string_iter_change() {
     );
 }
 
+#[test]
+fn test_compact_keeps_diffop_cursors_contiguous() {
+    let a = vec![1, 1, 0, 2];
+    let b = vec![2, 1, 0, 0, 0, 0];
+    let ops = capture_diff_slices(Algorithm::Myers, &a, &b);
+
+    for i in 1..ops.len() {
+        let prev = &ops[i - 1];
+        let op = &ops[i];
+        assert_eq!(
+            op.old_range().start,
+            prev.old_range().end,
+            "old_index gap at op {i}: {prev:?} -> {op:?}"
+        );
+        assert_eq!(
+            op.new_range().start,
+            prev.new_range().end,
+            "new_index gap at op {i}: {prev:?} -> {op:?}"
+        );
+    }
+}
+
 #[test]
 fn test_myers_compacts_adjacent_deletes_issue_80() {
     let a: Vec<u8> = vec![0, 1, 0, 0, 0, 1, 2];