gix-blame: optimize process_changes to avoid redundant work

Change `process_changes` to take `&[Change]` instead of `Vec<Change>`,
eliminating the `changes.clone()` heap allocation at every call site.

Replace the O(H×C) restart-from-beginning approach with a cursor that
advances through the changes list across hunks. Non-suspect hunks are
now skipped immediately. When the rare case of overlapping suspect
ranges is detected (from merge blame convergence), the cursor safely
resets to maintain correctness.

Author: vmg

gix-blame/src/file/function.rs

@@ -334,7 +334,7 @@ pub fn incremental(
                         options.diff_algorithm,
                         &mut stats,
                     )?;
-                    hunks_to_blame = process_changes(hunks_to_blame, changes.clone(), suspect, *parent_id);
+                    hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, *parent_id);
                     if let Some(ref mut blame_path) = blame_path {
                         let has_blame_been_passed = hunks_to_blame.iter().any(|hunk| hunk.has_suspect(parent_id));
 
@@ -366,7 +366,7 @@ pub fn incremental(
                         options.diff_algorithm,
                         &mut stats,
                     )?;
-                    hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, *parent_id);
+                    hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, *parent_id);
 
                     let mut has_blame_been_passed = false;
 

gix-blame/src/file/mod.rs

@@ -322,24 +322,36 @@ fn process_change(
 /// Consume `hunks_to_blame` and `changes` to pair up matches ranges (also overlapping) with each other.
 /// Once a match is found, it's pushed onto `out`.
 ///
-/// `process_changes` assumes that ranges coming from the same *Source File* can and do
-/// occasionally overlap. If it were a desirable property of the blame algorithm as a whole to
-/// never have two different lines from a *Blamed File* mapped to the same line in a *Source File*,
-/// this property would need to be enforced at a higher level than `process_changes`.
-/// Then the nested loops could potentially be flattened into one.
+/// Uses a cursor to avoid restarting the changes iteration from the beginning for each hunk.
+/// When suspect ranges overlap (rare, from merge blame convergence), the cursor resets to
+/// maintain correctness.
 fn process_changes(
     hunks_to_blame: Vec<UnblamedHunk>,
-    changes: Vec<Change>,
+    changes: &[Change],
     suspect: ObjectId,
     parent: ObjectId,
 ) -> Vec<UnblamedHunk> {
     let mut new_hunks_to_blame = Vec::new();
+    let mut offset_in_destination = Offset::Added(0);
+    let mut changes_pos = 0;
+    let mut last_suspect_end: Option<u32> = None;
+
+    for hunk in hunks_to_blame {
+        if !hunk.has_suspect(&suspect) {
+            new_hunks_to_blame.push(hunk);
+            continue;
+        }
 
-    for mut hunk in hunks_to_blame.into_iter().map(Some) {
-        let mut offset_in_destination = Offset::Added(0);
+        let suspect_range = hunk.get_range(&suspect).expect("has_suspect was true");
+        if last_suspect_end.is_some_and(|end| suspect_range.start < end) {
+            changes_pos = 0;
+            offset_in_destination = Offset::Added(0);
+        }
+        last_suspect_end = Some(suspect_range.end);
 
-        let mut changes_iter = changes.iter().cloned();
-        let mut change = changes_iter.next();
+        let mut hunk = Some(hunk);
+        let mut pos = changes_pos;
+        let mut change: Option<Change> = changes.get(pos).cloned();
 
         loop {
             (hunk, change) = process_change(
@@ -351,12 +363,17 @@ fn process_changes(
                 change,
             );
 
-            change = change.or_else(|| changes_iter.next());
+            if change.is_none() {
+                pos += 1;
+                change = changes.get(pos).cloned();
+            }
 
             if hunk.is_none() {
                 break;
             }
         }
+
+        changes_pos = pos;
     }
     new_hunks_to_blame
 }

gix-blame/src/file/tests.rs

@@ -742,7 +742,7 @@ mod process_changes {
     fn nothing() {
         let suspect = zero_sha();
         let parent = one_sha();
-        let new_hunks_to_blame = process_changes(vec![], vec![], suspect, parent);
+        let new_hunks_to_blame = process_changes(vec![], &[], suspect, parent);
 
         assert_eq!(new_hunks_to_blame, []);
     }
@@ -753,7 +753,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(0..4, suspect).into()];
         let changes = vec![Change::AddedOrReplaced(0..4, 0)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(new_hunks_to_blame, [(0..4, suspect).into()]);
     }
@@ -764,7 +764,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(0..6, suspect).into()];
         let changes = vec![Change::AddedOrReplaced(0..4, 0), Change::Unchanged(4..6)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -782,7 +782,7 @@ mod process_changes {
             Change::AddedOrReplaced(2..4, 0),
             Change::Unchanged(4..6),
         ];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -804,7 +804,7 @@ mod process_changes {
             Change::AddedOrReplaced(1..4, 0),
             Change::Unchanged(4..6),
         ];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -822,7 +822,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(0..6, suspect).into()];
         let changes = vec![Change::AddedOrReplaced(0..1, 0)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -836,7 +836,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(2..6, suspect, 0..4).into()];
         let changes = vec![Change::AddedOrReplaced(0..1, 0)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -850,7 +850,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(0..6, suspect).into()];
         let changes = vec![Change::AddedOrReplaced(0..4, 3), Change::Unchanged(4..6)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -864,7 +864,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(4..6, suspect, 3..5).into()];
         let changes = vec![Change::AddedOrReplaced(0..3, 0), Change::Unchanged(3..5)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(new_hunks_to_blame, [(4..6, parent, 0..2).into()]);
     }
@@ -875,7 +875,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(1..3, suspect, 0..2).into()];
         let changes = vec![Change::AddedOrReplaced(0..1, 2)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -893,7 +893,7 @@ mod process_changes {
             Change::Unchanged(2..3),
             Change::AddedOrReplaced(3..4, 0),
         ];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -915,7 +915,7 @@ mod process_changes {
             Change::AddedOrReplaced(16..17, 0),
             Change::Unchanged(17..37),
         ];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -938,7 +938,7 @@ mod process_changes {
             Change::AddedOrReplaced(6..9, 0),
             Change::Unchanged(9..11),
         ];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -958,7 +958,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(0..4, suspect).into(), (4..7, suspect).into()];
         let changes = vec![Change::Deleted(0, 3), Change::AddedOrReplaced(0..4, 0)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,
@@ -972,7 +972,7 @@ mod process_changes {
         let parent = one_sha();
         let hunks_to_blame = vec![(13..16, suspect).into(), (10..17, suspect).into()];
         let changes = vec![Change::AddedOrReplaced(10..14, 0)];
-        let new_hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent);
+        let new_hunks_to_blame = process_changes(hunks_to_blame, &changes, suspect, parent);
 
         assert_eq!(
             new_hunks_to_blame,