fix: remove index::Change::Unmerged as it doesn't matter to Git either.

Author: Byron

gix-diff/src/index/change.rs

@@ -70,19 +70,6 @@ impl ChangeRef<'_, '_> {
                 id: Cow::Owned(id.into_owned()),
                 copy,
             },
-            ChangeRef::Unmerged {
-                location,
-                stage,
-                index,
-                entry_mode,
-                id,
-            } => ChangeRef::Unmerged {
-                location: Cow::Owned(location.into_owned()),
-                stage,
-                index,
-                entry_mode,
-                id: Cow::Owned(id.into_owned()),
-            },
         }
     }
 }
@@ -120,13 +107,6 @@ impl ChangeRef<'_, '_> {
                 entry_mode,
                 id,
                 ..
-            }
-            | ChangeRef::Unmerged {
-                location,
-                index,
-                entry_mode,
-                id,
-                ..
             } => (location.as_ref(), *index, *entry_mode, id),
         }
     }
@@ -138,7 +118,7 @@ impl rewrites::tracker::Change for ChangeRef<'_, '_> {
             ChangeRef::Addition { id, .. } | ChangeRef::Deletion { id, .. } | ChangeRef::Modification { id, .. } => {
                 id.as_ref()
             }
-            ChangeRef::Rewrite { .. } | ChangeRef::Unmerged { .. } => {
+            ChangeRef::Rewrite { .. } => {
                 unreachable!("BUG")
             }
         }
@@ -156,9 +136,6 @@ impl rewrites::tracker::Change for ChangeRef<'_, '_> {
             ChangeRef::Rewrite { .. } => {
                 unreachable!("BUG: rewrites can't be determined ahead of time")
             }
-            ChangeRef::Unmerged { .. } => {
-                unreachable!("BUG: unmerged don't participate in rename tracking")
-            }
         }
     }
 
@@ -167,8 +144,7 @@ impl rewrites::tracker::Change for ChangeRef<'_, '_> {
             ChangeRef::Addition { entry_mode, .. }
             | ChangeRef::Deletion { entry_mode, .. }
             | ChangeRef::Modification { entry_mode, .. }
-            | ChangeRef::Rewrite { entry_mode, .. }
-            | ChangeRef::Unmerged { entry_mode, .. } => {
+            | ChangeRef::Rewrite { entry_mode, .. } => {
                 entry_mode
                     .to_tree_entry_mode()
                     // Default is for the impossible case - just don't let it participate in rename tracking.
@@ -182,8 +158,7 @@ impl rewrites::tracker::Change for ChangeRef<'_, '_> {
             ChangeRef::Addition { id, entry_mode, .. }
             | ChangeRef::Deletion { id, entry_mode, .. }
             | ChangeRef::Modification { id, entry_mode, .. }
-            | ChangeRef::Rewrite { id, entry_mode, .. }
-            | ChangeRef::Unmerged { id, entry_mode, .. } => {
+            | ChangeRef::Rewrite { id, entry_mode, .. } => {
                 (
                     id,
                     entry_mode

gix-diff/src/index/function.rs

@@ -1,6 +1,6 @@
 use super::{Action, ChangeRef, Error, RewriteOptions};
 use crate::rewrites;
-use bstr::{BStr, BString, ByteSlice};
+use bstr::BStr;
 use gix_filter::attributes::glob::pattern::Case;
 use std::borrow::Cow;
 use std::cell::RefCell;
@@ -20,7 +20,8 @@ use std::cmp::Ordering;
 /// Return the outcome of the rewrite tracker if it was enabled.
 ///
 /// Note that only `rhs` may contain unmerged entries, as `rhs` is expected to be the index read from `.git/index`.
-/// Unmerged entries are always provided as changes, one stage at a time, up to three stages for *base*, *ours* and *theirs*.
+/// Unmerged entries are skipped entirely.
+///
 /// Conceptually, `rhs` is *ours*, and `lhs` is *theirs*.
 /// The entries in `lhs` and `rhs` are both expected to be sorted like index entries are typically sorted.
 ///
@@ -74,23 +75,6 @@ where
             .filter(|(_, path, e)| pattern_matches.borrow_mut()(path, e)),
     );
 
-    let mut conflicting_paths = Vec::<BString>::new();
-    let mut cb = move |change: ChangeRef<'lhs, 'rhs>| {
-        let (location, ..) = change.fields();
-        if let ChangeRef::Unmerged { .. } = &change {
-            if let Err(insert_idx) = conflicting_paths.binary_search_by(|p| p.as_bstr().cmp(location)) {
-                conflicting_paths.insert(insert_idx, location.to_owned());
-            }
-            cb(change)
-        } else if conflicting_paths
-            .binary_search_by(|p| p.as_bstr().cmp(location))
-            .is_err()
-        {
-            cb(change)
-        } else {
-            Ok(Action::Continue)
-        }
-    };
     let mut resource_cache_storage = None;
     let mut tracker = rewrite_options.map(
         |RewriteOptions {
@@ -107,15 +91,6 @@ where
     loop {
         match (lhs_storage, rhs_storage) {
             (Some(lhs), Some(rhs)) => {
-                match emit_unmerged_ignore_intent_to_add(rhs, &mut cb)? {
-                    None => {}
-                    Some(Action::Cancel) => return Ok(None),
-                    Some(Action::Continue) => {
-                        rhs_storage = rhs_iter.next();
-                        continue;
-                    }
-                };
-
                 let (lhs_idx, lhs_path, lhs_entry) = lhs;
                 let (rhs_idx, rhs_path, rhs_entry) = rhs;
                 match lhs_path.cmp(rhs_path) {
@@ -126,6 +101,11 @@ where
                         Action::Cancel => return Ok(None),
                     },
                     Ordering::Equal => {
+                        if ignore_unmerged_and_intent_to_add(rhs) {
+                            rhs_storage = rhs_iter.next();
+                            lhs_storage = lhs_iter.next();
+                            continue;
+                        }
                         if lhs_entry.id != rhs_entry.id || lhs_entry.mode != rhs_entry.mode {
                             let change = ChangeRef::Modification {
                                 location: Cow::Borrowed(rhs_path),
@@ -274,8 +254,8 @@ fn emit_addition<'rhs, 'lhs: 'rhs, E>(
 where
     E: Into<Box<dyn std::error::Error + Send + Sync>>,
 {
-    if let Some(action) = emit_unmerged_ignore_intent_to_add((idx, path, entry), &mut cb)? {
-        return Ok(action);
+    if ignore_unmerged_and_intent_to_add((idx, path, entry)) {
+        return Ok(Action::Continue);
     }
 
     let change = ChangeRef::Addition {
@@ -296,29 +276,9 @@ where
     cb(change).map_err(|err| Error::Callback(err.into()))
 }
 
-fn emit_unmerged_ignore_intent_to_add<'rhs, 'lhs: 'rhs, E>(
-    (idx, path, entry): (usize, &'rhs BStr, &'rhs gix_index::Entry),
-    cb: &mut impl FnMut(ChangeRef<'lhs, 'rhs>) -> Result<Action, E>,
-) -> Result<Option<Action>, Error>
-where
-    E: Into<Box<dyn std::error::Error + Send + Sync>>,
-{
-    if entry.flags.contains(gix_index::entry::Flags::INTENT_TO_ADD) {
-        return Ok(Some(Action::Continue));
-    }
+fn ignore_unmerged_and_intent_to_add<'rhs, 'lhs: 'rhs>(
+    (_idx, _path, entry): (usize, &'rhs BStr, &'rhs gix_index::Entry),
+) -> bool {
     let stage = entry.stage();
-    if stage == gix_index::entry::Stage::Unconflicted {
-        return Ok(None);
-    }
-
-    Ok(Some(
-        cb(ChangeRef::Unmerged {
-            location: Cow::Borrowed(path),
-            stage,
-            index: idx,
-            entry_mode: entry.mode,
-            id: Cow::Borrowed(entry.id.as_ref()),
-        })
-        .map_err(|err| Error::Callback(err.into()))?,
-    ))
+    entry.flags.contains(gix_index::entry::Flags::INTENT_TO_ADD) || stage != gix_index::entry::Stage::Unconflicted
 }

gix-diff/src/index/mod.rs

@@ -43,8 +43,6 @@ where
 }
 
 /// Identify a change that would have to be applied to `lhs` to obtain `rhs`, as provided in [`index()`](crate::index()).
-///
-/// Note that all variants are unconflicted entries, unless it's the [`Self::Unmerged`] one.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ChangeRef<'lhs, 'rhs> {
     /// An entry was added to `rhs`.
@@ -116,22 +114,6 @@ pub enum ChangeRef<'lhs, 'rhs> {
         /// or similar content.
         copy: bool,
     },
-    /// One of up to three unmerged entries that are provided in order, one for each stage, ordered
-    /// by `location` and `stage`.
-    ///
-    /// Unmerged entries also don't participate in rename tracking, and they are never present in `lhs`.
-    Unmerged {
-        /// The current location of the entry in `rhs`.
-        location: Cow<'rhs, BStr>,
-        /// The stage of the entry, either *base*, *ours*, or *theirs*.
-        stage: gix_index::entry::Stage,
-        /// The index into the entries array of `rhs` for full access.
-        index: usize,
-        /// The mode of the entry in `rhs`.
-        entry_mode: gix_index::entry::Mode,
-        /// The object id of the entry in `rhs`.
-        id: Cow<'rhs, gix_hash::oid>,
-    },
 }
 
 /// The fully-owned version of [`ChangeRef`].

gix-diff/tests/diff/index.rs

@@ -1191,56 +1191,14 @@ fn unmerged_entries_and_intent_to_add() -> crate::Result {
         }),
     )?;
 
-    // each unmerged entry is emitted separately, and no entry is emitted for
-    // paths that are mentioned there. Intent-to-add is transparent.
+    // Intent-to-add is transparent. And unmerged entries aren't emitted either, along with
+    // their sibling paths.
     // All that with rename tracking…
-    insta::assert_debug_snapshot!(changes.into_iter().collect::<Vec<_>>(), @r#"
-    [
-        Unmerged {
-            location: "src/plumbing-renamed/main.rs",
-            stage: Base,
-            index: 2,
-            entry_mode: Mode(
-                FILE,
-            ),
-            id: Sha1(d00491fd7e5bb6fa28c517a0bb32b8b506539d4d),
-        },
-        Unmerged {
-            location: "src/plumbing-renamed/main.rs",
-            stage: Ours,
-            index: 3,
-            entry_mode: Mode(
-                FILE,
-            ),
-            id: Sha1(d00491fd7e5bb6fa28c517a0bb32b8b506539d4d),
-        },
-    ]
-    "#);
+    insta::assert_debug_snapshot!(changes.into_iter().collect::<Vec<_>>(), @"[]");
 
     let changes = collect_changes_no_renames("r4-dir-rename-non-identity", ".git/index")?;
     // …or without
-    insta::assert_debug_snapshot!(changes.into_iter().collect::<Vec<_>>(), @r#"
-    [
-        Unmerged {
-            location: "src/plumbing-renamed/main.rs",
-            stage: Base,
-            index: 2,
-            entry_mode: Mode(
-                FILE,
-            ),
-            id: Sha1(d00491fd7e5bb6fa28c517a0bb32b8b506539d4d),
-        },
-        Unmerged {
-            location: "src/plumbing-renamed/main.rs",
-            stage: Ours,
-            index: 3,
-            entry_mode: Mode(
-                FILE,
-            ),
-            id: Sha1(d00491fd7e5bb6fa28c517a0bb32b8b506539d4d),
-        },
-    ]
-    "#);
+    insta::assert_debug_snapshot!(changes.into_iter().collect::<Vec<_>>(), @"[]");
 
     let (index, _, _, _, _) = repo_with_indices(".git/index", ".git/index", None)?;
     assert_eq!(