implement support for resolving irreconcilable tree conflicts with 'ours' or 'ancestor'

Author: Byron

crate-status.md

@@ -352,8 +352,11 @@ Check out the [performance discussion][gix-diff-performance] as well.
     - [ ] a way to control inter-hunk merging based on proximity (maybe via `gix-diff` feature which could use the same)
 * [x] **tree**-diff-heuristics match Git for its test-cases
     - [x] a way to generate an index with stages, mostly conforming with Git.
+    - [ ] resolve to be *ours* or the *ancestors* version of the tree.
     - [ ] submodule merges (*right now they count as conflicts if they differ*)
     - [ ] assure sparse indices are handled correctly during application - right now we refuse.
+    - [ ] rewrite so that the whole logic can be proven to be correct - it's too insane now and probably has way 
+          more possible states than are tested, despite best attempts.
 * [x] **commits** - with handling of multiple merge bases by recursive merge-base merge
 * [x] API documentation
     * [ ] Examples

gix-merge/src/tree/function.rs

@@ -157,7 +157,7 @@ enum ConflictIndexEntryPathHint {
 }
 
 /// A utility to help define which side is what in the [`Conflict`] type.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 enum ConflictMapping {
     /// The sides are as described in the field documentation, i.e. `ours` is `ours`.
     Original,
@@ -198,7 +198,12 @@ impl Conflict {
                 match &self.resolution {
                     Ok(success) => match success {
                         Resolution::SourceLocationAffectedByRename { .. } => false,
-                        Resolution::Forced(_) => how.tree_merge == treat_as_unresolved::TreeMerge::ForcedResolution,
+                        Resolution::Forced(_) => {
+                            how.tree_merge == treat_as_unresolved::TreeMerge::ForcedResolution
+                                || self
+                                    .content_merge()
+                                    .map_or(false, |merged_blob| content_merge_matches(&merged_blob))
+                        }
                         Resolution::OursModifiedTheirsRenamedAndChangedThenRename {
                             merged_blob,
                             final_location,
@@ -386,7 +391,10 @@ pub struct Options {
 pub enum ResolveWith {
     /// On irreconcilable conflict, choose neither *our* nor *their* state, but keep the common *ancestor* state instead.
     Ancestor,
-    /// On irreconcilable conflict, choose *our* side
+    /// On irreconcilable conflict, choose *our* side.
+    ///
+    /// Note that in order to get something equivalent to *theirs*, put *theirs* into the side of *ours*,
+    /// swapping the sides essentially.
     Ours,
 }
 

gix-merge/src/tree/mod.rs

@@ -23,7 +23,7 @@ use std::collections::HashMap;
 /// 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(
-    check_tree: &mut TreeNodes,
+    check_tree: &TreeNodes,
     their_location: &BStr,
     our_changes: &ChangeListRef,
 ) -> Option<BString> {
@@ -60,7 +60,7 @@ pub fn rewrite_location_with_renamed_directory(their_location: &BStr, passed_cha
 pub fn unique_path_in_tree(
     file_path: &BStr,
     editor: &tree::Editor<'_>,
-    tree: &mut TreeNodes,
+    tree: &TreeNodes,
     side_name: &BStr,
 ) -> Result<BString, Error> {
     let mut buf = file_path.to_owned();
@@ -414,12 +414,12 @@ impl TreeNodes {
 
     /// Search the tree with `our` changes for `theirs` by [`source_location()`](Change::source_location())).
     /// If there is an entry but both are the same, or if there is no entry, return `None`.
-    pub fn check_conflict(&mut self, theirs_location: &BStr) -> Option<PossibleConflict> {
+    pub fn check_conflict(&self, theirs_location: &BStr) -> Option<PossibleConflict> {
         if self.0.len() == 1 {
             return None;
         }
         let components = to_components(theirs_location);
-        let mut cursor = &mut self.0[0];
+        let mut cursor = &self.0[0];
         let mut cursor_idx = 0;
         let mut intermediate_change = None;
         for component in components {
@@ -436,7 +436,7 @@ impl TreeNodes {
                     } else {
                         // a change somewhere else, i.e. `a/c` and we know `a/b` only.
                         intermediate_change.and_then(|(change, cursor_idx)| {
-                            let cursor = &mut self.0[cursor_idx];
+                            let cursor = &self.0[cursor_idx];
                             // If this is a destination location of a rename, then the `their_location`
                             // is already at the right spot, and we can just ignore it.
                             if matches!(cursor.location, ChangeLocation::CurrentLocation) {
@@ -450,7 +450,7 @@ impl TreeNodes {
                 }
                 Some(child_idx) => {
                     cursor_idx = child_idx;
-                    cursor = &mut self.0[cursor_idx];
+                    cursor = &self.0[cursor_idx];
                 }
             }
         }
@@ -504,7 +504,7 @@ impl TreeNodes {
                         cursor = &mut self.0[existing_idx];
                         debug_assert!(
                             cursor.is_leaf_node(),
-                            "BUG: we should really only try to remove leaf nodes"
+                            "BUG: we should really only try to remove leaf nodes: {cursor:?}"
                         );
                         cursor.change_idx = None;
                     } else {