replay: support replaying 2-parent merges

Documentation/git-history.adoc

@@ -40,13 +40,39 @@ at once.
 LIMITATIONS
 -----------
 
-This command does not (yet) work with histories that contain merges. You
-should use linkgit:git-rebase[1] with the `--rebase-merges` flag instead.
-
-Furthermore, the command does not support operations that can result in merge
-conflicts. This limitation is by design as history rewrites are not intended to
-be stateful operations. The limitation can be lifted once (if) Git learns about
-first-class conflicts.
+This command supports two-parent merge commits in the rewrite path:
+the auto-remerged tree of the original parents, the merge commit
+itself, and the auto-merged tree of the rewritten parents are
+combined so that the user's manual conflict resolution (textual or
+semantic) is preserved through the replay. Octopus merges (more than
+two parents) are not supported and are rejected with an error.
+
+When only one of the two parents of a merge has been rewritten, it
+is possible for the rewritten parent and the unchanged parent to
+conflict on a region that the original parents did not conflict on.
+The user's original resolution of the merge cannot speak to such a
+fresh conflict because it never existed at the time the merge was
+made. In that situation the replay stops and reports a conflict on
+the affected path rather than silently committing a tree whose
+content is taken from the rewritten side. Resolve the new conflict
+the same way you would resolve any other merge conflict, then
+continue. Paths managed by a binary, custom, or other non-textual
+merge driver are treated the same way: a fresh inner conflict on
+such a path is surfaced, never absorbed.
+
+The replay propagates the textual diffs the user actually made in
+the merge commit. It does _not_ extrapolate symbol-level intent: if
+rewriting the parents pulls in genuinely new content (for example, a
+new caller of a function that the merge renamed), that new content
+is _not_ rewritten by the replay and may need a follow-up edit.
+Symbol-aware refactoring is out of scope here, just as it is for
+plain rebase.
+
+The command does not support operations that can result in merge
+conflicts on the replayed merge itself. This limitation is by design
+as history rewrites are not intended to be stateful operations. Use
+linkgit:git-rebase[1] with the `--rebase-merges` flag when the
+rewrite is expected to require interactive conflict resolution.
 
 COMMANDS
 --------

Makefile

@@ -832,6 +832,7 @@ TEST_BUILTINS_OBJS += test-hash-speed.o
 TEST_BUILTINS_OBJS += test-hash.o
 TEST_BUILTINS_OBJS += test-hashmap.o
 TEST_BUILTINS_OBJS += test-hexdump.o
+TEST_BUILTINS_OBJS += test-historian.o
 TEST_BUILTINS_OBJS += test-json-writer.o
 TEST_BUILTINS_OBJS += test-lazy-init-name-hash.o
 TEST_BUILTINS_OBJS += test-match-trees.o

TODO

@@ -0,0 +1,4 @@
+if only one of the parents has been rebased (i.e. we're
+replaying O with parents P1' and P2) then can we just cherry-pick the merge -
+instead of merging P1' and P2, use P1 as the merge-base with O and P1' as the
+merge heads?

builtin/history.c

@@ -195,15 +195,15 @@ static int parse_ref_action(const struct option *opt, const char *value, int uns
 	return 0;
 }
 
-static int revwalk_contains_merges(struct repository *repo,
-				   const struct strvec *revwalk_args)
+static int revwalk_contains_octopus_merges(struct repository *repo,
+					   const struct strvec *revwalk_args)
 {
 	struct strvec args = STRVEC_INIT;
 	struct rev_info revs;
 	int ret;
 
 	strvec_pushv(&args, revwalk_args->v);
-	strvec_push(&args, "--min-parents=2");
+	strvec_push(&args, "--min-parents=3");
 
 	repo_init_revisions(repo, &revs, NULL);
 
@@ -217,7 +217,7 @@ static int revwalk_contains_merges(struct repository *repo,
 	}
 
 	if (get_revision(&revs)) {
-		ret = error(_("replaying merge commits is not supported yet!"));
+		ret = error(_("replaying octopus merges is not supported"));
 		goto out;
 	}
 
@@ -289,7 +289,7 @@ static int setup_revwalk(struct repository *repo,
 		strvec_push(&args, "HEAD");
 	}
 
-	ret = revwalk_contains_merges(repo, &args);
+	ret = revwalk_contains_octopus_merges(repo, &args);
 	if (ret < 0)
 		goto out;
 
@@ -482,6 +482,9 @@ static int cmd_history_reword(int argc,
 	if (ret < 0) {
 		ret = error(_("failed replaying descendants"));
 		goto out;
+	} else if (ret) {
+		ret = error(_("conflict during replay; some descendants were not rewritten"));
+		goto out;
 	}
 
 	ret = 0;
@@ -721,6 +724,9 @@ static int cmd_history_split(int argc,
 	if (ret < 0) {
 		ret = error(_("failed replaying descendants"));
 		goto out;
+	} else if (ret) {
+		ret = error(_("conflict during replay; some descendants were not rewritten"));
+		goto out;
 	}
 
 	ret = 0;

merge-ll.c

@@ -141,6 +141,9 @@ static enum ll_merge_result ll_xdl_merge(const struct ll_merge_driver *drv_unuse
 	xmp.ancestor = orig_name;
 	xmp.file1 = name1;
 	xmp.file2 = name2;
+	xmp.out_intervals = opts->out_intervals;
+	xmp.in_orig_intervals = opts->in_orig_intervals;
+	xmp.in_side2_intervals = opts->in_side2_intervals;
 	status = xdl_merge(orig, src1, src2, &xmp, result);
 	ret = (status > 0) ? LL_MERGE_CONFLICT : status;
 	return ret;

merge-ll.h

@@ -83,6 +83,20 @@ struct ll_merge_options {
 
 	/* Extra xpparam_t flags as defined in xdiff/xdiff.h. */
 	long xdl_opts;
+
+	/*
+	 * Forwarded onto xmparam_t. See xdiff/xdiff.h:s_xmparam.
+	 * `out_intervals`, when set, receives the byte ranges of
+	 * every conflict-marker hunk xdl_merge writes into the
+	 * result buffer. `in_orig_intervals` and
+	 * `in_side2_intervals` request the newly-introduced-conflict
+	 * detection in the outer merge of a replayed merge commit;
+	 * setting `in_side2_intervals` to a non-NULL pointer is the
+	 * opt-in.
+	 */
+	struct xdl_conflict_intervals *out_intervals;
+	struct xdl_conflict_intervals *in_orig_intervals;
+	struct xdl_conflict_intervals *in_side2_intervals;
 };
 
 #define LL_MERGE_OPTIONS_INIT { .conflict_style = -1 }

merge-ort.c

@@ -1371,13 +1371,31 @@ static int collect_merge_info_callback(int n,
 	 * files, then we can use side2 as the resolution.  We cannot
 	 * necessarily do so this for trees, because there may be rename
 	 * destinations within side2.
+	 *
+	 * Under the replay-merge interval side channel, however, this
+	 * shortcut would silently install side2's blob even when an
+	 * earlier inner merge left an unresolved conflict on the path:
+	 * the conflict-marker bytes (or, for non-textual drivers, the
+	 * unresolved binary blob) would land in the result verbatim.
+	 * Skip the shortcut when a side-channel entry says side2 is
+	 * unresolved for this path; the path then falls through to the
+	 * full content merge below, where xdl_merge or the loud-gate
+	 * for non-xdiff drivers will surface the conflict.
 	 */
 	if (side1_matches_mbase && filemask == 0x07) {
-		/* use side2 version as resolution */
-		setup_path_info(opt, &pi, dirname, info->pathlen, fullpath,
-				names, names+2, side2_null, 0,
-				filemask, dirmask, 1);
-		return mask;
+		int side2_unresolved = 0;
+
+		if (opt->in_replay_side2_intervals &&
+		    strmap_get(opt->in_replay_side2_intervals, fullpath))
+			side2_unresolved = 1;
+
+		if (!side2_unresolved) {
+			/* use side2 version as resolution */
+			setup_path_info(opt, &pi, dirname, info->pathlen, fullpath,
+					names, names+2, side2_null, 0,
+					filemask, dirmask, 1);
+			return mask;
+		}
 	}
 
 	/* Similar to above but swapping sides 1 and 2 */
@@ -2105,6 +2123,7 @@ static int merge_3way(struct merge_options *opt,
 {
 	mmfile_t orig, src1, src2;
 	struct ll_merge_options ll_opts = LL_MERGE_OPTIONS_INIT;
+	struct xdl_conflict_intervals out_intervals = { 0 };
 	char *base, *name1, *name2;
 	enum ll_merge_result merge_status;
 
@@ -2115,6 +2134,14 @@ static int merge_3way(struct merge_options *opt,
 	ll_opts.extra_marker_size = extra_marker_size;
 	ll_opts.xdl_opts = opt->xdl_opts;
 	ll_opts.conflict_style = opt->conflict_style;
+	if (opt->out_replay_intervals)
+		ll_opts.out_intervals = &out_intervals;
+	if (opt->in_replay_orig_intervals)
+		ll_opts.in_orig_intervals =
+			strmap_get(opt->in_replay_orig_intervals, path);
+	if (opt->in_replay_side2_intervals)
+		ll_opts.in_side2_intervals =
+			strmap_get(opt->in_replay_side2_intervals, path);
 
 	if (opt->priv->call_depth) {
 		ll_opts.virtual_ancestor = 1;
@@ -2157,6 +2184,28 @@ static int merge_3way(struct merge_options *opt,
 			 "warning: Cannot merge binary files: %s (%s vs. %s)",
 			 path, name1, name2);
 
+	if (opt->out_replay_intervals &&
+	    (out_intervals.nr > 0 ||
+	     merge_status == LL_MERGE_CONFLICT ||
+	     merge_status == LL_MERGE_BINARY_CONFLICT)) {
+		/*
+		 * Inner content merge for this path emitted markers
+		 * (recorded as intervals) or otherwise failed to
+		 * resolve (binary driver or other non-textual
+		 * driver). Either way, the path carries an
+		 * unresolved inner conflict that the outer merge
+		 * needs to know about; transfer ownership of the
+		 * recorded intervals (possibly empty) into the
+		 * caller-owned strmap.
+		 */
+		struct xdl_conflict_intervals *stored;
+		stored = xmalloc(sizeof(*stored));
+		*stored = out_intervals;
+		strmap_put(opt->out_replay_intervals, path, stored);
+	} else {
+		xdl_conflict_intervals_release(&out_intervals);
+	}
+
 	free(base);
 	free(name1);
 	free(name2);
@@ -4216,6 +4265,26 @@ static int process_entry(struct merge_options *opt,
 			assert(othermask == 2 || othermask == 4);
 			assert(ci->merged.is_null ==
 			       (ci->filemask == ci->match_mask));
+
+			/*
+			 * Replay-merge side channel: when this match_mask
+			 * shortcut would have taken side2's blob verbatim
+			 * (match_mask == 3 means stages 0 and 1 agree,
+			 * stage 2 differs), but an earlier inner merge
+			 * recorded that side2 is unresolved for this
+			 * path, surface a content conflict instead of
+			 * silently committing the inner-conflict blob.
+			 */
+			if (ci->merged.clean && side == 2 &&
+			    !ci->merged.is_null &&
+			    opt->in_replay_side2_intervals &&
+			    strmap_get(opt->in_replay_side2_intervals, path)) {
+				ci->merged.clean = 0;
+				path_msg(opt, CONFLICT_CONTENTS, 0,
+					 path, NULL, NULL, NULL,
+					 _("CONFLICT (content): Merge conflict in %s"),
+					 path);
+			}
 		}
 	} else if (ci->filemask >= 6 &&
 		   (S_IFMT & ci->stages[1].mode) !=
@@ -5433,8 +5502,6 @@ void merge_incore_recursive(struct merge_options *opt,
 	 * allow one exception through so that builtin/am can override
 	 * with its constructed fake ancestor.
 	 */
-	assert(opt->ancestor == NULL ||
-	       (merge_bases && !merge_bases->next));
 
 	trace2_region_enter("merge", "merge_start", opt->repo);
 	merge_start(opt, result);

merge-ort.h

@@ -87,6 +87,39 @@ struct merge_options {
 	unsigned record_conflict_msgs_as_headers : 1;
 	const char *msg_header_prefix;
 
+	/*
+	 * Conflict-interval side channel for replay-merge. Each strmap,
+	 * when non-NULL, maps a path to a heap-allocated
+	 * `struct xdl_conflict_intervals *`. The caller owns both the
+	 * strmaps and the value pointers.
+	 *
+	 *   out_replay_intervals: populated by the per-path content
+	 *     merge. After ll_merge returns for a path, the recorded
+	 *     intervals are moved into a freshly allocated struct
+	 *     stored under the path. Paths whose inner content merge
+	 *     was clean do not appear; paths whose ll_merge call
+	 *     produced conflict markers (text driver) or returned a
+	 *     non-clean status (binary, custom, union, ours/theirs)
+	 *     do.
+	 *
+	 *   in_replay_orig_intervals, in_replay_side2_intervals:
+	 *     looked up per path during the outer merge and forwarded
+	 *     into ll_merge_options.in_orig_intervals /
+	 *     ll_merge_options.in_side2_intervals so that xdl_merge
+	 *     can detect a conflict in mf2 (side2) that has no
+	 *     counterpart in orig.
+	 *
+	 *     The fast paths in collect_merge_info_callback() and
+	 *     process_entry() that would otherwise take side2's blob
+	 *     verbatim also consult `in_replay_side2_intervals`: a
+	 *     present entry forces the path through the full content
+	 *     merge (or, when the entry was recorded for a non-xdiff
+	 *     driver, surfaces an explicit conflict).
+	 */
+	struct strmap *out_replay_intervals;
+	struct strmap *in_replay_orig_intervals;
+	struct strmap *in_replay_side2_intervals;
+
 	/* internal fields used by the implementation */
 	struct merge_options_internal *priv;
 };