From af818d63126afcfc708b23eb0e5cc66a99274b54 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <gitster@pobox.com>
Date: Tue, 14 Apr 2026 13:34:01 -0700
Subject: [PATCH] Revert "Merge branch 'hn/git-checkout-m-with-stash' into
 next"

This reverts commit b4e5a964fa85a84a9328647486c250706ad6501d, reversing
changes made to 0e6c98f313ae3e75cedad7125c9b4ab3ba1065c2, as the topic
is still getting rerolled.
---
 Documentation/git-checkout.adoc |  60 +++++-----
 Documentation/git-stash.adoc    |  11 +-
 Documentation/git-switch.adoc   |  33 +++---
 builtin/checkout.c              | 138 ++++++++++++----------
 builtin/stash.c                 |  32 ++----
 sequencer.c                     |  67 +++--------
 sequencer.h                     |   4 -
 t/t3420-rebase-autostash.sh     |  24 +---
 t/t3903-stash.sh                |  29 -----
 t/t7201-co.sh                   | 195 --------------------------------
 t/t7600-merge.sh                |   2 +-
 xdiff-interface.c               |  12 --
 xdiff-interface.h               |   1 -
 xdiff/xmerge.c                  |   6 +-
 14 files changed, 158 insertions(+), 456 deletions(-)

diff --git a/Documentation/git-checkout.adoc b/Documentation/git-checkout.adoc
index 70dd211ee3..43ccf47cf6 100644
--- a/Documentation/git-checkout.adoc
+++ b/Documentation/git-checkout.adoc
@@ -251,19 +251,20 @@ working tree, by copying them from elsewhere, extracting a tarball, etc.
 	are different between the current branch and the branch to
 	which you are switching, the command refuses to switch
 	branches in order to preserve your modifications in context.
-	With this option, the conflicting local changes are
-	automatically stashed before the switch and reapplied
-	afterwards.  If the local changes do not overlap with the
-	differences between branches, the switch proceeds without
-	stashing.  If reapplying the stash results in conflicts, the
-	entry is saved to the stash list.  Resolve the conflicts
-	and run `git stash drop` when done, or clear the working
-	tree (e.g. with `git reset --hard`) before running `git stash
-	pop` later to re-apply your changes.
+	However, with this option, a three-way merge between the current
+	branch, your working tree contents, and the new branch
+	is done, and you will be on the new branch.
++
+When a merge conflict happens, the index entries for conflicting
+paths are left unmerged, and you need to resolve the conflicts
+and mark the resolved paths with `git add` (or `git rm` if the merge
+should result in deletion of the path).
 +
 When checking out paths from the index, this option lets you recreate
 the conflicted merge in the specified paths.  This option cannot be
 used when checking out paths from a tree-ish.
++
+When switching branches with `--merge`, staged changes may be lost.
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the
@@ -577,44 +578,39 @@ $ git checkout mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would carry your local
-changes to the new branch:
+You can give the `-m` flag to the command, which would try a
+three-way merge:
 
 ------------
 $ git checkout -m mytopic
-Switched to branch 'mytopic'
+Auto-merging frotz
 ------------
 
-After the switch, the local modifications are reapplied and are _not_
+After this three-way merge, the local modifications are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 
 === 3. Merge conflict
 
-When the `--merge` (`-m`) option is in effect and the locally
-modified files overlap with files that need to be updated by the
-branch switch, the changes are stashed and reapplied after the
-switch.  If this process results in conflicts, a stash entry is saved
-and made available in `git stash list`:
+When a merge conflict happens during switching branches with
+the `-m` option, you would see something like this:
 
 ------------
 $ git checkout -m mytopic
-Your local changes are stashed, however, applying it to carry
-forward your local changes resulted in conflicts:
-
- - You can try resolving them now.  If you resolved them
-   successfully, discard the stash entry with "git stash drop".
-
- - Alternatively you can "git reset --hard" if you do not want
-   to deal with them right now, and later "git stash pop" to
-   recover your local changes.
+Auto-merging frotz
+ERROR: Merge conflict in frotz
+fatal: merge program failed
 ------------
 
-You can try resolving the conflicts now.  Edit the conflicting files
-and mark them resolved with `git add` as usual, then run `git stash
-drop` to discard the stash entry.  Alternatively, you can clear the
-working tree with `git reset --hard` and recover your local changes
-later with `git stash pop`.
+At this point, `git diff` shows the changes cleanly merged as in
+the previous example, as well as the changes in the conflicted
+files.  Edit and resolve the conflict and mark it resolved with
+`git add` as usual:
+
+------------
+$ edit frotz
+$ git add frotz
+------------
 
 CONFIGURATION
 -------------
diff --git a/Documentation/git-stash.adoc b/Documentation/git-stash.adoc
index 50bb89f483..b05c990ecd 100644
--- a/Documentation/git-stash.adoc
+++ b/Documentation/git-stash.adoc
@@ -12,7 +12,7 @@ git stash list [<log-options>]
 git stash show [-u | --include-untracked | --only-untracked] [<diff-options>] [<stash>]
 git stash drop [-q | --quiet] [<stash>]
 git stash pop [--index] [-q | --quiet] [<stash>]
-git stash apply [--index] [-q | --quiet] [--label-ours=<label>] [--label-theirs=<label>] [--label-base=<label>] [<stash>]
+git stash apply [--index] [-q | --quiet] [<stash>]
 git stash branch <branchname> [<stash>]
 git stash [push] [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
 	     [-u | --include-untracked] [-a | --all] [(-m | --message) <message>]
@@ -195,15 +195,6 @@ the index's ones. However, this can fail, when you have conflicts
 (which are stored in the index, where you therefore can no longer
 apply the changes as they were originally).
 
-`--label-ours=<label>`::
-`--label-theirs=<label>`::
-`--label-base=<label>`::
-	These options are only valid for the `apply` command.
-+
-Use the given labels in conflict markers instead of the default
-"Updated upstream", "Stashed changes", and "Stash base".
-`--label-base` only has an effect with merge.conflictStyle=diff3.
-
 `-k`::
 `--keep-index`::
 `--no-keep-index`::
diff --git a/Documentation/git-switch.adoc b/Documentation/git-switch.adoc
index ee58a4d0fd..87707e9265 100644
--- a/Documentation/git-switch.adoc
+++ b/Documentation/git-switch.adoc
@@ -123,19 +123,18 @@ variable.
 
 `-m`::
 `--merge`::
-	If you have local modifications to one or more files that
-	are different between the current branch and the branch to
-	which you are switching, the command normally refuses to
-	switch branches in order to preserve your modifications in
-	context.  However, with this option, the conflicting local
-	changes are automatically stashed before the switch and
-	reapplied afterwards.  If the local changes do not overlap
-	with the differences between branches, the switch proceeds
-	without stashing.  If reapplying the stash results in
-	conflicts, the entry is saved to the stash list.  Resolve
-	the conflicts and run `git stash drop` when done, or clear
-	the working tree (e.g. with `git reset --hard`) before
-	running `git stash pop` later to re-apply your changes.
+	If you have local modifications to one or more files that are
+	different between the current branch and the branch to which
+	you are switching, the command refuses to switch branches in
+	order to preserve your modifications in context.  However,
+	with this option, a three-way merge between the current
+	branch, your working tree contents, and the new branch is
+	done, and you will be on the new branch.
++
+When a merge conflict happens, the index entries for conflicting
+paths are left unmerged, and you need to resolve the conflicts
+and mark the resolved paths with `git add` (or `git rm` if the merge
+should result in deletion of the path).
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the
@@ -218,15 +217,15 @@ $ git switch mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would carry your local
-changes to the new branch:
+You can give the `-m` flag to the command, which would try a three-way
+merge:
 
 ------------
 $ git switch -m mytopic
-Switched to branch 'mytopic'
+Auto-merging frotz
 ------------
 
-After the switch, the local modifications are reapplied and are _not_
+After this three-way merge, the local modifications are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 
diff --git a/builtin/checkout.c b/builtin/checkout.c
index 4671ff3804..ac0186a33e 100644
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -17,6 +17,7 @@
 #include "merge-ll.h"
 #include "lockfile.h"
 #include "mem-pool.h"
+#include "merge-ort-wrappers.h"
 #include "object-file.h"
 #include "object-name.h"
 #include "odb.h"
@@ -29,7 +30,6 @@
 #include "repo-settings.h"
 #include "resolve-undo.h"
 #include "revision.h"
-#include "sequencer.h"
 #include "setup.h"
 #include "strvec.h"
 #include "submodule.h"
@@ -790,10 +790,8 @@ static int merge_working_tree(const struct checkout_opts *opts,
 	struct tree *new_tree;
 
 	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
-	if (repo_read_index_preload(the_repository, NULL, 0) < 0) {
-		rollback_lock_file(&lock_file);
+	if (repo_read_index_preload(the_repository, NULL, 0) < 0)
 		return error(_("index file corrupt"));
-	}
 
 	resolve_undo_clear_index(the_repository->index);
 	if (opts->new_orphan_branch && opts->orphan_from_empty_tree) {
@@ -806,18 +804,14 @@ static int merge_working_tree(const struct checkout_opts *opts,
 	} else {
 		new_tree = repo_get_commit_tree(the_repository,
 						new_branch_info->commit);
-		if (!new_tree) {
-			rollback_lock_file(&lock_file);
+		if (!new_tree)
 			return error(_("unable to read tree (%s)"),
 				     oid_to_hex(&new_branch_info->commit->object.oid));
-		}
 	}
 	if (opts->discard_changes) {
 		ret = reset_tree(new_tree, opts, 1, writeout_error, new_branch_info);
-		if (ret) {
-			rollback_lock_file(&lock_file);
+		if (ret)
 			return ret;
-		}
 	} else {
 		struct tree_desc trees[2];
 		struct tree *tree;
@@ -827,7 +821,6 @@ static int merge_working_tree(const struct checkout_opts *opts,
 		refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);
 
 		if (unmerged_index(the_repository->index)) {
-			rollback_lock_file(&lock_file);
 			error(_("you need to resolve your current index first"));
 			return 1;
 		}
@@ -860,8 +853,82 @@ static int merge_working_tree(const struct checkout_opts *opts,
 		ret = unpack_trees(2, trees, &topts);
 		clear_unpack_trees_porcelain(&topts);
 		if (ret == -1) {
-			rollback_lock_file(&lock_file);
-			return 1;
+			/*
+			 * Unpack couldn't do a trivial merge; either
+			 * give up or do a real merge, depending on
+			 * whether the merge flag was used.
+			 */
+			struct tree *work;
+			struct tree *old_tree;
+			struct merge_options o;
+			struct strbuf sb = STRBUF_INIT;
+			struct strbuf old_commit_shortname = STRBUF_INIT;
+
+			if (!opts->merge)
+				return 1;
+
+			/*
+			 * Without old_branch_info->commit, the below is the same as
+			 * the two-tree unpack we already tried and failed.
+			 */
+			if (!old_branch_info->commit)
+				return 1;
+			old_tree = repo_get_commit_tree(the_repository,
+							old_branch_info->commit);
+
+			if (repo_index_has_changes(the_repository, old_tree, &sb))
+				die(_("cannot continue with staged changes in "
+				      "the following files:\n%s"), sb.buf);
+			strbuf_release(&sb);
+
+			/* Do more real merge */
+
+			/*
+			 * We update the index fully, then write the
+			 * tree from the index, then merge the new
+			 * branch with the current tree, with the old
+			 * branch as the base. Then we reset the index
+			 * (but not the working tree) to the new
+			 * branch, leaving the working tree as the
+			 * merged version, but skipping unmerged
+			 * entries in the index.
+			 */
+
+			add_files_to_cache(the_repository, NULL, NULL, NULL, 0,
+					0, 0);
+			init_ui_merge_options(&o, the_repository);
+			o.verbosity = 0;
+			work = write_in_core_index_as_tree(the_repository,
+							   the_repository->index);
+
+			ret = reset_tree(new_tree,
+					 opts, 1,
+					 writeout_error, new_branch_info);
+			if (ret)
+				return ret;
+			o.ancestor = old_branch_info->name;
+			if (!old_branch_info->name) {
+				strbuf_add_unique_abbrev(&old_commit_shortname,
+							 &old_branch_info->commit->object.oid,
+							 DEFAULT_ABBREV);
+				o.ancestor = old_commit_shortname.buf;
+			}
+			o.branch1 = new_branch_info->name;
+			o.branch2 = "local";
+			o.conflict_style = opts->conflict_style;
+			ret = merge_ort_nonrecursive(&o,
+						     new_tree,
+						     work,
+						     old_tree);
+			if (ret < 0)
+				die(NULL);
+			ret = reset_tree(new_tree,
+					 opts, 0,
+					 writeout_error, new_branch_info);
+			strbuf_release(&o.obuf);
+			strbuf_release(&old_commit_shortname);
+			if (ret)
+				return ret;
 		}
 	}
 
@@ -1106,9 +1173,6 @@ static int switch_branches(const struct checkout_opts *opts,
 	struct object_id rev;
 	int flag, writeout_error = 0;
 	int do_merge = 1;
-	int created_autostash = 0;
-	struct strbuf old_commit_shortname = STRBUF_INIT;
-	const char *stash_label_base = NULL;
 
 	trace2_cmd_mode("branch");
 
@@ -1146,31 +1210,10 @@ static int switch_branches(const struct checkout_opts *opts,
 			do_merge = 0;
 	}
 
-	if (old_branch_info.name)
-		stash_label_base = old_branch_info.name;
-	else if (old_branch_info.commit) {
-		strbuf_add_unique_abbrev(&old_commit_shortname,
-					 &old_branch_info.commit->object.oid,
-					 DEFAULT_ABBREV);
-		stash_label_base = old_commit_shortname.buf;
-	}
-
 	if (do_merge) {
 		ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
-		if (ret && opts->merge) {
-			create_autostash_ref_silent(the_repository,
-						   "CHECKOUT_AUTOSTASH_HEAD");
-			created_autostash = 1;
-			ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
-		}
 		if (ret) {
-			apply_autostash_ref_with_labels(the_repository,
-						       "CHECKOUT_AUTOSTASH_HEAD",
-						       new_branch_info->name,
-						       "local",
-						       stash_label_base);
 			branch_info_release(&old_branch_info);
-			strbuf_release(&old_commit_shortname);
 			return ret;
 		}
 	}
@@ -1180,29 +1223,8 @@ static int switch_branches(const struct checkout_opts *opts,
 
 	update_refs_for_switch(opts, &old_branch_info, new_branch_info);
 
-	if (opts->conflict_style >= 0) {
-		struct strbuf cfg = STRBUF_INIT;
-		strbuf_addf(&cfg, "merge.conflictStyle=%s",
-			    conflict_style_name(opts->conflict_style));
-		git_config_push_parameter(cfg.buf);
-		strbuf_release(&cfg);
-	}
-	apply_autostash_ref_with_labels(the_repository, "CHECKOUT_AUTOSTASH_HEAD",
-				       new_branch_info->name, "local",
-				       stash_label_base);
-
-	discard_index(the_repository->index);
-	if (repo_read_index(the_repository) < 0)
-		die(_("index file corrupt"));
-
-	if (created_autostash && !opts->discard_changes && !opts->quiet &&
-	    new_branch_info->commit)
-		show_local_changes(&new_branch_info->commit->object,
-				   &opts->diff_options);
-
 	ret = post_checkout_hook(old_branch_info.commit, new_branch_info->commit, 1);
 	branch_info_release(&old_branch_info);
-	strbuf_release(&old_commit_shortname);
 
 	return ret || writeout_error;
 }
diff --git a/builtin/stash.c b/builtin/stash.c
index 00314e2b13..0d27b2fb1f 100644
--- a/builtin/stash.c
+++ b/builtin/stash.c
@@ -44,7 +44,7 @@
 #define BUILTIN_STASH_POP_USAGE \
 	N_("git stash pop [--index] [-q | --quiet] [<stash>]")
 #define BUILTIN_STASH_APPLY_USAGE \
-	N_("git stash apply [--index] [-q | --quiet] [--label-ours=<label>] [--label-theirs=<label>] [--label-base=<label>] [<stash>]")
+	N_("git stash apply [--index] [-q | --quiet] [<stash>]")
 #define BUILTIN_STASH_BRANCH_USAGE \
 	N_("git stash branch <branchname> [<stash>]")
 #define BUILTIN_STASH_STORE_USAGE \
@@ -590,11 +590,8 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
 		die(_("could not write index"));
 }
 
-static int do_apply_stash_with_labels(const char *prefix,
-				      struct stash_info *info,
-				      int index, int quiet,
-				      const char *label_ours, const char *label_theirs,
-				      const char *label_base)
+static int do_apply_stash(const char *prefix, struct stash_info *info,
+			  int index, int quiet)
 {
 	int clean, ret;
 	int has_index = index;
@@ -646,9 +643,9 @@ static int do_apply_stash_with_labels(const char *prefix,
 
 	init_ui_merge_options(&o, the_repository);
 
-	o.branch1 = label_ours ? label_ours : "Updated upstream";
-	o.branch2 = label_theirs ? label_theirs : "Stashed changes";
-	o.ancestor = label_base ? label_base : "Stash base";
+	o.branch1 = "Updated upstream";
+	o.branch2 = "Stashed changes";
+	o.ancestor = "Stash base";
 
 	if (oideq(&info->b_tree, &c_tree))
 		o.branch1 = "Version stash was based on";
@@ -720,31 +717,17 @@ restore_untracked:
 	return ret;
 }
 
-static int do_apply_stash(const char *prefix, struct stash_info *info,
-			  int index, int quiet)
-{
-	return do_apply_stash_with_labels(prefix, info, index, quiet,
-					  NULL, NULL, NULL);
-}
-
 static int apply_stash(int argc, const char **argv, const char *prefix,
 		       struct repository *repo UNUSED)
 {
 	int ret = -1;
 	int quiet = 0;
 	int index = use_index;
-	const char *label_ours = NULL, *label_theirs = NULL, *label_base = NULL;
 	struct stash_info info = STASH_INFO_INIT;
 	struct option options[] = {
 		OPT__QUIET(&quiet, N_("be quiet, only report errors")),
 		OPT_BOOL(0, "index", &index,
 			 N_("attempt to recreate the index")),
-		OPT_STRING(0, "label-ours", &label_ours, N_("label"),
-			   N_("label for the upstream side in conflict markers")),
-		OPT_STRING(0, "label-theirs", &label_theirs, N_("label"),
-			   N_("label for the stashed side in conflict markers")),
-		OPT_STRING(0, "label-base", &label_base, N_("label"),
-			   N_("label for the base in diff3 conflict markers")),
 		OPT_END()
 	};
 
@@ -754,8 +737,7 @@ static int apply_stash(int argc, const char **argv, const char *prefix,
 	if (get_stash_info(&info, argc, argv))
 		goto cleanup;
 
-	ret = do_apply_stash_with_labels(prefix, &info, index, quiet,
-					 label_ours, label_theirs, label_base);
+	ret = do_apply_stash(prefix, &info, index, quiet);
 cleanup:
 	free_stash_info(&info);
 	return ret;
diff --git a/sequencer.c b/sequencer.c
index 72967886d7..b7d8dca47f 100644
--- a/sequencer.c
+++ b/sequencer.c
@@ -4657,8 +4657,7 @@ static enum todo_command peek_command(struct todo_list *todo_list, int offset)
 
 static void create_autostash_internal(struct repository *r,
 				      const char *path,
-				      const char *refname,
-				      bool silent)
+				      const char *refname)
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct lock_file lock_file = LOCK_INIT;
@@ -4703,8 +4702,7 @@ static void create_autostash_internal(struct repository *r,
 					&oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
 		}
 
-		if (!silent)
-			printf(_("Created autostash: %s\n"), buf.buf);
+		printf(_("Created autostash: %s\n"), buf.buf);
 		if (reset_head(r, &ropts) < 0)
 			die(_("could not reset --hard"));
 		discard_index(r->index);
@@ -4716,22 +4714,15 @@ static void create_autostash_internal(struct repository *r,
 
 void create_autostash(struct repository *r, const char *path)
 {
-	create_autostash_internal(r, path, NULL, false);
+	create_autostash_internal(r, path, NULL);
 }
 
 void create_autostash_ref(struct repository *r, const char *refname)
 {
-	create_autostash_internal(r, NULL, refname, false);
+	create_autostash_internal(r, NULL, refname);
 }
 
-void create_autostash_ref_silent(struct repository *r, const char *refname)
-{
-	create_autostash_internal(r, NULL, refname, true);
-}
-
-static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
-				    const char *label_ours, const char *label_theirs,
-				    const char *label_base)
+static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
 {
 	struct child_process child = CHILD_PROCESS_INIT;
 	int ret = 0;
@@ -4742,12 +4733,6 @@ static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
 		child.no_stderr = 1;
 		strvec_push(&child.args, "stash");
 		strvec_push(&child.args, "apply");
-		if (label_ours)
-			strvec_pushf(&child.args, "--label-ours=%s", label_ours);
-		if (label_theirs)
-			strvec_pushf(&child.args, "--label-theirs=%s", label_theirs);
-		if (label_base)
-			strvec_pushf(&child.args, "--label-base=%s", label_base);
 		strvec_push(&child.args, stash_oid);
 		ret = run_command(&child);
 	}
@@ -4766,23 +4751,15 @@ static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
 		strvec_push(&store.args, stash_oid);
 		if (run_command(&store))
 			ret = error(_("cannot store %s"), stash_oid);
-		else if (attempt_apply)
-			fprintf(stderr,
-				_("Your local changes are stashed, however, applying it to carry\n"
-				  "forward your local changes resulted in conflicts:\n"
-				  "\n"
-				  " - You can try resolving them now.  If you resolved them\n"
-				  "   successfully, discard the stash entry with \"git stash drop\".\n"
-				  "\n"
-				  " - Alternatively you can \"git reset --hard\" if you do not want\n"
-				  "   to deal with them right now, and later \"git stash pop\" to\n"
-				  "   recover your local changes.\n"));
 		else
 			fprintf(stderr,
-				_("Autostash exists; creating a new stash entry.\n"
+				_("%s\n"
 				  "Your changes are safe in the stash.\n"
 				  "You can run \"git stash pop\" or"
-				  " \"git stash drop\" at any time.\n"));
+				  " \"git stash drop\" at any time.\n"),
+				attempt_apply ?
+				_("Applying autostash resulted in conflicts.") :
+				_("Autostash exists; creating a new stash entry."));
 	}
 
 	return ret;
@@ -4800,8 +4777,7 @@ static int apply_save_autostash(const char *path, int attempt_apply)
 	}
 	strbuf_trim(&stash_oid);
 
-	ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply,
-				      NULL, NULL, NULL);
+	ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply);
 
 	unlink(path);
 	strbuf_release(&stash_oid);
@@ -4820,13 +4796,11 @@ int apply_autostash(const char *path)
 
 int apply_autostash_oid(const char *stash_oid)
 {
-	return apply_save_autostash_oid(stash_oid, 1, NULL, NULL, NULL);
+	return apply_save_autostash_oid(stash_oid, 1);
 }
 
 static int apply_save_autostash_ref(struct repository *r, const char *refname,
-				    int attempt_apply,
-				    const char *label_ours, const char *label_theirs,
-				    const char *label_base)
+				    int attempt_apply)
 {
 	struct object_id stash_oid;
 	char stash_oid_hex[GIT_MAX_HEXSZ + 1];
@@ -4842,8 +4816,7 @@ static int apply_save_autostash_ref(struct repository *r, const char *refname,
 		return error(_("autostash reference is a symref"));
 
 	oid_to_hex_r(stash_oid_hex, &stash_oid);
-	ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply,
-				       label_ours, label_theirs, label_base);
+	ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply);
 
 	refs_delete_ref(get_main_ref_store(r), "", refname,
 			&stash_oid, REF_NO_DEREF);
@@ -4853,20 +4826,12 @@ static int apply_save_autostash_ref(struct repository *r, const char *refname,
 
 int save_autostash_ref(struct repository *r, const char *refname)
 {
-	return apply_save_autostash_ref(r, refname, 0, NULL, NULL, NULL);
+	return apply_save_autostash_ref(r, refname, 0);
 }
 
 int apply_autostash_ref(struct repository *r, const char *refname)
 {
-	return apply_save_autostash_ref(r, refname, 1, NULL, NULL, NULL);
-}
-
-int apply_autostash_ref_with_labels(struct repository *r, const char *refname,
-				    const char *label_ours, const char *label_theirs,
-				    const char *label_base)
-{
-	return apply_save_autostash_ref(r, refname, 1,
-					label_ours, label_theirs, label_base);
+	return apply_save_autostash_ref(r, refname, 1);
 }
 
 static int checkout_onto(struct repository *r, struct replay_opts *opts,
diff --git a/sequencer.h b/sequencer.h
index 2c4ff17c4e..a6fa670c7c 100644
--- a/sequencer.h
+++ b/sequencer.h
@@ -230,15 +230,11 @@ void commit_post_rewrite(struct repository *r,
 
 void create_autostash(struct repository *r, const char *path);
 void create_autostash_ref(struct repository *r, const char *refname);
-void create_autostash_ref_silent(struct repository *r, const char *refname);
 int save_autostash(const char *path);
 int save_autostash_ref(struct repository *r, const char *refname);
 int apply_autostash(const char *path);
 int apply_autostash_oid(const char *stash_oid);
 int apply_autostash_ref(struct repository *r, const char *refname);
-int apply_autostash_ref_with_labels(struct repository *r, const char *refname,
-				    const char *label_ours, const char *label_theirs,
-				    const char *label_base);
 
 #define SUMMARY_INITIAL_COMMIT   (1 << 0)
 #define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)
diff --git a/t/t3420-rebase-autostash.sh b/t/t3420-rebase-autostash.sh
index e4e2cb19ce..ad3ba6a984 100755
--- a/t/t3420-rebase-autostash.sh
+++ b/t/t3420-rebase-autostash.sh
@@ -61,30 +61,18 @@ create_expected_failure_apply () {
 	First, rewinding head to replay your work on top of it...
 	Applying: second commit
 	Applying: third commit
-	Your local changes are stashed, however, applying it to carry
-	forward your local changes resulted in conflicts:
-
-	 - You can try resolving them now.  If you resolved them
-	   successfully, discard the stash entry with "git stash drop".
-
-	 - Alternatively you can "git reset --hard" if you do not want
-	   to deal with them right now, and later "git stash pop" to
-	   recover your local changes.
+	Applying autostash resulted in conflicts.
+	Your changes are safe in the stash.
+	You can run "git stash pop" or "git stash drop" at any time.
 	EOF
 }
 
 create_expected_failure_merge () {
 	cat >expected <<-EOF
 	$(grep "^Created autostash: [0-9a-f][0-9a-f]*\$" actual)
-	Your local changes are stashed, however, applying it to carry
-	forward your local changes resulted in conflicts:
-
-	 - You can try resolving them now.  If you resolved them
-	   successfully, discard the stash entry with "git stash drop".
-
-	 - Alternatively you can "git reset --hard" if you do not want
-	   to deal with them right now, and later "git stash pop" to
-	   recover your local changes.
+	Applying autostash resulted in conflicts.
+	Your changes are safe in the stash.
+	You can run "git stash pop" or "git stash drop" at any time.
 	Successfully rebased and updated refs/heads/rebased-feature-branch.
 	EOF
 }
diff --git a/t/t3903-stash.sh b/t/t3903-stash.sh
index 00bcb1f802..70879941c2 100755
--- a/t/t3903-stash.sh
+++ b/t/t3903-stash.sh
@@ -1666,35 +1666,6 @@ test_expect_success 'restore untracked files even when we hit conflicts' '
 	)
 '
 
-test_expect_success 'apply with custom conflict labels' '
-	git init conflict_labels &&
-	(
-		cd conflict_labels &&
-		test_commit base file &&
-		echo stashed >file &&
-		git stash push -m "stashed" &&
-		test_commit upstream file &&
-		test_must_fail git -c merge.conflictStyle=diff3 stash apply --label-ours=UP --label-theirs=STASH &&
-		test_grep "^<<<<<<< UP" file &&
-		test_grep "^||||||| Stash base" file &&
-		test_grep "^>>>>>>> STASH" file
-	)
-'
-
-test_expect_success 'apply with empty conflict labels' '
-	git init empty_labels &&
-	(
-		cd empty_labels &&
-		test_commit base file &&
-		echo stashed >file &&
-		git stash push -m "stashed" &&
-		test_commit upstream file &&
-		test_must_fail git stash apply --label-ours= --label-theirs= &&
-		test_grep "^<<<<<<<$" file &&
-		test_grep "^>>>>>>>$" file
-	)
-'
-
 test_expect_success 'stash create reports a locked index' '
 	test_when_finished "rm -rf repo" &&
 	git init repo &&
diff --git a/t/t7201-co.sh b/t/t7201-co.sh
index 8f02a664f4..9bcf7c0b40 100755
--- a/t/t7201-co.sh
+++ b/t/t7201-co.sh
@@ -210,201 +210,6 @@ test_expect_success 'checkout --merge --conflict=diff3 <branch>' '
 	test_cmp expect two
 '
 
-test_expect_success 'checkout --merge --conflict=zdiff3 <branch>' '
-	git checkout -f main &&
-	git reset --hard &&
-	git clean -f &&
-
-	fill a b X d e >two &&
-	git checkout --merge --conflict=zdiff3 simple &&
-
-	cat <<-EOF >expect &&
-	a
-	<<<<<<< simple
-	c
-	||||||| main
-	b
-	c
-	d
-	=======
-	b
-	X
-	d
-	>>>>>>> local
-	e
-	EOF
-	test_cmp expect two
-'
-
-test_expect_success 'checkout -m respects merge.conflictStyle config' '
-	git checkout -f main &&
-	git reset --hard &&
-	git clean -f &&
-
-	test_config merge.conflictStyle diff3 &&
-	fill b d >two &&
-	git checkout -m simple &&
-
-	cat <<-EOF >expect &&
-	<<<<<<< simple
-	a
-	c
-	e
-	||||||| main
-	a
-	b
-	c
-	d
-	e
-	=======
-	b
-	d
-	>>>>>>> local
-	EOF
-	test_cmp expect two
-'
-
-test_expect_success 'checkout -m skips stash when no conflict' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 0 x y z >same &&
-	git stash list >stash-before &&
-	git checkout -m side >actual 2>&1 &&
-	test_grep ! "Created autostash" actual &&
-	git stash list >stash-after &&
-	test_cmp stash-before stash-after &&
-	fill 0 x y z >expect &&
-	test_cmp expect same
-'
-
-test_expect_success 'checkout -m skips stash with non-conflicting dirty index' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 0 x y z >same &&
-	git add same &&
-	git checkout -m side >actual 2>&1 &&
-	test_grep ! "Created autostash" actual &&
-	fill 0 x y z >expect &&
-	test_cmp expect same
-'
-
-test_expect_success 'checkout -m stashes and applies on conflicting changes' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 1 2 3 4 5 6 7 >one &&
-	git checkout -m side >actual 2>&1 &&
-	test_grep ! "Created autostash" actual &&
-	test_grep "Applied autostash" actual &&
-	fill 1 2 3 4 5 6 7 >expect &&
-	test_cmp expect one
-'
-
-test_expect_success 'checkout -m with mixed staged and unstaged changes' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 0 x y z >same &&
-	git add same &&
-	fill 1 2 3 4 5 6 7 >one &&
-	git checkout -m side >actual 2>&1 &&
-	test_grep ! "Created autostash" actual &&
-	test_grep "Applied autostash" actual &&
-	fill 0 x y z >expect &&
-	test_cmp expect same &&
-	fill 1 2 3 4 5 6 7 >expect &&
-	test_cmp expect one
-'
-
-test_expect_success 'checkout -m stashes on truly conflicting changes' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 1 2 3 4 5 >one &&
-	test_must_fail git checkout side 2>stderr &&
-	test_grep "Your local changes" stderr &&
-	git checkout -m side >actual 2>&1 &&
-	test_grep ! "Created autostash" actual &&
-	test_grep "resulted in conflicts" actual &&
-	test_grep "git stash drop" actual &&
-	git stash drop &&
-	git reset --hard
-'
-
-test_expect_success 'checkout -m produces usable stash on conflict' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 1 2 3 4 5 >one &&
-	git checkout -m side >actual 2>&1 &&
-	test_grep "recover your local changes" actual &&
-	git checkout -f main &&
-	git stash pop &&
-	fill 1 2 3 4 5 >expect &&
-	test_cmp expect one
-'
-
-test_expect_success 'checkout -m stashes on staged conflicting changes' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 1 2 3 4 5 >one &&
-	git add one &&
-	git checkout -m side >actual 2>&1 &&
-	test_grep ! "Created autostash" actual &&
-	test_grep "resulted in conflicts" actual &&
-	test_grep "git stash drop" actual &&
-	git stash drop &&
-	git reset --hard
-'
-
-test_expect_success 'checkout -m applies stash cleanly with non-overlapping changes in same file' '
-	git checkout -f main &&
-	git reset --hard &&
-	git clean -f &&
-
-	git checkout -b nonoverlap_base &&
-	fill a b c d >file &&
-	git add file &&
-	git commit -m "add file" &&
-
-	git checkout -b nonoverlap_child &&
-	fill a b c INSERTED d >file &&
-	git commit -a -m "insert line near end of file" &&
-
-	fill DIRTY a b c INSERTED d >file &&
-
-	git stash list >stash-before &&
-	git checkout -m nonoverlap_base 2>stderr &&
-	test_grep "Applied autostash" stderr &&
-	test_grep ! "resulted in conflicts" stderr &&
-
-	git stash list >stash-after &&
-	test_cmp stash-before stash-after &&
-
-	fill DIRTY a b c d >expect &&
-	test_cmp expect file &&
-
-	git checkout -f main &&
-	git branch -D nonoverlap_base &&
-	git branch -D nonoverlap_child
-'
-
-test_expect_success 'checkout -m -b skips stash with dirty tree' '
-	git checkout -f main &&
-	git clean -f &&
-
-	fill 0 x y z >same &&
-	git checkout -m -b newbranch >actual 2>&1 &&
-	test_grep ! "Created autostash" actual &&
-	fill 0 x y z >expect &&
-	test_cmp expect same &&
-	git checkout main &&
-	git branch -D newbranch
-'
-
 test_expect_success 'switch to another branch while carrying a deletion' '
 	git checkout -f main &&
 	git reset --hard &&
diff --git a/t/t7600-merge.sh b/t/t7600-merge.sh
index cbef8a534e..9838094b66 100755
--- a/t/t7600-merge.sh
+++ b/t/t7600-merge.sh
@@ -914,7 +914,7 @@ test_expect_success 'merge with conflicted --autostash changes' '
 	git diff >expect &&
 	test_when_finished "test_might_fail git stash drop" &&
 	git merge --autostash c3 2>err &&
-	test_grep "your local changes resulted in conflicts" err &&
+	test_grep "Applying autostash resulted in conflicts." err &&
 	git show HEAD:file >merge-result &&
 	test_cmp result.1-9 merge-result &&
 	git stash show -p >actual &&
diff --git a/xdiff-interface.c b/xdiff-interface.c
index 5ee2b96d0a..f043330f2a 100644
--- a/xdiff-interface.c
+++ b/xdiff-interface.c
@@ -325,18 +325,6 @@ int parse_conflict_style_name(const char *value)
 		return -1;
 }
 
-const char *conflict_style_name(int style)
-{
-	switch (style) {
-	case XDL_MERGE_DIFF3:
-		return "diff3";
-	case XDL_MERGE_ZEALOUS_DIFF3:
-		return "zdiff3";
-	default:
-		return "merge";
-	}
-}
-
 int git_xmerge_style = -1;
 
 int git_xmerge_config(const char *var, const char *value,
diff --git a/xdiff-interface.h b/xdiff-interface.h
index ce54e1c0e0..fbc4ceec40 100644
--- a/xdiff-interface.h
+++ b/xdiff-interface.h
@@ -55,7 +55,6 @@ void xdiff_set_find_func(xdemitconf_t *xecfg, const char *line, int cflags);
 void xdiff_clear_find_func(xdemitconf_t *xecfg);
 struct config_context;
 int parse_conflict_style_name(const char *value);
-const char *conflict_style_name(int style);
 int git_xmerge_config(const char *var, const char *value,
 		      const struct config_context *ctx, void *cb);
 extern int git_xmerge_style;
diff --git a/xdiff/xmerge.c b/xdiff/xmerge.c
index 659ad4ec97..29dad98c49 100644
--- a/xdiff/xmerge.c
+++ b/xdiff/xmerge.c
@@ -199,9 +199,9 @@ static int fill_conflict_hunk(xdfenv_t *xe1, const char *name1,
 			      int size, int i, int style,
 			      xdmerge_t *m, char *dest, int marker_size)
 {
-	int marker1_size = (name1 && *name1 ? strlen(name1) + 1 : 0);
-	int marker2_size = (name2 && *name2 ? strlen(name2) + 1 : 0);
-	int marker3_size = (name3 && *name3 ? strlen(name3) + 1 : 0);
+	int marker1_size = (name1 ? strlen(name1) + 1 : 0);
+	int marker2_size = (name2 ? strlen(name2) + 1 : 0);
+	int marker3_size = (name3 ? strlen(name3) + 1 : 0);
 	int needs_cr = is_cr_needed(xe1, xe2, m);
 
 	if (marker_size <= 0)