fix!: Adjust blob-merge baseline to also test the reverse of each operation

This also fixes an issue with blob merge computations.

It's breaking because the marker-size was reduced to `u8`.

Author: Byron

gix-merge/fuzz/.gitignore

@@ -0,0 +1,7 @@
+target
+corpus
+artifacts
+
+# These usually involve a lot of local CPU time, keep them.
+$artifacts
+$corpus

gix-merge/fuzz/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "gix-merge-fuzz"
+version = "0.0.0"
+authors = ["Automatically generated"]
+publish = false
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+anyhow = "1.0.76"
+libfuzzer-sys = "0.4"
+arbitrary = { version = "1.3.2", features = ["derive"] }
+imara-diff = { version = "0.1.7" }
+gix-merge = { path = ".." }
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "blob"
+path = "fuzz_targets/blob.rs"
+test = false
+doc = false

gix-merge/fuzz/fuzz_targets/blob.rs

@@ -0,0 +1,80 @@
+#![no_main]
+use anyhow::Result;
+use arbitrary::Arbitrary;
+use gix_merge::blob::builtin_driver::text::{Conflict, ConflictStyle, Options};
+use gix_merge::blob::Resolution;
+use libfuzzer_sys::fuzz_target;
+use std::hint::black_box;
+use std::num::NonZero;
+
+fn fuzz_text_merge(
+    Ctx {
+        base,
+        ours,
+        theirs,
+        marker_size,
+    }: Ctx,
+) -> Result<()> {
+    let mut buf = Vec::new();
+    let mut input = imara_diff::intern::InternedInput::default();
+    for diff_algorithm in [
+        imara_diff::Algorithm::Histogram,
+        imara_diff::Algorithm::Myers,
+        imara_diff::Algorithm::MyersMinimal,
+    ] {
+        let mut opts = Options {
+            diff_algorithm,
+            conflict: Default::default(),
+        };
+        for (left, right) in [(ours, theirs), (theirs, ours)] {
+            let resolution = gix_merge::blob::builtin_driver::text(
+                &mut buf,
+                &mut input,
+                Default::default(),
+                left,
+                base,
+                right,
+                opts,
+            );
+            if resolution == Resolution::Conflict {
+                for conflict in [
+                    Conflict::ResolveWithOurs,
+                    Conflict::ResolveWithTheirs,
+                    Conflict::ResolveWithUnion,
+                    Conflict::Keep {
+                        style: ConflictStyle::Diff3,
+                        marker_size,
+                    },
+                    Conflict::Keep {
+                        style: ConflictStyle::ZealousDiff3,
+                        marker_size,
+                    },
+                ] {
+                    opts.conflict = conflict;
+                    gix_merge::blob::builtin_driver::text(
+                        &mut buf,
+                        &mut input,
+                        Default::default(),
+                        left,
+                        base,
+                        right,
+                        opts,
+                    );
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[derive(Debug, Arbitrary)]
+struct Ctx<'a> {
+    base: &'a [u8],
+    ours: &'a [u8],
+    theirs: &'a [u8],
+    marker_size: NonZero<u8>,
+}
+
+fuzz_target!(|ctx: Ctx<'_>| {
+    _ = black_box(fuzz_text_merge(ctx));
+});

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

@@ -1,4 +1,5 @@
 use bstr::BStr;
+use std::num::NonZeroU8;
 
 /// The way the built-in [text driver](crate::blob::BuiltinDriver::Text) will express
 /// merge conflicts in the resulting file.
@@ -87,7 +88,7 @@ pub enum Conflict {
         /// How to visualize conflicts in merged files.
         style: ConflictStyle,
         /// The amount of markers to draw, defaults to 7, i.e. `<<<<<<<`
-        marker_size: usize,
+        marker_size: NonZeroU8,
     },
     /// Chose our side to resolve a conflict.
     ResolveWithOurs,
@@ -99,12 +100,13 @@ pub enum Conflict {
 
 impl Conflict {
     /// The amount of conflict marker characters to print by default.
-    pub const DEFAULT_MARKER_SIZE: usize = 7;
+    // TODO: use NonZeroU8::new().unwrap() here once the MSRV supports it.
+    pub const DEFAULT_MARKER_SIZE: u8 = 7;
 
     /// The amount of conflict markers to print if this instance contains them, or `None` otherwise
-    pub fn marker_size(&self) -> Option<usize> {
+    pub fn marker_size(&self) -> Option<u8> {
         match self {
-            Conflict::Keep { marker_size, .. } => Some(*marker_size),
+            Conflict::Keep { marker_size, .. } => Some(marker_size.get()),
             Conflict::ResolveWithOurs | Conflict::ResolveWithTheirs | Conflict::ResolveWithUnion => None,
         }
     }
@@ -114,7 +116,7 @@ impl Default for Conflict {
     fn default() -> Self {
         Conflict::Keep {
             style: Default::default(),
-            marker_size: Conflict::DEFAULT_MARKER_SIZE,
+            marker_size: Conflict::DEFAULT_MARKER_SIZE.try_into().unwrap(),
         }
     }
 }

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

@@ -93,9 +93,9 @@ pub fn assure_ends_with_nl(out: &mut Vec<u8>, nl: &BStr) {
     }
 }
 
-pub fn write_conflict_marker(out: &mut Vec<u8>, marker: u8, label: Option<&BStr>, marker_size: usize, nl: &BStr) {
+pub fn write_conflict_marker(out: &mut Vec<u8>, marker: u8, label: Option<&BStr>, marker_size: u8, nl: &BStr) {
     assure_ends_with_nl(out, nl);
-    out.extend(std::iter::repeat(marker).take(marker_size));
+    out.extend(std::iter::repeat(marker).take(marker_size as usize));
     if let Some(label) = label {
         out.push(b' ');
         out.extend_from_slice(label);
@@ -132,8 +132,8 @@ pub fn fill_ancestor(Range { start, end }: &Range<u32>, in_out: &mut Vec<Hunk>)
     for (idx, next_idx) in (first_idx..in_out.len()).map(|idx| (idx, idx + 1)) {
         let Some(next_hunk) = in_out.get(next_idx) else { break };
         let hunk = &in_out[idx];
-        if let Some(lines_to_add) = next_hunk.after.start.checked_sub(hunk.after.end).filter(is_nonzero) {
-            in_out.push(ancestor_hunk(hunk.after.end, lines_to_add));
+        if let Some(lines_to_add) = next_hunk.before.start.checked_sub(hunk.before.end).filter(is_nonzero) {
+            in_out.push(ancestor_hunk(hunk.before.end, lines_to_add));
             added_hunks = true;
         }
     }
@@ -414,21 +414,46 @@ fn write_tokens(
 }
 
 /// Find all hunks in `iter` which aren't from the same side as `hunk` and intersect with it.
-/// Return `true` if `out` is non-empty after the operation, indicating overlapping hunks were found.
-pub fn take_intersecting(hunk: &Hunk, iter: &mut Peekable<impl Iterator<Item = Hunk>>, out: &mut Vec<Hunk>) -> bool {
-    out.clear();
-    while iter
-        .peek()
-        .filter(|b_hunk| {
-            b_hunk.side != hunk.side
-                && (hunk.before.contains(&b_hunk.before.start)
-                    || (hunk.before.is_empty() && hunk.before.start == b_hunk.before.start))
-        })
-        .is_some()
-    {
-        out.extend(iter.next());
+/// Also put `hunk` into `input` so it's the first item, and possibly put more hunks of the side of `hunk` so
+/// `iter` doesn't have any overlapping hunks left.
+/// Return `true` if `intersecting` is non-empty after the operation, indicating overlapping hunks were found.
+pub fn take_intersecting(
+    iter: &mut Peekable<impl Iterator<Item = Hunk>>,
+    input: &mut Vec<Hunk>,
+    intersecting: &mut Vec<Hunk>,
+) -> Option<()> {
+    input.clear();
+    input.push(iter.next()?);
+    intersecting.clear();
+
+    fn left_overlaps_right(left: &Hunk, right: &Hunk) -> bool {
+        left.side != right.side
+            && (right.before.contains(&left.before.start)
+                || (right.before.is_empty() && right.before.start == left.before.start))
+    }
+
+    loop {
+        let hunk = input.last().expect("just pushed");
+        while iter.peek().filter(|b_hunk| left_overlaps_right(b_hunk, hunk)).is_some() {
+            intersecting.extend(iter.next());
+        }
+        // The hunks that overlap might themselves overlap with a following hunk of the other side.
+        // If so, split it so it doesn't overlap anymore.
+        let mut found_more_intersections = false;
+        while intersecting
+            .last_mut()
+            .zip(iter.peek_mut())
+            .filter(|(last_intersecting, candidate)| left_overlaps_right(candidate, last_intersecting))
+            .is_some()
+        {
+            input.extend(iter.next());
+            found_more_intersections = true;
+        }
+        if !found_more_intersections {
+            break;
+        }
     }
-    !out.is_empty()
+    Some(())
 }
 
 pub fn tokens(input: &[u8]) -> imara_diff::sources::ByteLines<'_, true> {

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

@@ -12,8 +12,11 @@ function baseline() {
 
   shift 4
   git merge-file --stdout "$@" "$ours" "$base" "$theirs" > "$output" || true
-
   echo "$ours" "$base" "$theirs" "$output" "$@" >> baseline.cases
+
+  local output="${output}-reversed"
+  git merge-file --stdout "$@" "$theirs" "$base" "$ours" > "${output}" || true
+  echo "$theirs" "$base" "$ours" "${output}" "$@" >> baseline-reversed.cases
 }
 
 mkdir simple