Add more of our own tests to trigger the remaining code

This also allows for deviations in case the Git result is worse.

Author: Byron

crate-status.md

@@ -338,15 +338,16 @@ Check out the [performance discussion][gix-diff-performance] as well.
 
 ### gix-merge
 
-* [x] three-way merge analysis of **blobs** with choice of how to resolve conflicts
+* [x] three-way content-merge analysis of **blobs** with choice of how to resolve conflicts
     - [ ] choose how to resolve conflicts on the data-structure
     - [x] produce a new blob based on data-structure containing possible resolutions
         - [x] `merge` style
         - [x] `diff3` style
         - [x] `zdiff` style
     - [ ] various newlines-related options during the merge (see https://git-scm.com/docs/git-merge#Documentation/git-merge.txt-ignore-space-change).
     - [ ] a way to control inter-hunk merging based on proximity (maybe via `gix-diff` feature which could use the same)
-* [ ] diff-heuristics match Git perfectly
+* [x] **tree**-diff-heuristics match Git for its test-cases
+    - [ ] index-correctness (currently the data it provides won't generate index entries, and possibly can't be used for it)
 * [x] API documentation
     * [ ] Examples
 

gix-merge/src/tree/function.rs

@@ -43,31 +43,25 @@ pub struct Outcome<'a> {
     pub failed_on_first_unresolved_conflict: bool,
 }
 
+/// Determine what should be considered an unresolved conflict.
+///
+/// Note that no matter which variant, [conflicts](Conflict) with [resolution failure](`ResolutionFailure`)
+/// will always be unresolved.
+///
+/// However, those whose resolution was
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum UnresolvedConflict {
+    /// Only consider content merges with conflict markers as unresolved.
+    ConflictMarkers,
+    /// Whenever there was any rename, or conflict markers, it is unresolved.
+    Renames,
+}
+
 impl Outcome<'_> {
     /// Return `true` if there is any conflict that would still need to be resolved as they would yield undesirable trees.
-    /// Note that this interpretation of conflicts and their resolution, see
-    /// [`has_unresolved_conflicts_strict`](Self::has_unresolved_conflicts_strict).
-    pub fn has_unresolved_conflicts(&self) -> bool {
-        self.conflicts.iter().any(|c| {
-            c.resolution.is_err()
-                || c.content_merge().map_or(false, |info| {
-                    matches!(info.resolution, crate::blob::Resolution::Conflict)
-                })
-        })
-    }
-
-    /// Return `true` only if there was any (even resolved) conflict in the tree structure, or if there are still conflict markers.
-    pub fn has_unresolved_conflicts_strict(&self) -> bool {
-        self.conflicts.iter().any(|c| match &c.resolution {
-            Ok(success) => match success {
-                Resolution::OursAddedTheirsAddedTypeMismatch { .. }
-                | Resolution::OursModifiedTheirsRenamedAndChangedThenRename { .. } => true,
-                Resolution::OursModifiedTheirsModifiedThenBlobContentMerge { merged_blob } => {
-                    matches!(merged_blob.resolution, crate::blob::Resolution::Conflict)
-                }
-            },
-            Err(_failure) => true,
-        })
+    /// This is based on `how` to determine what should be considered unresolved.
+    pub fn has_unresolved_conflicts(&self, how: UnresolvedConflict) -> bool {
+        function::is_unresolved(&self.conflicts, how)
     }
 }
 
@@ -135,14 +129,16 @@ impl Conflict {
     pub fn content_merge(&self) -> Option<ContentMerge> {
         match &self.resolution {
             Ok(success) => match success {
-                Resolution::OursAddedTheirsAddedTypeMismatch { .. } => None,
+                Resolution::SourceLocationAffectedByRename { .. } => None,
                 Resolution::OursModifiedTheirsRenamedAndChangedThenRename { merged_blob, .. } => *merged_blob,
                 Resolution::OursModifiedTheirsModifiedThenBlobContentMerge { merged_blob } => Some(*merged_blob),
             },
             Err(failure) => match failure {
+                ResolutionFailure::OursRenamedTheirsRenamedDifferently { merged_blob } => *merged_blob,
                 ResolutionFailure::OursModifiedTheirsDirectoryThenOursRenamed {
-                    renamed_path_to_modified_blob: _,
+                    renamed_unique_path_to_modified_blob: _,
                 }
+                | ResolutionFailure::OursAddedTheirsAddedTypeMismatch { .. }
                 | ResolutionFailure::OursDeletedTheirsRenamed => None,
             },
         }
@@ -154,11 +150,18 @@ impl Conflict {
 /// Note that all resolutions are side-agnostic, so *ours* could also have been *theirs* and vice versa.
 #[derive(Debug, Clone)]
 pub enum Resolution {
+    /// *ours* had a renamed directory and *theirs* made a change in the now renamed directory.
+    /// We moved that change into its location.
+    SourceLocationAffectedByRename {
+        /// The repository-relative path to the location that the change ended up in after
+        /// being affected by a renamed directory.
+        final_location: BString,
+    },
     /// *ours* was a modified blob and *theirs* renamed that blob.
     /// We moved the changed blob from *ours* to its new location, and merged it successfully.
     /// If this is a `copy`, the source of the copy was set to be the changed blob as well so both match.
     OursModifiedTheirsRenamedAndChangedThenRename {
-        /// If not `None`, the content of the involved blob had to be merged.
+        /// If `Some(…)`, the content of the involved blob had to be merged.
         merged_blob: Option<ContentMerge>,
         /// The repository relative path to the location the blob finally ended up in.
         /// It's `Some()` only if *they* rewrote the blob into a directory which *we* renamed on *our* side.
@@ -172,11 +175,30 @@ pub enum Resolution {
         /// The outcome of the content merge.
         merged_blob: ContentMerge,
     },
+}
+
+/// Describes of a conflict involving *our* change and *their* failed to be resolved.
+#[derive(Debug, Clone)]
+pub enum ResolutionFailure {
+    /// *ours* was renamed, but *theirs* was renamed differently. Both versions will be present in the tree,
+    OursRenamedTheirsRenamedDifferently {
+        /// If `Some(…)`, the content of the involved blob had to be merged.
+        merged_blob: Option<ContentMerge>,
+    },
+    /// *ours* was modified, but *theirs* was turned into a directory, so *ours* was renamed to a non-conflicting path.
+    OursModifiedTheirsDirectoryThenOursRenamed {
+        /// The path at which `ours` can be found in the tree - it's in the same directory that it was in before.
+        renamed_unique_path_to_modified_blob: BString,
+    },
     /// *ours* was added (or renamed into place) with a different mode than theirs, e.g. blob and symlink, and we kept
+    /// the symlink in its original location, renaming
     OursAddedTheirsAddedTypeMismatch {
-        /// The location at which *their* state was placed to resolve the name and type clash.
-        their_final_location: BString,
+        /// The location at which *their* state was placed to resolve the name and type clash, named to indicate
+        /// where the entry is coming from.
+        their_unique_location: BString,
     },
+    /// *ours* was deleted, but *theirs* was renamed.
+    OursDeletedTheirsRenamed,
 }
 
 /// Information about a blob content merge for use in a [`Resolution`].
@@ -190,18 +212,6 @@ pub struct ContentMerge {
     pub resolution: crate::blob::Resolution,
 }
 
-/// Describes of a conflict involving *our* change and *their* failed to be resolved.
-#[derive(Debug, Clone)]
-pub enum ResolutionFailure {
-    /// *ours* was modified, but *theirs* was turned into a directory, so *ours* was renamed to a non-conflicting path.
-    OursModifiedTheirsDirectoryThenOursRenamed {
-        /// The path at which `ours` can be found in the tree - it's in the same directory that it was in before.
-        renamed_path_to_modified_blob: BString,
-    },
-    /// *ours* was deleted, but *theirs* was renamed.
-    OursDeletedTheirsRenamed,
-}
-
 /// A way to configure [`tree()`](crate::tree()).
 #[derive(Default, Debug, Clone)]
 pub struct Options {
@@ -211,8 +221,13 @@ pub struct Options {
     pub blob_merge: crate::blob::platform::merge::Options,
     /// The context to use when invoking merge-drivers.
     pub blob_merge_command_ctx: gix_command::Context,
-    /// If `true`, the first conflict will cause the entire
-    pub fail_on_conflict: bool,
+    /// If `Some(what-is-unresolved)`, the first unresolved conflict will cause the entire merge to stop.
+    /// This is useful to see if there is any conflict, without performing the whole operation.
+    // TODO: Maybe remove this if the cost of figuring out conflicts is so low - after all, the data structures
+    //       and initial diff is the expensive thing right now, which are always done upfront.
+    //       However, this could change once we know do everything during the traversal, which probably doesn't work
+    //       without caching stuff and is too complicated to actually do.
+    pub fail_on_conflict: Option<UnresolvedConflict>,
     /// If greater than 0, each level indicates another merge-of-merge. This can be greater than
     /// 0 when merging merge-bases, which are merged like a pyramid.
     /// This value also affects the size of merge-conflict markers, to allow differentiating

gix-merge/src/tree/mod.rs

@@ -1,3 +1,10 @@
+//! ## About `debug_assert!()
+//!
+//! The idea is to have code that won't panic in production. Thus, if in production that assertion would fail,
+//! we will rather let the code run and hope it will either be correct enough or fail in more graceful ways later.
+//!
+//! Once such a case becomes a bug and is reproduced in testing, the debug-assertion will kick in and hopefully
+//! contribute to finding a fix faster.
 use crate::blob::ResourceKind;
 use crate::tree::{Conflict, ConflictMapping, Error, Options, Resolution, ResolutionFailure};
 use bstr::ByteSlice;
@@ -6,27 +13,23 @@ use gix_diff::tree_with_rewrites::{Change, ChangeRef};
 use gix_hash::ObjectId;
 use gix_object::tree;
 use gix_object::tree::EntryMode;
-use std::borrow::Cow;
 use std::collections::HashMap;
 
 /// Assuming that `their_location` is the destination of *their* rewrite, check if *it* passes
 /// over a directory rewrite in *our* tree. If so, rewrite it so that we get the path
 /// it would have had if it had been renamed along with *our* directory.
-pub fn possibly_rewritten_location<'a>(
+pub fn possibly_rewritten_location(
     check_tree: &mut TreeNodes,
-    their_location: &'a BStr,
+    their_location: &BStr,
     our_changes: &ChangeListRef,
-) -> Cow<'a, BStr> {
-    check_tree
-        .check_conflict(their_location)
-        .and_then(|pc| match pc {
-            PossibleConflict::PassedRewrittenDirectory { change_idx } => {
-                let passed_change = &our_changes[change_idx];
-                rewrite_location_with_renamed_directory(their_location, &passed_change.inner).map(Cow::Owned)
-            }
-            _ => None,
-        })
-        .unwrap_or(Cow::Borrowed(their_location))
+) -> Option<BString> {
+    check_tree.check_conflict(their_location).and_then(|pc| match pc {
+        PossibleConflict::PassedRewrittenDirectory { change_idx } => {
+            let passed_change = &our_changes[change_idx];
+            rewrite_location_with_renamed_directory(their_location, &passed_change.inner)
+        }
+        _ => None,
+    })
 }
 
 pub fn rewrite_location_with_renamed_directory(their_location: &BStr, passed_change: &Change) -> Option<BString> {
@@ -165,6 +168,11 @@ pub struct TrackedChange {
     /// This makes sure that new changes aren't visible too early, which would mean the algorihtm
     /// knows things too early which can be misleading.
     pub needs_tree_insertion: bool,
+    /// A new location for the change that can happen if the location is touching a rewrite in a parent
+    /// directory, but otherwise doesn't have a match. This means we shall redo the operation but with
+    /// the changed path.
+    /// The second touple entry is the change-idx we passed over.
+    pub rewritten_location: Option<(BString, usize)>,
 }
 
 pub type ChangeList = Vec<TrackedChange>;
@@ -179,6 +187,7 @@ pub fn track(change: ChangeRef<'_>, changes: &mut ChangeList) {
     if change.entry_mode().is_tree() && matches!(change, ChangeRef::Modification { .. }) {
         return;
     }
+    let is_tree = change.entry_mode().is_tree();
     changes.push(TrackedChange {
         inner: match change.into_owned() {
             Change::Rewrite {
@@ -196,22 +205,24 @@ pub fn track(change: ChangeRef<'_>, changes: &mut ChangeList) {
             },
             other => other,
         },
-        was_written: false,
+        was_written: is_tree,
         needs_tree_insertion: false,
+        rewritten_location: None,
     });
 }
 
 /// Unconditionally apply `change` to `editor`.
-pub fn apply_change(editor: &mut tree::Editor<'_>, change: &Change) -> Result<(), tree::editor::Error> {
+pub fn apply_change(
+    editor: &mut tree::Editor<'_>,
+    change: &Change,
+    alternative_location: Option<&BString>,
+) -> Result<(), tree::editor::Error> {
     use to_components_bstring_ref as to_components;
-    // TODO(performance): we could apply tree changes if they are renames-by-identity, and then save the
-    //                    work needed to set all the children recursively. This would require more elaborate
-    //                    tracking though.
     if change.entry_mode().is_tree() {
         return Ok(());
     }
 
-    match change {
+    let (location, mode, id) = match change {
         Change::Addition {
             location,
             entry_mode,
@@ -223,8 +234,11 @@ pub fn apply_change(editor: &mut tree::Editor<'_>, change: &Change) -> Result<()
             entry_mode,
             id,
             ..
-        } => editor.upsert(to_components(location), entry_mode.kind(), *id)?,
-        Change::Deletion { location, .. } => editor.remove(to_components(location))?,
+        } => (location, entry_mode, id),
+        Change::Deletion { location, .. } => {
+            editor.remove(to_components(alternative_location.unwrap_or(location)))?;
+            return Ok(());
+        }
         Change::Rewrite {
             source_location,
             entry_mode,
@@ -236,17 +250,21 @@ pub fn apply_change(editor: &mut tree::Editor<'_>, change: &Change) -> Result<()
             if !*copy {
                 editor.remove(to_components(source_location))?;
             }
-            editor.upsert(to_components(location), entry_mode.kind(), *id)?
+            (location, entry_mode, id)
         }
     };
+
+    editor.upsert(
+        to_components(alternative_location.unwrap_or(location)),
+        mode.kind(),
+        *id,
+    )?;
     Ok(())
 }
 
 /// A potential conflict that needs to be checked. It comes in several varieties and always happens
 /// if paths overlap in some way between *theirs* and *ours*.
 #[derive(Debug)]
-// TODO: remove this when all fields are used.
-#[allow(dead_code)]
 pub enum PossibleConflict {
     /// *our* changes have a tree here, but *they* place a non-tree or edit an existing item (that we removed).
     TreeToNonTree {
@@ -483,7 +501,6 @@ impl TreeNodes {
             }
         }
 
-        // TODO: This overwrites nodes, possibly rewrites, is that OK or can there be issues later?
         debug_assert!(
             !matches!(new_change, Change::Rewrite { .. }),
             "BUG: we thought we wouldn't do that current.location is related?"