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 {
@@ -170,14 +173,15 @@ pub fn merge<'a>(
                 ancestor_integrated_until = last_hunk.before.end;
             }
             Conflict::ResolveWithOurs | Conflict::ResolveWithTheirs => {
+                resolution = Resolution::CompleteWithAutoResolvedConflict;
                 let (our_hunks, their_hunks) = match filled_hunks_side {
                     Side::Current => (&current_hunks, &intersecting),
                     Side::Other => (&intersecting, &current_hunks),
                     Side::Ancestor => {
                         unreachable!("initial hunks are never ancestors")
                     }
                 };
-                let hunks_to_write = if opts.conflict == Conflict::ResolveWithOurs {
+                let hunks_to_write = if conflict == Conflict::ResolveWithOurs {
                     our_hunks
                 } else {
                     their_hunks
@@ -191,6 +195,7 @@ pub fn merge<'a>(
                 }
             }
             Conflict::ResolveWithUnion => {
+                resolution = Resolution::CompleteWithAutoResolvedConflict;
                 let (hunks_front_and_back, num_hunks_front) =
                     zealously_contract_hunks(&mut current_hunks, &mut intersecting, input, &current_tokens);
 

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

@@ -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,);
                 }
             }
 

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);