internal/diff: Merge

This CL addes a Merge operator to the diff package.
It performs a simple three-way merge on two ordered
lists of valid Edits, and reports a conflict if
any edit could not be applied cleanly.

I suspect there is considerable latitude in the
implementation. This versions considers two identical
insertions as non-conflicting, as is the case for
redundant imports of the same package; however, it
may be inappropriate for, say, identical statements
that increment a counter, where the correct resolution
is to keep both copies.

+ tests.

Update golang/go#68765
Update golang/go#67049

Change-Id: I7d8bf5b0b2e601c15d3ee787499e6adc012f884b
Reviewed-on: https://go-review.googlesource.com/c/tools/+/643196
Auto-Submit: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Commit-Queue: Alan Donovan <[email protected]>
Reviewed-by: Robert Findley <[email protected]>

Author: adonovan

Diff for: internal/diff/merge.go

@@ -0,0 +1,81 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package diff
+
+import (
+	"slices"
+)
+
+// Merge merges two valid, ordered lists of edits.
+// It returns zero if there was a conflict.
+//
+// If corresponding edits in x and y are identical,
+// they are coalesced in the result.
+//
+// If x and y both provide different insertions at the same point,
+// the insertions from x will be first in the result.
+//
+// TODO(adonovan): this algorithm could be improved, for example by
+// working harder to coalesce non-identical edits that share a common
+// deletion or common prefix of insertion (see the tests).
+// Survey the academic literature for insights.
+func Merge(x, y []Edit) ([]Edit, bool) {
+	// Make a defensive (premature) copy of the arrays.
+	x = slices.Clone(x)
+	y = slices.Clone(y)
+
+	var merged []Edit
+	add := func(edit Edit) {
+		merged = append(merged, edit)
+	}
+	var xi, yi int
+	for xi < len(x) && yi < len(y) {
+		px := &x[xi]
+		py := &y[yi]
+
+		if *px == *py {
+			// x and y are identical: coalesce.
+			add(*px)
+			xi++
+			yi++
+
+		} else if px.End <= py.Start {
+			// x is entirely before y,
+			// or an insertion at start of y.
+			add(*px)
+			xi++
+
+		} else if py.End <= px.Start {
+			// y is entirely before x,
+			// or an insertion at start of x.
+			add(*py)
+			yi++
+
+		} else if px.Start < py.Start {
+			// x is partly before y:
+			// split it into a deletion and an edit.
+			add(Edit{px.Start, py.Start, ""})
+			px.Start = py.Start
+
+		} else if py.Start < px.Start {
+			// y is partly before x:
+			// split it into a deletion and an edit.
+			add(Edit{py.Start, px.Start, ""})
+			py.Start = px.Start
+
+		} else {
+			// x and y are unequal non-insertions
+			// at the same point: conflict.
+			return nil, false
+		}
+	}
+	for ; xi < len(x); xi++ {
+		add(x[xi])
+	}
+	for ; yi < len(y); yi++ {
+		add(y[yi])
+	}
+	return merged, true
+}

Diff for: internal/diff/merge_test.go

@@ -0,0 +1,65 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package diff_test
+
+import (
+	"testing"
+
+	"golang.org/x/tools/internal/diff"
+)
+
+func TestMerge(t *testing.T) {
+	// For convenience, we test Merge using strings, not sequences
+	// of edits, though this does put us at the mercy of the diff
+	// algorithm.
+	for _, test := range []struct {
+		base, x, y string
+		want       string // "!" => conflict
+	}{
+		// independent insertions
+		{"abcdef", "abXcdef", "abcdeYf", "abXcdeYf"},
+		// independent deletions
+		{"abcdef", "acdef", "abcdf", "acdf"},
+		// colocated insertions (X first)
+		{"abcdef", "abcXdef", "abcYdef", "abcXYdef"},
+		// colocated identical insertions (coalesced)
+		{"abcdef", "abcXdef", "abcXdef", "abcXdef"},
+		// colocated insertions with common prefix (X first)
+		// TODO(adonovan): would "abcXYdef" be better?
+		// i.e. should we dissect the insertions?
+		{"abcdef", "abcXdef", "abcXYdef", "abcXXYdef"},
+		// mix of identical and independent insertions (X first)
+		{"abcdef", "aIbcdXef", "aIbcdYef", "aIbcdXYef"},
+		// independent deletions
+		{"abcdef", "def", "abc", ""},
+		// overlapping deletions: conflict
+		{"abcdef", "adef", "abef", "!"},
+		// overlapping deletions with distinct insertions, X first
+		{"abcdef", "abXef", "abcYf", "!"},
+		// overlapping deletions with distinct insertions, Y first
+		{"abcdef", "abcXf", "abYef", "!"},
+		// overlapping deletions with common insertions
+		{"abcdef", "abXef", "abcXf", "!"},
+		// trailing insertions in X (observe X bias)
+		{"abcdef", "aXbXcXdXeXfX", "aYbcdef", "aXYbXcXdXeXfX"},
+		// trailing insertions in Y (observe X bias)
+		{"abcdef", "aXbcdef", "aYbYcYdYeYfY", "aXYbYcYdYeYfY"},
+	} {
+		dx := diff.Strings(test.base, test.x)
+		dy := diff.Strings(test.base, test.y)
+		got := "!" // conflict
+		if dz, ok := diff.Merge(dx, dy); ok {
+			var err error
+			got, err = diff.Apply(test.base, dz)
+			if err != nil {
+				t.Errorf("Merge(%q, %q, %q) produced invalid edits %v: %v", test.base, test.x, test.y, dz, err)
+				continue
+			}
+		}
+		if test.want != got {
+			t.Errorf("base=%q x=%q y=%q: got %q, want %q", test.base, test.x, test.y, got, test.want)
+		}
+	}
+}