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

Author: Byron

gix-merge/src/tree/function.rs

@@ -129,7 +129,12 @@ where
 
     let mut conflicts = Vec::new();
     let mut failed_on_first_conflict = false;
-    let mut should_fail_on_conflict = |conflict: Conflict| -> bool {
+    let mut should_fail_on_conflict = |mut conflict: Conflict| -> bool {
+        if options.tree_conflicts.is_some() {
+            if let Err(failure) = conflict.resolution {
+                conflict.resolution = Ok(Resolution::Forced(failure));
+            }
+        }
         if let Some(how) = options.fail_on_conflict {
             if conflict.resolution.is_err() || conflict.is_unresolved(how) {
                 failed_on_first_conflict = true;
@@ -284,6 +289,7 @@ where
                                 || ours.source_location() == theirs.source_location()),
                             "BUG: right now it's not known to be possible to match changes from different paths: {match_kind:?} {candidate:?}"
                         );
+                        dbg!(&ours, &theirs);
                         match (ours, theirs) {
                             (
                                 Change::Modification {
@@ -623,7 +629,9 @@ where
                                     };
                                     change_on_right
                                         .map(|change| {
-                                            change.inner.entry_mode().is_tree() && change.inner.location() == location
+                                            change.inner.entry_mode().is_tree()
+                                                && change.inner.location() == location
+                                                && matches!(change.inner, Change::Addition { .. })
                                         })
                                         .unwrap_or_default()
                                 };

gix-merge/tests/fixtures/generated-archives/tree-baseline.tar

@@ -36,6 +36,15 @@ function make_conflict_index() {
   cp .git/index .git/"${identifier}".index
 }
 
+function make_resolve_tree() {
+  local resolve=${1:?Their 'ancestor' or 'ours'}
+  local our_side=${2:-}
+  local their_side=${3:-}
+
+  local filename="resolve-${our_side}-${their_side}-with-${resolve}"
+  git write-tree > ".git/${filename}.tree"
+}
+
 function baseline () (
   local dir=${1:?the directory to enter}
   local output_name=${2:?the basename of the output of the merge}
@@ -1074,3 +1083,43 @@ baseline rename-and-modification A-B A B
 baseline symlink-modification A-B A B
 baseline symlink-addition A-B A B
 baseline type-change-to-symlink A-B A B
+
+##
+## Only once the tree-merges were performed can we refer to their objects
+## when making tree-conflict resolution expectations. It's important
+## to get these right.
+##
+(cd simple
+  rm .git/index
+  # 'whatever' is tree-conflict, 'greeting' is content conflict with markers
+  git update-index --index-info <<EOF
+100644 9dc97bdc2426e68423360e3e5299280b2cf6b8ff 0	greeting
+100644 09c277aa66897c58157f57a374eacc63a407dcab 0	numbers
+100644 5716ca5987cbf97d6bb54920bea6adde242d87e6 0	whatever
+EOF
+  make_resolve_tree ours side1 side2
+
+  rm .git/index
+  git update-index --index-info <<EOF
+100644 7ee0500b60d7a0682a8eee44369bb3df116054c7 0	greeting
+100644 09c277aa66897c58157f57a374eacc63a407dcab 0	numbers
+100644 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 0	whatever/empty
+EOF
+  make_resolve_tree ours side2 side1
+
+  rm .git/index
+  git update-index --index-info <<EOF
+100644 9dc97bdc2426e68423360e3e5299280b2cf6b8ff 0	greeting
+100644 09c277aa66897c58157f57a374eacc63a407dcab 0	numbers
+100644 257cc5642cb1a054f08cc83f2d943e56fd3ebe99 0	whatever
+EOF
+  make_resolve_tree ancestor side1 side2
+
+  rm .git/index
+  git update-index --index-info <<EOF
+100644 7ee0500b60d7a0682a8eee44369bb3df116054c7 0	greeting
+100644 09c277aa66897c58157f57a374eacc63a407dcab 0	numbers
+100644 257cc5642cb1a054f08cc83f2d943e56fd3ebe99 0	whatever
+EOF
+  make_resolve_tree ancestor side1 side2
+)

gix-merge/tests/fixtures/tree-baseline.sh

@@ -371,6 +371,22 @@ pub fn show_diff_and_fail(
     );
 }
 
+pub fn show_diff_trees_and_fail(
+    case_name: &str,
+    actual_id: ObjectId,
+    actual: &gix_merge::tree::Outcome<'_>,
+    expected_tree_id: gix_hash::ObjectId,
+    additional_information: &str,
+    odb: &gix_odb::memory::Proxy<gix_odb::Handle>,
+) {
+    pretty_assertions::assert_str_eq!(
+        visualize_tree(&actual_id, odb, None).to_string(),
+        visualize_tree(&expected_tree_id, odb, None).to_string(),
+        "{case_name}: merged tree mismatch\n{:#?}\n{additional_information}\n{case_name}",
+        actual.conflicts,
+    );
+}
+
 pub(crate) fn apply_git_index_entries(conflicts: &[Conflict], state: &mut gix_index::State) {
     let len = state.entries().len();
     for Conflict { ours, theirs, ancestor } in conflicts {

gix-merge/tests/merge/tree/baseline.rs

@@ -21,8 +21,9 @@ fn run_baseline() -> crate::Result {
     let root = gix_testtools::scripted_fixture_read_only("tree-baseline.sh")?;
     let cases = std::fs::read_to_string(root.join("baseline.cases"))?;
     let mut actual_cases = 0;
-    // let new_test = Some("rename-add-symlink-A-B");
-    let new_test = None;
+    let mut skipped_tree_resolve_cases = 0;
+    let new_test = Some("simple-side-1-2-various-conflicts");
+    // let new_test = None;
     for baseline::Expectation {
         root,
         conflict_style,
@@ -63,7 +64,7 @@ fn run_baseline() -> crate::Result {
             &mut blob_merge,
             &odb,
             &mut |id| id.to_hex_with_len(7).to_string(),
-            options,
+            options.clone(),
         )?
         .tree_merge;
 
@@ -138,8 +139,57 @@ fn run_baseline() -> crate::Result {
             actual.has_unresolved_conflicts(conflicts_like_in_git),
             "{case_name}: If there is any kind of conflict, the index should have been changed"
         );
+
+        // The content-merge mode is not relevant for the upcoming tree-conflict resolution.
+        if case_name.contains("diff3") {
+            continue;
+        }
+
+        for tree_resolution in [
+            gix_merge::tree::ResolveWith::Ancestor,
+            gix_merge::tree::ResolveWith::Ours,
+        ] {
+            let resolution_name = match tree_resolution {
+                gix_merge::tree::ResolveWith::Ancestor => "ancestor",
+                gix_merge::tree::ResolveWith::Ours => "ours",
+            };
+            let basename = format!("resolve-{our_side_name}-{their_side_name}-with-{resolution_name}");
+            let tree_path = root.join(".git").join(format!("{basename}.tree"));
+            if !tree_path.exists() {
+                skipped_tree_resolve_cases += 1;
+                continue;
+            };
+            let expected_tree_id = gix_hash::ObjectId::from_hex(std::fs::read_to_string(tree_path)?.trim().as_bytes())?;
+            options.tree_merge.tree_conflicts = Some(tree_resolution);
+            let actual = gix_merge::commit(
+                our_commit_id,
+                their_commit_id,
+                gix_merge::blob::builtin_driver::text::Labels {
+                    ancestor: None,
+                    current: Some(our_side_name.as_str().into()),
+                    other: Some(their_side_name.as_str().into()),
+                },
+                &mut graph,
+                &mut diff_resource_cache,
+                &mut blob_merge,
+                &odb,
+                &mut |id| id.to_hex_with_len(7).to_string(),
+                options.clone(),
+            )?
+            .tree_merge;
+
+            if actual_id != expected_tree_id {
+                baseline::show_diff_trees_and_fail(&case_name, actual_id, &actual, expected_tree_id, &basename, &odb);
+            }
+        }
     }
 
+    assert_eq!(
+        skipped_tree_resolve_cases,
+        166 - 4 * 7,
+        "this is done when no case is skipped, and we don't want to accidentally skip them.\
+        Some don't actually have conflicts"
+    );
     assert_eq!(
         actual_cases, 109,
         "BUG: update this number, and don't forget to remove a filter in the end"