fix is_odd condition to ensure optimal number of iterations are used│

Cargo.toml

@@ -17,7 +17,7 @@ exclude = [
 ]
 
 [dependencies]
-hashbrown = { version = "0.15", default-features = false, features = ["default-hasher", "inline-more"] }
+hashbrown = { version = ">=0.15,<=0.16", default-features = false, features = ["default-hasher", "inline-more"] }
 memchr = "2.7.4"
 
 [features]
@@ -26,6 +26,7 @@ unified_diff = []
 
 [dev-dependencies]
 # criterion = "0.4.0"
+cov-mark = "2.1.0"
 expect-test = "1.4.0"
 # git-repository = "0.25.0"
 # similar = { version = "2.2.0", features = ["bytes"] }

src/myers.rs

@@ -99,7 +99,7 @@ impl Myers {
             unsafe { MiddleSnakeSearch::<false>::new(self.kforward, file1, file2) };
         let mut backwards_search =
             unsafe { MiddleSnakeSearch::<true>::new(self.kbackward, file1, file2) };
-        let is_odd = (file2.len() - file2.len()) & 1 != 0;
+        let is_odd = file2.len().wrapping_sub(file1.len()) & 1 != 0;
 
         let mut ec = 0;
 
@@ -111,6 +111,8 @@ impl Myers {
                     backwards_search.contains(k)
                         && backwards_search.x_pos_at_diagonal(k) <= token_idx1
                 }) {
+                    #[cfg(test)]
+                    cov_mark::hit!(ODD_SPLIT);
                     match res {
                         SearchResult::Snake => found_snake = true,
                         SearchResult::Found {
@@ -135,6 +137,8 @@ impl Myers {
                 if let Some(res) = backwards_search.run(file1, file2, |k, token_idx1| {
                     forward_search.contains(k) && token_idx1 <= forward_search.x_pos_at_diagonal(k)
                 }) {
+                    #[cfg(test)]
+                    cov_mark::hit!(EVEN_SPLIT);
                     match res {
                         SearchResult::Snake => found_snake = true,
                         SearchResult::Found {

src/myers/middle_snake.rs

@@ -6,6 +6,7 @@ use crate::util::{common_postfix, common_prefix};
 const SNAKE_CNT: u32 = 20;
 const K_HEUR: u32 = 4;
 
+#[derive(Debug)]
 pub struct MiddleSnakeSearch<const BACK: bool> {
     kvec: NonNull<i32>,
     kmin: i32,
@@ -98,6 +99,8 @@ impl<const BACK: bool> MiddleSnakeSearch<BACK> {
         let mut res = None;
         let mut k = self.kmax;
         while k >= self.kmin {
+            #[cfg(test)]
+            cov_mark::hit!(SPLIT_SEARCH_ITER);
             let mut token_idx1 = if BACK {
                 if self.x_pos_at_diagonal(k - 1) < self.x_pos_at_diagonal(k + 1) {
                     self.x_pos_at_diagonal(k - 1)
@@ -249,6 +252,7 @@ impl<const BACK: bool> MiddleSnakeSearch<BACK> {
     }
 }
 
+#[derive(Debug)]
 pub enum SearchResult {
     Snake,
     Found { token_idx1: i32, token_idx2: i32 },

src/tests.rs

@@ -118,6 +118,71 @@ fn foo() -> Bar{
     }
 }
 
+#[test]
+fn myers_is_odd() {
+    let before = "a\nb\nx\ny\nx\n";
+    let after = "b\na\nx\ny\n";
+
+    cov_mark::check!(ODD_SPLIT);
+    // if the check for odd doesn't work then
+    // we still find the correct result but the number of search
+    // iterations increases
+    cov_mark::check_count!(SPLIT_SEARCH_ITER, 9);
+    let input = InternedInput::new(before, after);
+    let diff = Diff::compute(Algorithm::Myers, &input);
+    expect![[r#"
+        @@ -1,5 +1,4 @@
+        -a
+         b
+        +a
+         x
+         y
+        -x
+    "#]]
+    .assert_eq(
+        &diff
+            .unified_diff(
+                &BasicLineDiffPrinter(&input.interner),
+                UnifiedDiffConfig::default(),
+                &input,
+            )
+            .to_string(),
+    );
+}
+#[test]
+fn myers_is_even() {
+    let before = "a\nb\nx\nx\ny\n";
+    let after = "b\na\nx\ny\nx\n";
+
+    cov_mark::check!(EVEN_SPLIT);
+    // if the check for is_odd incorrectly always true then we take a fastpath
+    // when we shouldn't which always leads to inifite iterations/recursion
+    // still we check the number of iterations here in case the search
+    // is buggy in more subtle ways
+    cov_mark::check_count!(SPLIT_SEARCH_ITER, 15);
+    let input = InternedInput::new(before, after);
+    let diff = Diff::compute(Algorithm::Myers, &input);
+    expect![[r#"
+        @@ -1,5 +1,5 @@
+        -a
+         b
+        -x
+        +a
+         x
+         y
+        +x
+    "#]]
+    .assert_eq(
+        &diff
+            .unified_diff(
+                &BasicLineDiffPrinter(&input.interner),
+                UnifiedDiffConfig::default(),
+                &input,
+            )
+            .to_string(),
+    );
+}
+
 #[test]
 fn identical_files() {
     let file = r#"fn foo() -> Bar{