refactor

- try to not force `clone_from()` into move semantics unless necessary

Author: Byron

gix-blame/src/file/function.rs

@@ -172,10 +172,9 @@ where
                 if more_than_one_parent {
                     // None of the changes affected the file we’re currently blaming.
                     // Copy blame to parent.
-                    hunks_to_blame = hunks_to_blame
-                        .into_iter()
-                        .map(|unblamed_hunk| unblamed_hunk.clone_blame(suspect, parent_id))
-                        .collect();
+                    for unblamed_hunk in &mut hunks_to_blame {
+                        unblamed_hunk.clone_blame(suspect, parent_id);
+                    }
                 } else {
                     pass_blame_from_to(suspect, parent_id, &mut hunks_to_blame);
                 }
@@ -202,26 +201,20 @@ where
             }
         }
 
-        hunks_to_blame = hunks_to_blame
-            .into_iter()
-            .filter_map(|mut unblamed_hunk| {
-                if unblamed_hunk.suspects.len() == 1 {
-                    if let Some(entry) = BlameEntry::from_unblamed_hunk(&unblamed_hunk, suspect) {
-                        // At this point, we have copied blame for every hunk to a parent. Hunks
-                        // that have only `suspect` left in `suspects` have not passed blame to any
-                        // parent and so they can be converted to a `BlameEntry` and moved to
-                        // `out`.
-                        out.push(entry);
-
-                        return None;
-                    }
+        hunks_to_blame.retain_mut(|unblamed_hunk| {
+            if unblamed_hunk.suspects.len() == 1 {
+                if let Some(entry) = BlameEntry::from_unblamed_hunk(&unblamed_hunk, suspect) {
+                    // At this point, we have copied blame for every hunk to a parent. Hunks
+                    // that have only `suspect` left in `suspects` have not passed blame to any
+                    // parent, and so they can be converted to a `BlameEntry` and moved to
+                    // `out`.
+                    out.push(entry);
+                    return false;
                 }
-
-                unblamed_hunk.remove_blame(suspect);
-
-                Some(unblamed_hunk)
-            })
-            .collect();
+            }
+            unblamed_hunk.remove_blame(suspect);
+            true
+        });
 
         // This block asserts that line ranges for each suspect never overlap. If they did overlap
         // this would mean that the same line in a *Source File* would map to more than one line in

gix-blame/src/file/mod.rs

@@ -66,7 +66,7 @@ fn process_change(
 
                     // Nothing to do with `hunk` except shifting it,
                     // but `unchanged` needs to be checked against the next hunk to catch up.
-                    new_hunks_to_blame.push(hunk.clone_blame(suspect, parent).shift_by(parent, *offset));
+                    new_hunks_to_blame.push(hunk.cloned_blame(suspect, parent).shift_by(parent, *offset));
                     (None, Some(Change::Unchanged(unchanged)))
                 }
                 (false, false) => {
@@ -95,7 +95,7 @@ fn process_change(
 
                         // Nothing to do with `hunk` except shifting it,
                         // but `unchanged` needs to be checked against the next hunk to catch up.
-                        new_hunks_to_blame.push(hunk.clone_blame(suspect, parent).shift_by(parent, *offset));
+                        new_hunks_to_blame.push(hunk.cloned_blame(suspect, parent).shift_by(parent, *offset));
                         (None, Some(Change::Unchanged(unchanged)))
                     }
                 }
@@ -125,7 +125,7 @@ fn process_change(
                         }
                         Either::Right((before, after)) => {
                             // requeue the left side `before` after offsetting it…
-                            new_hunks_to_blame.push(before.clone_blame(suspect, parent).shift_by(parent, *offset));
+                            new_hunks_to_blame.push(before.cloned_blame(suspect, parent).shift_by(parent, *offset));
                             // …and treat `after` as `new_hunk`, which contains the `added` range.
                             after
                         }
@@ -162,7 +162,7 @@ fn process_change(
                         Either::Left(hunk) => hunk,
                         Either::Right((before, after)) => {
                             // Keep looking for the left side of the unblamed portion.
-                            new_hunks_to_blame.push(before.clone_blame(suspect, parent).shift_by(parent, *offset));
+                            new_hunks_to_blame.push(before.cloned_blame(suspect, parent).shift_by(parent, *offset));
                             after
                         }
                     };
@@ -220,7 +220,7 @@ fn process_change(
                         //       <---->  (added)
 
                         // Retry `hunk` once there is overlapping changes to process.
-                        new_hunks_to_blame.push(hunk.clone_blame(suspect, parent).shift_by(parent, *offset));
+                        new_hunks_to_blame.push(hunk.cloned_blame(suspect, parent).shift_by(parent, *offset));
 
                         // Let hunks catchup with this change.
                         (
@@ -273,7 +273,7 @@ fn process_change(
                     }
                     Either::Right((before, after)) => {
                         // `before` isn't affected by deletion, so keep it for later.
-                        new_hunks_to_blame.push(before.clone_blame(suspect, parent).shift_by(parent, *offset));
+                        new_hunks_to_blame.push(before.cloned_blame(suspect, parent).shift_by(parent, *offset));
                         // after will be affected by offset, and we will see if there are more changes affecting it.
                         after
                     }
@@ -285,7 +285,7 @@ fn process_change(
                 //         |  (line_number_in_destination)
 
                 // Catchup with changes.
-                new_hunks_to_blame.push(hunk.clone_blame(suspect, parent).shift_by(parent, *offset));
+                new_hunks_to_blame.push(hunk.cloned_blame(suspect, parent).shift_by(parent, *offset));
 
                 (
                     None,
@@ -295,7 +295,7 @@ fn process_change(
         }
         (Some(hunk), None) => {
             // nothing to do - changes are exhausted, re-evaluate `hunk`.
-            new_hunks_to_blame.push(hunk.clone_blame(suspect, parent).shift_by(parent, *offset));
+            new_hunks_to_blame.push(hunk.cloned_blame(suspect, parent).shift_by(parent, *offset));
             (None, None)
         }
         (None, Some(Change::Unchanged(_))) => {
@@ -409,13 +409,17 @@ impl UnblamedHunk {
         }
     }
 
-    // TODO
-    // Should this also accept `&mut self` as the other functions do?
-    fn clone_blame(mut self, from: ObjectId, to: ObjectId) -> Self {
+    /// This is like [`Self::clone_blame()`], but easier to use in places
+    /// where the cloning is done 'inline'.
+    fn cloned_blame(mut self, from: ObjectId, to: ObjectId) -> Self {
+        self.clone_blame(from, to);
+        self
+    }
+
+    fn clone_blame(&mut self, from: ObjectId, to: ObjectId) {
         if let Some(range_in_suspect) = self.suspects.get(&from) {
             self.suspects.insert(to, range_in_suspect.clone());
         }
-        self
     }
 
     fn remove_blame(&mut self, suspect: ObjectId) {