fix: Don't create overlapping prefix_eq/suffix_eq in the LCS

Regressed in #89

Author: Markus Westerlind

diffus-derive-test/src/lib.rs

@@ -91,6 +91,33 @@ mod test {
         }
     }
 
+    #[test]
+    fn changed_contents() {
+        let left = vec![Identified { id: 1, value: 0 }];
+        let right = vec![Identified { id: 1, value: 1 }];
+
+        let diff = left.diff(&right);
+
+        use edit::{self, collection};
+
+        if let edit::Edit::Change(diff) = diff {
+            let diff = diff.into_iter().collect::<Vec<_>>();
+
+            assert_eq!(diff.len(), 1);
+
+            if let &collection::Edit::Change(EditedIdentified {
+                id: edit::Edit::Copy(&1),
+                value: edit::Edit::Change((&0, &1)),
+            }) = &diff[0]
+            {
+            } else {
+                unreachable!()
+            }
+        } else {
+            unreachable!()
+        }
+    }
+
     #[derive(Diffus)]
     enum NestedTest {
         T { test: Test },

diffus/src/lcs.rs

@@ -28,12 +28,32 @@ where
     I: DoubleEndedIterator<Item = T>,
     J: DoubleEndedIterator<Item = T>,
 {
-    let prefix_eq = x().zip(y()).take_while(|(x, y)| x.same(y)).count();
-    let suffix_eq = x()
-        .rev()
-        .zip(y().rev())
-        .take_while(|(x, y)| x.same(y))
-        .count();
+    let mut prefix_eq = 0;
+    let mut suffix_eq = 0;
+    {
+        let mut x_iter = x();
+        let mut y_iter = y();
+        // We must not compute an overlapping `prefix_eq` and `suffix_eq` so we only check the suffix
+        // if there is something that is not the same in the middle of the iterators
+        let mut check_suffix = false;
+        loop {
+            match (x_iter.next(), y_iter.next()) {
+                (Some(x), Some(y)) if x.same(&y) => prefix_eq += 1,
+                (Some(_), Some(_)) => {
+                    check_suffix = true;
+                    break;
+                }
+                (None, _) | (_, None) => break,
+            }
+        }
+        if check_suffix {
+            suffix_eq = x_iter
+                .rev()
+                .zip(y_iter.rev())
+                .take_while(|(x, y)| x.same(y))
+                .count();
+        }
+    }
 
     let width = x_len.saturating_sub(prefix_eq + suffix_eq) + 1;
     let height = y_len.saturating_sub(prefix_eq + suffix_eq) + 1;