feat: when blob-merging, clarify if something would have conflicted.

Author: Byron

gix-merge/src/blob/builtin_driver/text/function.rs

@@ -31,14 +31,17 @@ pub fn merge<'a>(
     current: &'a [u8],
     ancestor: &'a [u8],
     other: &'a [u8],
-    opts: Options,
+    Options {
+        diff_algorithm,
+        conflict,
+    }: Options,
 ) -> Resolution {
     out.clear();
     input.update_before(tokens(ancestor));
     input.update_after(tokens(current));
 
     let hunks = imara_diff::diff(
-        opts.diff_algorithm,
+        diff_algorithm,
         input,
         CollectHunks {
             side: Side::Current,
@@ -50,7 +53,7 @@ pub fn merge<'a>(
     input.update_after(tokens(other));
 
     let mut hunks = imara_diff::diff(
-        opts.diff_algorithm,
+        diff_algorithm,
         input,
         CollectHunks {
             side: Side::Other,
@@ -86,7 +89,7 @@ pub fn merge<'a>(
             fill_ancestor(&extended_range, &mut current_hunks);
             fill_ancestor(&extended_range, &mut intersecting);
         }
-        match opts.conflict {
+        match conflict {
             Conflict::Keep { style, marker_size } => {
                 let marker_size = marker_size.get();
                 let (hunks_front_and_back, num_hunks_front) = match style {
@@ -177,7 +180,10 @@ pub fn merge<'a>(
                         unreachable!("initial hunks are never ancestors")
                     }
                 };
-                let hunks_to_write = if opts.conflict == Conflict::ResolveWithOurs {
+                if hunks_differ_in_diff3(ConflictStyle::Diff3, our_hunks, their_hunks, input, &current_tokens) {
+                    resolution = Resolution::CompleteWithAutoResolvedConflict;
+                }
+                let hunks_to_write = if conflict == Conflict::ResolveWithOurs {
                     our_hunks
                 } else {
                     their_hunks
@@ -201,6 +207,9 @@ pub fn merge<'a>(
                         unreachable!("initial hunks are never ancestors")
                     }
                 };
+                if hunks_differ_in_diff3(ConflictStyle::Diff3, our_hunks, their_hunks, input, &current_tokens) {
+                    resolution = Resolution::CompleteWithAutoResolvedConflict;
+                }
                 let (front_hunks, back_hunks) = hunks_front_and_back.split_at(num_hunks_front);
                 let first_hunk = first_hunk(front_hunks, our_hunks, their_hunks, back_hunks);
                 write_ancestor(input, ancestor_integrated_until, first_hunk.before.start as usize, out);

gix-merge/src/blob/mod.rs

@@ -15,13 +15,13 @@ pub mod platform;
 /// Define if a merge is conflicted or not.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Resolution {
-    /// Everything could be resolved during the merge.
-    ///
-    /// Conflicts may have been resolved automatically, depending on the options.
+    /// Everything could be resolved during the merge, and there was no conflict.
     Complete,
+    /// Conflicts were resolved automatically, even thought the result is complete
+    /// and free of conflict markers.
+    /// This can only be the case for text-file content merges.
+    CompleteWithAutoResolvedConflict,
     /// A conflict is still present in the form of conflict markers.
-    ///
-    /// Note that this won't be the case if conflicts were automatically resolved.
     Conflict,
 }
 

gix-merge/tests/merge/blob/builtin_driver.rs

@@ -25,7 +25,7 @@ fn binary() {
 
 mod text {
     use bstr::ByteSlice;
-    use gix_merge::blob::builtin_driver::text::Conflict;
+    use gix_merge::blob::builtin_driver::text::{Conflict, ConflictStyle};
     use gix_merge::blob::{builtin_driver, Resolution};
     use pretty_assertions::assert_str_eq;
 
@@ -160,10 +160,17 @@ mod text {
                 if is_case_diverging(&case, diverging) {
                     num_diverging += 1;
                 } else {
-                    let expected_resolution = if case.expected.contains_str("<<<<<<<") {
-                        Resolution::Conflict
+                    if case.expected.contains_str("<<<<<<<") {
+                        assert_eq!(actual, Resolution::Conflict, "{}: resolution mismatch", case.name,);
                     } else {
-                        Resolution::Complete
+                        assert!(
+                            matches!(
+                                actual,
+                                Resolution::Complete | Resolution::CompleteWithAutoResolvedConflict
+                            ),
+                            "{}: resolution mismatch",
+                            case.name
+                        );
                     };
                     assert_str_eq!(
                         out.as_bstr().to_str_lossy(),
@@ -173,7 +180,6 @@ mod text {
                         out.as_bstr()
                     );
                     assert_eq!(out.as_bstr(), case.expected);
-                    assert_eq!(actual, expected_resolution, "{}: resolution mismatch", case.name,);
                 }
             }
 
@@ -191,6 +197,100 @@ mod text {
         Ok(())
     }
 
+    #[test]
+    fn both_sides_same_changes_are_conflict_free() {
+        for conflict in [
+            builtin_driver::text::Conflict::Keep {
+                style: ConflictStyle::Merge,
+                marker_size: 7.try_into().unwrap(),
+            },
+            builtin_driver::text::Conflict::Keep {
+                style: ConflictStyle::Diff3,
+                marker_size: 7.try_into().unwrap(),
+            },
+            builtin_driver::text::Conflict::Keep {
+                style: ConflictStyle::ZealousDiff3,
+                marker_size: 7.try_into().unwrap(),
+            },
+            builtin_driver::text::Conflict::ResolveWithOurs,
+            builtin_driver::text::Conflict::ResolveWithTheirs,
+            builtin_driver::text::Conflict::ResolveWithUnion,
+        ] {
+            let options = builtin_driver::text::Options {
+                conflict,
+                ..Default::default()
+            };
+            let mut input = imara_diff::intern::InternedInput::default();
+            let mut out = Vec::new();
+            let actual = builtin_driver::text(
+                &mut out,
+                &mut input,
+                Default::default(),
+                b"1\n3\nother",
+                b"1\n2\n3",
+                b"1\n3\nother",
+                options,
+            );
+            assert_eq!(actual, Resolution::Complete, "{conflict:?}");
+        }
+    }
+
+    #[test]
+    fn both_differ_partially_resolution_is_conflicting() {
+        for (conflict, expected) in [
+            (
+                builtin_driver::text::Conflict::Keep {
+                    style: ConflictStyle::Merge,
+                    marker_size: 7.try_into().unwrap(),
+                },
+                Resolution::Conflict,
+            ),
+            (
+                builtin_driver::text::Conflict::Keep {
+                    style: ConflictStyle::Diff3,
+                    marker_size: 7.try_into().unwrap(),
+                },
+                Resolution::Conflict,
+            ),
+            (
+                builtin_driver::text::Conflict::Keep {
+                    style: ConflictStyle::ZealousDiff3,
+                    marker_size: 7.try_into().unwrap(),
+                },
+                Resolution::Conflict,
+            ),
+            (
+                builtin_driver::text::Conflict::ResolveWithOurs,
+                Resolution::CompleteWithAutoResolvedConflict,
+            ),
+            (
+                builtin_driver::text::Conflict::ResolveWithTheirs,
+                Resolution::CompleteWithAutoResolvedConflict,
+            ),
+            (
+                builtin_driver::text::Conflict::ResolveWithUnion,
+                Resolution::CompleteWithAutoResolvedConflict,
+            ),
+        ] {
+            let options = builtin_driver::text::Options {
+                conflict,
+                ..Default::default()
+            };
+            let mut input = imara_diff::intern::InternedInput::default();
+            let mut out = Vec::new();
+            let actual = builtin_driver::text(
+                &mut out,
+                &mut input,
+                Default::default(),
+                b"1\n3\nours",
+                b"1\n2\n3",
+                b"1\n3\ntheirs",
+                options,
+            );
+            assert_eq!(actual, expected, "{conflict:?}");
+        }
+    }
+
     mod baseline {
         use bstr::BString;
         use gix_merge::blob::builtin_driver::text::{Conflict, ConflictStyle};

gix-merge/tests/merge/blob/platform.rs

@@ -125,25 +125,25 @@ theirs
         let res = platform_ref.merge(&mut buf, default_labels(), &Default::default())?;
         assert_eq!(
             res,
-            (Pick::Buffer, Resolution::Complete),
-            "it's actually unclear now if there ever was a conflict, but we *could* compute it"
+            (Pick::Buffer, Resolution::CompleteWithAutoResolvedConflict),
+            "we can determine that there was a conflict, despite the resolution being complete"
         );
         assert_eq!(buf.as_bstr(), "ours");
 
         platform_ref.options.text.conflict = builtin_driver::text::Conflict::ResolveWithTheirs;
         let res = platform_ref.merge(&mut buf, default_labels(), &Default::default())?;
-        assert_eq!(res, (Pick::Buffer, Resolution::Complete));
+        assert_eq!(res, (Pick::Buffer, Resolution::CompleteWithAutoResolvedConflict));
         assert_eq!(buf.as_bstr(), "theirs");
 
         platform_ref.options.text.conflict = builtin_driver::text::Conflict::ResolveWithUnion;
         let res = platform_ref.merge(&mut buf, default_labels(), &Default::default())?;
-        assert_eq!(res, (Pick::Buffer, Resolution::Complete));
+        assert_eq!(res, (Pick::Buffer, Resolution::CompleteWithAutoResolvedConflict));
         assert_eq!(buf.as_bstr(), "ours\ntheirs");
 
         platform_ref.driver = DriverChoice::BuiltIn(BuiltinDriver::Union);
         platform_ref.options.text.conflict = builtin_driver::text::Conflict::default();
         let res = platform_ref.merge(&mut buf, default_labels(), &Default::default())?;
-        assert_eq!(res, (Pick::Buffer, Resolution::Complete));
+        assert_eq!(res, (Pick::Buffer, Resolution::CompleteWithAutoResolvedConflict));
         assert_eq!(buf.as_bstr(), "ours\ntheirs");
 
         platform_ref.driver = DriverChoice::BuiltIn(BuiltinDriver::Binary);