checkout: add --autostash option for branch switching

From: Harald Nordgren <[email protected]>

When switching branches, local modifications in the working tree can prevent the checkout from succeeding. While "git rebase" and "git merge" already support --autostash to handle this case automatically, "git checkout" and "git switch" require users to manually stash and unstash their changes.

Teach "git checkout" and "git switch" to accept --autostash and --no-autostash options that automatically create a temporary stash entry before the branch switch begins and apply it after the switch completes. If the stash application results in conflicts, the stash entry is saved to the stash list so the user can resolve them later.

Also add a checkout.autoStash configuration option that enables this behavior by default, which can be overridden with --no-autostash on the command line.

---
checkout: 'autostash' for branch switching

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2234%2FHaraldNordgren%2Fcheckout_autostash-v1
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2234/HaraldNordgren/checkout_autostash-v1
Pull-Request: https://github.com/git/git/pull/2234

 Documentation/config/checkout.adoc |  12 ++
 Documentation/git-checkout.adoc    |   9 ++
 Documentation/git-switch.adoc      |   9 ++
 builtin/checkout.c                 |  16 +++
 t/meson.build                      |   1 +
 t/t2061-switch-autostash.sh        | 181 +++++++++++++++++++++++++++++
 t/t9902-completion.sh              |   1 +
 7 files changed, 229 insertions(+)
 create mode 100755 t/t2061-switch-autostash.sh

index e35d212969..2e157c5398 100644
@@ -36,6 +36,18 @@ with a small number of cores, the default sequential checkout often performs
 better. The size and compression level of a repository might also influence how
 well the parallel version performs.
 
+`checkout.autoStash`::
+	When set to true, automatically create a temporary stash entry
+	before the operation begins, and apply it after the operation
+	ends.  This means that you can run `git checkout` or `git switch`
+	on a dirty worktree.  However, use with care: the final stash
+	application after a successful branch switch might result in
+	non-trivial conflicts.
+	This option can be overridden by the `--no-autostash` and
+	`--autostash` options of linkgit:git-checkout[1] and
+	linkgit:git-switch[1].
+	Defaults to false.
+
 `checkout.thresholdForParallelism`::
 	When running parallel checkout with a small number of files, the cost
 	of subprocess spawning and inter-process communication might outweigh

index 43ccf47cf6..96d9bf9203 100644
@@ -272,6 +272,15 @@ When switching branches with `--merge`, staged changes may be lost.
 	`merge.conflictStyle` configuration variable.  Possible values are
 	`merge` (default), `diff3`, and `zdiff3`.
 
+`--autostash`::
+`--no-autostash`::
+	When switching branches, automatically create a temporary stash
+	entry before the operation begins, and apply it after the
+	operation ends.  This means that you can switch branches on a
+	dirty worktree.  However, use with care: the final stash
+	application after a successful branch switch might result in
+	non-trivial conflicts.
+
 `-p`::
 `--patch`::
 	Interactively select hunks in the difference between the

index 87707e9265..b296df2a0b 100644
@@ -142,6 +142,15 @@ should result in deletion of the path).
 	`merge.conflictStyle` configuration variable.  Possible values are
 	`merge` (default), `diff3`, and `zdiff3`.
 
+`--autostash`::
+`--no-autostash`::
+	Automatically create a temporary stash entry before the
+	operation begins, and apply it after the operation ends.
+	This means that you can switch branches on a dirty worktree.
+	However, use with care: the final stash application after a
+	successful branch switch might result in non-trivial
+	conflicts.
+
 `-q`::
 `--quiet`::
 	Quiet, suppress feedback messages.

index 1d1667fa4c..453dbe3230 100644
@@ -30,6 +30,7 @@
 #include "repo-settings.h"
 #include "resolve-undo.h"
 #include "revision.h"
+#include "sequencer.h"
 #include "setup.h"
 #include "submodule.h"
 #include "symlinks.h"

@@ -68,6 +69,7 @@ struct checkout_opts {
 	int only_merge_on_switching_branches;
 	int can_switch_when_in_progress;
 	int orphan_from_empty_tree;
+	int autostash;
 	int empty_pathspec_ok;
 	int checkout_index;
 	int checkout_worktree;

@@ -1202,9 +1204,16 @@ static int switch_branches(const struct checkout_opts *opts,
 			do_merge = 0;
 	}
 
+	if (opts->autostash) {
+		if (repo_read_index(the_repository) < 0)
+			die(_("index file corrupt"));
+		create_autostash_ref(the_repository, "CHECKOUT_AUTOSTASH");
+	}
+
 	if (do_merge) {
 		ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
 		if (ret) {
+			apply_autostash_ref(the_repository, "CHECKOUT_AUTOSTASH");
 			branch_info_release(&old_branch_info);
 			return ret;
 		}

@@ -1215,6 +1224,8 @@ static int switch_branches(const struct checkout_opts *opts,
 
 	update_refs_for_switch(opts, &old_branch_info, new_branch_info);
 
+	apply_autostash_ref(the_repository, "CHECKOUT_AUTOSTASH");
+
 	ret = post_checkout_hook(old_branch_info.commit, new_branch_info->commit, 1);
 	branch_info_release(&old_branch_info);
 

@@ -1236,6 +1247,10 @@ static int git_checkout_config(const char *var, const char *value,
 		opts->dwim_new_local_branch = git_config_bool(var, value);
 		return 0;
 	}
+	if (!strcmp(var, "checkout.autostash")) {
+		opts->autostash = git_config_bool(var, value);
+		return 0;
+	}
 
 	if (starts_with(var, "submodule."))
 		return git_default_submodule_config(var, value, NULL);

@@ -1745,6 +1760,7 @@ static struct option *add_common_switch_branch_options(
 			   PARSE_OPT_NOCOMPLETE),
 		OPT_BOOL(0, "ignore-other-worktrees", &opts->ignore_other_worktrees,
 			 N_("do not check if another worktree is using this branch")),
+		OPT_AUTOSTASH(&opts->autostash),
 		OPT_END()
 	};
 	struct option *newopts = parse_options_concat(prevopts, options);

index f66a73f8a0..0645253d25 100644
@@ -275,6 +275,7 @@ integration_tests = [
   't2030-unresolve-info.sh',
   't2050-git-dir-relative.sh',
   't2060-switch.sh',
+  't2061-switch-autostash.sh',
   't2070-restore.sh',
   't2071-restore-patch.sh',
   't2072-restore-pathspec-file.sh',

index 2f9a597ec7..f33ca543a9 100755
@@ -2602,6 +2602,7 @@ test_expect_success 'double dash "git checkout"' '
 	--ignore-other-worktrees Z
 	--recurse-submodules Z
 	--auto-advance Z
+	--autostash Z
 	--progress Z
 	--guess Z
 	--no-guess Z

base-commit: 7f19e4e1b6a3ad259e2ed66033e01e03b8b74c5e

gitgitgadget

Unconditionally always stash when checkout happens? This feature as implemented does not have to be a separate feature. It can be done by end-users as a short-cut for "stash" followed by "checkout" via alias or custom command.

Perhaps doing it this way would make it more worth doing?

- At the beginning of branch switching, ask a new helper function that takes the branch we are switching to as an argument this question:

Do any paths that are different between the current branch and the branch we are switching to have local (i.e., either in the index or in the working tree) change [Yes/No]?

- When the answer is "yes", save the local changes to a new stash entry, and clear the local changes from the index and from the working tree. If not, do not bother with stash at all.

- Switch to other branch the usual way. This will never conflict.

- If we created a stash entry earlier, try to unstash it. It may conflict or it may not.

- If it does not conflict, then we are done. We drop that stash entry, and tell nothing about the stash to the user, as there is nothing they can do to the now-consumed stash.

- If it does conflict, tell the user that the original change is in the stash, and can be used to recover if you botch the conflict resolution, and also tell the user that they need to drop the stash entry once they are done with the change that caused this current conflict.

Essentially, the new "autostaash only when needed" would become a much better reimplementation of the "-m" option. From the point of view of a user who is used to "checkout -m", the basic workflow would be the same, only with vast improvement.

- It may not conflict and merge cleanly, in which case they do not have to do anything. This is the same as status quo.

- It may conflict and they find it too involved to resolve right at the moment, in which case they now have a choiceto say "git reset --hard", essentially declaring "I prioritize working on this new branch; I'll deal with the work in progress I started on the previous branch later", and then later they can "git stash pop" to deal with it.

Which is a vast improvement over the current "-m" that gives you only one chance to resolve it right.

- It may conflict and they may be able to resolve cleanly, in which case they have to remember that they need to do an extra thing (i.e., drop the stash we created just in case) but that may not be too bad a tradeoff.

If we can sell it as an improved implementation of "-m", we probably can lose some code that the current "-m" implementation uses to do its merge; we'd be instead using the "unstash" code paths.

And the new helper function to detect if switching from one commit to another commit would never conflict can later be used to enhance "git rebase" as well---we could call it N times to rebase a branch with N commits and if all steps are clear, we do not have to insist that there is no local changes like we do currently.

Hmm?

Good point! I have been running this today, and it gets a bit annoying when it's stashing and unstashing needlessly.

I updated the code!

Harald

Can we avoid the extra check and stash if the user passed "--autostash" and unpack_trees() fails because it would overwrite local changes in merge_working_tree()?

That would be nice but I think "git checkout --recurse-submodules -m <branch>" currently updates submodules whereas "git stash" does not know how to recurse submodules.

It would be nice to teach "git stash" to recurse submodules but I don't think it is completly straight forward as we'd need to store the object id of the submodule's stash commit in the parent stash.

Thanks

Phillip

Sorry, but I couldn't quite figure out what you are saying here.

My guess on one part of what it says is that an explicit "--autostash", we should stash without second guessing the user (i.e., avoid chedk and stash). But then the latter part of the sentence "and unpack_trees() fails ..." do not quite parse.

If the user gave "--autostash" and we check with unpack_trees() dry-run and find out that a normal branch switch will be interfered by the local changes, then we would stash, but that check made by a dry-run unpack_trees() is not an "extra" check, so, that does not work as a guess of what you are saying, either.

Hmph, I do not do submodules outside what we already have, and I certainly do not do "checkout --recurse-submodules" with or without "-m" with local changes in our submodule.

But does "git stash" even need to know about recursing into submodules for this? When checkout recurses into a submodule, that checkout that is working in the repository of the submodule can handle "-m" itself, which may stash the local changes made in the submodule, no?

No, let's not add more commands that take "--recurse-submodules", if we do not have to.

Thanks.

Why is the dry-run of unpack_trees() not an extra check? I was assuming that it was because we do the dry-run and then do it for real after possibly stashing any local changes. That's why I was wondering if we could avoid the dry-run by creating the stash if the non-dry-run unpack_trees() failed. Looking at the unpack_trees() implementation it can fail for a variety of reasons, only some (one?) of which can be addressed by stashing local changes but there does not seem to be a way for the caller to determine what caused it to fail.

Oh, because this all happens in a single command then yes, I think we can. When I wrote that I'd been thinking about a recent question about rebase not recursing submodules on discord and what it would take to make "git rebase --recurse-submodules --autostash" work. There we need to be able to retrive the stash in a different process to the one that created it so we need some way of tracking the stashed changes in each submodule.

It turns out I'd misremembered what "git checkout -m --recurse-submodules" does at the moment - after testing it, it seems to simply nuke an uncommitted submodule changes rather than merging them.

Thanks

Phillip

Ah, I didn't even think about that possibility.

Try to unpack anyway, and if unpack_trees() branch switching succeeds, we are done. Otherwise, we can trust that unpack_trees() did not do _anything_ to the index or the working tree files, so we can create the stash at that time.

Makes sense.

Makes sense.

Interesting idea, and thanks for your help with this! I gave it a shot with this simplification.

It passes the tests, which either means it works, or just that the test coverage is not good enough to detect new issues introduced by me here.

Harald

Hi Junio and Jeff!

Did you get a chance to look at the latest changes?

The scope of this grew a lot from my original idea of auto-stashing, so I'm not 100% convinced that changing '-m' is necessary here. My fear is to break something, especially since 'checkout -m' is a feature I never used before touching it here, so I don't have a good sense of how it should work.

Harald

FWIW, I very much like what I see in

   $ git checkout hn/git-checkout-m-with-stash && git diff @{1}

output. It is great that we do not have to do any dry-run, because the "real" run safely aborts, we can do the "stash && merge && unstash" dance as a fallback instead. All the credit goes to Phillip and you for the idea and the execution of this.

I do use "checkout -m" a few times a week, but I do not do anything complex with submodules or run the command with unrelated local modifications, so there may be changes in behaviour I haven't seen in corner cases that I do not exercise.

I wonder if my implementation is not really up to par. I have ran into a few "conflicts", were 'git stash pop' simply worked afterwards.

So not quite production ready.

Harald

Update on this: I realized that the issues I ran into was happening because of a sub-shell, so it's resolved by running like this:

export GIT_EXEC_PATH=/Users/Harald/git-repos/github.com/git/git && \
/Users/Harald/git-repos/github.com/git/git/git checkout -m -

So thus, it's not a real problem.

I think this is ready to be reviewed, does anyone have time to take a look?

Harald

Update on this: I realized that the issues I ran into was happening because of a sub-shell, so it's resolved by running like this:

export GIT_EXEC_PATH=/Users/Harald/git-repos/github.com/git/git && \
/Users/Harald/git-repos/github.com/git/git/git checkout -m -

So thus, it's not a real problem.

I think this is ready to be reviewed, does anyone have time to take a look?

Harald

In other words, you were not consistently trying the version of Git you just built?

Thanks for a good news.

you just built?

I was, but the difference here is the this logic calls another instance of Git halfway through, and I didn't realize until today that that other instance ended up being the system Git instead. So technically, I was only half-using it -- but accident.

Maybe I should consider installing it globally on my machine, via PATH or otherwise!

Harald

Update on this: I realized that the issues I ran into was happening because of a sub-shell, so it's resolved by running like this:

export GIT_EXEC_PATH=/Users/Harald/git-repos/github.com/git/git && \
/Users/Harald/git-repos/github.com/git/git/git checkout -m -

So thus, it's not a real problem.

I think this is ready to be reviewed, does anyone have time to take a look?

Harald

From: Harald Nordgren <[email protected]>

When switching branches, local modifications in the working tree can prevent the checkout from succeeding. While "git rebase" and "git merge" already support --autostash to handle this case automatically, "git checkout" and "git switch" require users to manually stash and unstash their changes.

Teach "git checkout" and "git switch" to accept --autostash and --no-autostash options that automatically create a temporary stash entry before the branch switch begins and apply it after the switch completes. If the stash application results in conflicts, the stash entry is saved to the stash list so the user can resolve them later.

Also add a checkout.autoStash configuration option that enables this behavior by default, which can be overridden with --no-autostash on the command line.

---
checkout: 'autostash' for branch switching

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2234%2FHaraldNordgren%2Fcheckout_autostash-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2234/HaraldNordgren/checkout_autostash-v2
Pull-Request: https://github.com/git/git/pull/2234

Range-diff vs v1:

1: 12194f6fbe ! 1: be2b697c54 checkout: add --autostash option for branch switching

     @@ Documentation/config/checkout.adoc: with a small number of cores, the default se
       well the parallel version performs.
       
      +`checkout.autoStash`::
     -+	When set to true, automatically create a temporary stash entry
     -+	before the operation begins, and apply it after the operation
     -+	ends.  This means that you can run `git checkout` or `git switch`
     -+	on a dirty worktree.  However, use with care: the final stash
     -+	application after a successful branch switch might result in
     -+	non-trivial conflicts.
     ++	When set to true, enable autostash for `git checkout` and
     ++	`git switch` branch switching operations.  When a branch
     ++	switch would fail because local changes (in the index or the
     ++	working tree) overlap with paths that differ between the
     ++	current and target branch, a temporary stash entry is
     ++	automatically created before the switch and applied after
     ++	it completes.  If the local changes do not overlap with the
     ++	branch difference, the switch proceeds normally without
     ++	stashing.
      +	This option can be overridden by the `--no-autostash` and
      +	`--autostash` options of linkgit:git-checkout[1] and
      +	linkgit:git-switch[1].
     @@ Documentation/git-checkout.adoc: When switching branches with `--merge`, staged
       
      +`--autostash`::
      +`--no-autostash`::
     -+	When switching branches, automatically create a temporary stash
     -+	entry before the operation begins, and apply it after the
     -+	operation ends.  This means that you can switch branches on a
     -+	dirty worktree.  However, use with care: the final stash
     -+	application after a successful branch switch might result in
     -+	non-trivial conflicts.
     ++	When switching branches, if any of the paths that differ
     ++	between the current branch and the target branch have local
     ++	changes (in the index or the working tree), automatically
     ++	create a temporary stash entry before the operation begins,
     ++	and apply it after the operation ends.  If the local changes
     ++	do not overlap with the branch difference, the switch proceeds
     ++	without stashing.  When a stash entry is created and the
     ++	subsequent application results in conflicts, the stash entry
     ++	is saved so that you can use `git stash pop` to recover and
     ++	`git stash drop` when done.  Use with `--force` to always
     ++	stash local changes regardless of conflicts.
      +
       `-p`::
       `--patch`::
     @@ Documentation/git-switch.adoc: should result in deletion of the path).
       
      +`--autostash`::
      +`--no-autostash`::
     -+	Automatically create a temporary stash entry before the
     -+	operation begins, and apply it after the operation ends.
     -+	This means that you can switch branches on a dirty worktree.
     -+	However, use with care: the final stash application after a
     -+	successful branch switch might result in non-trivial
     -+	conflicts.
     ++	When switching branches, if any of the paths that differ
     ++	between the current branch and the target branch have local
     ++	changes (in the index or the working tree), automatically
     ++	create a temporary stash entry before the operation begins,
     ++	and apply it after the operation ends.  If the local changes
     ++	do not overlap with the branch difference, the switch proceeds
     ++	without stashing.  When a stash entry is created and the
     ++	subsequent application results in conflicts, the stash entry
     ++	is saved so that you can use `git stash pop` to recover and
     ++	`git stash drop` when done.  Use with `--force` to always
     ++	stash local changes regardless of conflicts.
      +
       `-q`::
       `--quiet`::
     @@ builtin/checkout.c: struct checkout_opts {
       	int empty_pathspec_ok;
       	int checkout_index;
       	int checkout_worktree;
     +@@ builtin/checkout.c: static void orphaned_commit_warning(struct commit *old_commit, struct commit *ne
     + 	release_revisions(&revs);
     + }
     + 
     ++static int checkout_would_clobber_changes(struct branch_info *old_branch_info,
     ++					  struct branch_info *new_branch_info)
     ++{
     ++	struct tree_desc trees[2];
     ++	struct tree *old_tree, *new_tree;
     ++	struct unpack_trees_options topts;
     ++	struct index_state tmp_index = INDEX_STATE_INIT(the_repository);
     ++	const struct object_id *old_commit_oid;
     ++	int ret;
     ++
     ++	if (!new_branch_info->commit)
     ++		return 0;
     ++
     ++	old_commit_oid = old_branch_info->commit ?
     ++		&old_branch_info->commit->object.oid :
     ++		the_hash_algo->empty_tree;
     ++	old_tree = repo_parse_tree_indirect(the_repository, old_commit_oid);
     ++	if (!old_tree)
     ++		return 0;
     ++
     ++	new_tree = repo_get_commit_tree(the_repository,
     ++					new_branch_info->commit);
     ++	if (!new_tree)
     ++		return 0;
     ++	if (repo_parse_tree(the_repository, new_tree) < 0)
     ++		return 0;
     ++
     ++	memset(&topts, 0, sizeof(topts));
     ++	topts.head_idx = -1;
     ++	topts.src_index = the_repository->index;
     ++	topts.dst_index = &tmp_index;
     ++	topts.initial_checkout = is_index_unborn(the_repository->index);
     ++	topts.merge = 1;
     ++	topts.update = 1;
     ++	topts.dry_run = 1;
     ++	topts.quiet = 1;
     ++	topts.fn = twoway_merge;
     ++
     ++	init_tree_desc(&trees[0], &old_tree->object.oid,
     ++		       old_tree->buffer, old_tree->size);
     ++	init_tree_desc(&trees[1], &new_tree->object.oid,
     ++		       new_tree->buffer, new_tree->size);
     ++
     ++	ret = unpack_trees(2, trees, &topts);
     ++	discard_index(&tmp_index);
     ++
     ++	return ret != 0;
     ++}
     ++
     + static int switch_branches(const struct checkout_opts *opts,
     + 			   struct branch_info *new_branch_info)
     + {
      @@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
       			do_merge = 0;
       	}
     @@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
      +	if (opts->autostash) {
      +		if (repo_read_index(the_repository) < 0)
      +			die(_("index file corrupt"));
     -+		create_autostash_ref(the_repository, "CHECKOUT_AUTOSTASH");
     ++		if (opts->discard_changes ||
     ++		    checkout_would_clobber_changes(&old_branch_info,
     ++						   new_branch_info))
     ++			create_autostash_ref(the_repository,
     ++					     "CHECKOUT_AUTOSTASH");
      +	}
      +
       	if (do_merge) {
     @@ t/t2061-switch-autostash.sh (new)
      +	git checkout main
      +'
      +
     -+test_expect_success 'switch --autostash on dirty worktree' '
     ++test_expect_success 'switch --autostash skips stash when no conflict' '
      +	git branch branch1 other-branch &&
      +	echo dirty >file0 &&
      +	git switch --autostash branch1 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty >expected &&
      +	test_cmp expected file0 &&
      +	git switch main
      +'
      +
     -+test_expect_success 'checkout --autostash on dirty worktree' '
     ++test_expect_success 'checkout --autostash skips stash when no conflict' '
      +	git branch branch2 other-branch &&
      +	echo dirty >file0 &&
      +	git checkout --autostash branch2 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty >expected &&
      +	test_cmp expected file0 &&
      +	git checkout main
      +'
      +
     -+test_expect_success 'switch: checkout.autostash config' '
     ++test_expect_success 'switch: checkout.autostash config skips stash when no conflict' '
      +	git branch branch3 other-branch &&
      +	echo dirty >file0 &&
      +	test_config checkout.autostash true &&
      +	git switch branch3 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty >expected &&
      +	test_cmp expected file0 &&
      +	git switch main
      +'
      +
     -+test_expect_success 'checkout: checkout.autostash config' '
     ++test_expect_success 'checkout: checkout.autostash config skips stash when no conflict' '
      +	git branch branch4 other-branch &&
      +	echo dirty >file0 &&
      +	test_config checkout.autostash true &&
      +	git checkout branch4 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty >expected &&
      +	test_cmp expected file0 &&
      +	git checkout main
     @@ t/t2061-switch-autostash.sh (new)
      +	echo dirty >file0 &&
      +	test_config checkout.autostash false &&
      +	git switch --autostash branch6 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty >expected &&
      +	test_cmp expected file0 &&
      +	git switch main
      +'
      +
     -+test_expect_success 'autostash with dirty index' '
     ++test_expect_success 'autostash with non-conflicting dirty index' '
      +	git branch branch7 other-branch &&
      +	echo dirty-index >file0 &&
      +	git add file0 &&
      +	git switch --autostash branch7 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty-index >expected &&
      +	test_cmp expected file0 &&
      +	git checkout -- file0 &&
     @@ t/t2061-switch-autostash.sh (new)
      +	git switch main
      +'
      +
     -+test_expect_success '--autostash with --merge stashes and switches' '
     ++test_expect_success '--autostash with --merge skips stash when no conflict' '
      +	git branch branch10 other-branch &&
      +	echo dirty >file0 &&
      +	git switch --autostash --merge branch10 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty >expected &&
      +	test_cmp expected file0 &&
      +	git switch main
     @@ t/t2061-switch-autostash.sh (new)
      +	git switch main
      +'
      +
     -+test_expect_success '--autostash with new branch creation' '
     ++test_expect_success '--autostash with new branch creation skips stash' '
      +	echo dirty >file0 &&
      +	git switch --autostash -c branch13 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     ++	test_grep ! "Created autostash" actual &&
      +	echo dirty >expected &&
      +	test_cmp expected file0 &&
      +	git switch main &&
      +	git branch -D branch13
      +'
      +
     ++test_expect_success 'autostash with conflicting changes that apply cleanly' '
     ++	git branch branch14 other-branch &&
     ++	echo file1other >file1 &&
     ++	git switch --autostash branch14 >actual 2>&1 &&
     ++	test_grep "Created autostash" actual &&
     ++	test_grep "Applied autostash" actual &&
     ++	echo file1other >expected &&
     ++	test_cmp expected file1 &&
     ++	git switch main
     ++'
     ++
      +test_done
      
       ## t/t9902-completion.sh ##

 Documentation/config/checkout.adoc |  15 +++
 Documentation/git-checkout.adoc    |  14 +++
 Documentation/git-switch.adoc      |  14 +++
 builtin/checkout.c                 |  69 +++++++++++
 t/meson.build                      |   1 +
 t/t2061-switch-autostash.sh        | 184 +++++++++++++++++++++++++++++
 t/t9902-completion.sh              |   1 +
 7 files changed, 298 insertions(+)
 create mode 100755 t/t2061-switch-autostash.sh

index e35d212969..268b7b1b8b 100644
@@ -36,6 +36,21 @@ with a small number of cores, the default sequential checkout often performs
 better. The size and compression level of a repository might also influence how
 well the parallel version performs.
 
+`checkout.autoStash`::
+	When set to true, enable autostash for `git checkout` and
+	`git switch` branch switching operations.  When a branch
+	switch would fail because local changes (in the index or the
+	working tree) overlap with paths that differ between the
+	current and target branch, a temporary stash entry is
+	automatically created before the switch and applied after
+	it completes.  If the local changes do not overlap with the
+	branch difference, the switch proceeds normally without
+	stashing.
+	This option can be overridden by the `--no-autostash` and
+	`--autostash` options of linkgit:git-checkout[1] and
+	linkgit:git-switch[1].
+	Defaults to false.
+
 `checkout.thresholdForParallelism`::
 	When running parallel checkout with a small number of files, the cost
 	of subprocess spawning and inter-process communication might outweigh

index 43ccf47cf6..19da63c5be 100644
@@ -272,6 +272,20 @@ When switching branches with `--merge`, staged changes may be lost.
 	`merge.conflictStyle` configuration variable.  Possible values are
 	`merge` (default), `diff3`, and `zdiff3`.
 
+`--autostash`::
+`--no-autostash`::
+	When switching branches, if any of the paths that differ
+	between the current branch and the target branch have local
+	changes (in the index or the working tree), automatically
+	create a temporary stash entry before the operation begins,
+	and apply it after the operation ends.  If the local changes
+	do not overlap with the branch difference, the switch proceeds
+	without stashing.  When a stash entry is created and the
+	subsequent application results in conflicts, the stash entry
+	is saved so that you can use `git stash pop` to recover and
+	`git stash drop` when done.  Use with `--force` to always
+	stash local changes regardless of conflicts.
+
 `-p`::
 `--patch`::
 	Interactively select hunks in the difference between the

index 87707e9265..6028479fef 100644
@@ -142,6 +142,20 @@ should result in deletion of the path).
 	`merge.conflictStyle` configuration variable.  Possible values are
 	`merge` (default), `diff3`, and `zdiff3`.
 
+`--autostash`::
+`--no-autostash`::
+	When switching branches, if any of the paths that differ
+	between the current branch and the target branch have local
+	changes (in the index or the working tree), automatically
+	create a temporary stash entry before the operation begins,
+	and apply it after the operation ends.  If the local changes
+	do not overlap with the branch difference, the switch proceeds
+	without stashing.  When a stash entry is created and the
+	subsequent application results in conflicts, the stash entry
+	is saved so that you can use `git stash pop` to recover and
+	`git stash drop` when done.  Use with `--force` to always
+	stash local changes regardless of conflicts.
+
 `-q`::
 `--quiet`::
 	Quiet, suppress feedback messages.

index f66a73f8a0..0645253d25 100644
@@ -275,6 +275,7 @@ integration_tests = [
   't2030-unresolve-info.sh',
   't2050-git-dir-relative.sh',
   't2060-switch.sh',
+  't2061-switch-autostash.sh',
   't2070-restore.sh',
   't2071-restore-patch.sh',
   't2072-restore-pathspec-file.sh',

index 2f9a597ec7..f33ca543a9 100755
@@ -2602,6 +2602,7 @@ test_expect_success 'double dash "git checkout"' '
 	--ignore-other-worktrees Z
 	--recurse-submodules Z
 	--auto-advance Z
+	--autostash Z
 	--progress Z
 	--guess Z
 	--no-guess Z

base-commit: 7f19e4e1b6a3ad259e2ed66033e01e03b8b74c5e

gitgitgadget

With this, shouldn't "-m" become a synonym for "--autostash"? For users of "checkout -m", this is a strictly improved version of the same feature, it seems.

Also, "stash" is merely an implementation detail of how we make the merge safer, so from end-user's point of view, this feature is more like "switch to the other branch, while merging the local changes there", so calling it "--merge" or something may be much better than calling it "--autostash".

Other than that, I like the implementation in general.

That's an interesting idea and I gave it a shot! I do worry about breaking the existing '-m' flow because I don't understand its fundamentals.

But tests old seem to be passing (well, they did break and then I fixed the code to make them pass again), so that's promising. Although hard for me to say if the old test coverage protects against all possible regressions.

Thanks for all your support, Junio!

Harald

From: Harald Nordgren <[email protected]>

When switching branches, local modifications in the working tree can prevent the checkout from succeeding. While "git rebase" and "git merge" already support --autostash to handle this case automatically, "git checkout" and "git switch" require users to manually stash and unstash their changes.

Teach "git checkout" and "git switch" to accept --autostash and --no-autostash options that automatically create a temporary stash entry before the branch switch begins and apply it after the switch completes. If the stash application results in conflicts, the stash entry is saved to the stash list so the user can resolve them later.

Also add a checkout.autoStash configuration option that enables this behavior by default, which can be overridden with --no-autostash on the command line.

---
checkout: 'autostash' for branch switching

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2234%2FHaraldNordgren%2Fcheckout_autostash-v3
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2234/HaraldNordgren/checkout_autostash-v3
Pull-Request: https://github.com/git/git/pull/2234

Range-diff vs v2:

1: be2b697c54 ! 1: 05f1e53163 checkout: add --autostash option for branch switching

     @@ Commit message
      
          Signed-off-by: Harald Nordgren <[email protected]>
      
     - ## Documentation/config/checkout.adoc ##
     -@@ Documentation/config/checkout.adoc: with a small number of cores, the default sequential checkout often performs
     - better. The size and compression level of a repository might also influence how
     - well the parallel version performs.
     - 
     -+`checkout.autoStash`::
     -+	When set to true, enable autostash for `git checkout` and
     -+	`git switch` branch switching operations.  When a branch
     -+	switch would fail because local changes (in the index or the
     -+	working tree) overlap with paths that differ between the
     -+	current and target branch, a temporary stash entry is
     -+	automatically created before the switch and applied after
     -+	it completes.  If the local changes do not overlap with the
     -+	branch difference, the switch proceeds normally without
     -+	stashing.
     -+	This option can be overridden by the `--no-autostash` and
     -+	`--autostash` options of linkgit:git-checkout[1] and
     -+	linkgit:git-switch[1].
     -+	Defaults to false.
     -+
     - `checkout.thresholdForParallelism`::
     - 	When running parallel checkout with a small number of files, the cost
     - 	of subprocess spawning and inter-process communication might outweigh
     -
       ## Documentation/git-checkout.adoc ##
     -@@ Documentation/git-checkout.adoc: When switching branches with `--merge`, staged changes may be lost.
     - 	`merge.conflictStyle` configuration variable.  Possible values are
     - 	`merge` (default), `diff3`, and `zdiff3`.
     +@@ Documentation/git-checkout.adoc: 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.
     +-	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).
     ++	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 so you can use `git stash
     ++	pop` to recover and `git stash drop` when done.
     + +
     + 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
     +@@ Documentation/git-checkout.adoc: $ git checkout mytopic
     + error: You have local changes to 'frotz'; not switching branches.
     + ------------
     + 
     +-You can give the `-m` flag to the command, which would try a
     +-three-way merge:
     ++You can give the `-m` flag to the command, which would save the local
     ++changes in a stash entry and reset the working tree to allow switching:
     + 
     + ------------
     + $ git checkout -m mytopic
     +-Auto-merging frotz
     ++Created autostash: 7a9afa3
     ++Applied autostash.
     + ------------
     + 
     +-After this three-way merge, the local modifications are _not_
     ++After the switch, the local modifications are reapplied and 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 a merge conflict happens during switching branches with
     +-the `-m` option, you would see something like this:
     ++When 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 the stash application results in conflicts,
     ++they are not resolved and the stash is saved to the stash list:
     + 
     + ------------
     + $ git checkout -m mytopic
     +-Auto-merging frotz
     +-ERROR: Merge conflict in frotz
     +-fatal: merge program failed
     ++Created autostash: 7a9afa3
     ++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.
     + ------------
       
     -+`--autostash`::
     -+`--no-autostash`::
     -+	When switching branches, if any of the paths that differ
     -+	between the current branch and the target branch have local
     -+	changes (in the index or the working tree), automatically
     -+	create a temporary stash entry before the operation begins,
     -+	and apply it after the operation ends.  If the local changes
     -+	do not overlap with the branch difference, the switch proceeds
     -+	without stashing.  When a stash entry is created and the
     -+	subsequent application results in conflicts, the stash entry
     -+	is saved so that you can use `git stash pop` to recover and
     -+	`git stash drop` when done.  Use with `--force` to always
     -+	stash local changes regardless of conflicts.
     -+
     - `-p`::
     - `--patch`::
     - 	Interactively select hunks in the difference between the
     +-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
     +-------------
     ++At this point, `git stash pop` can be used to recover and resolve
     ++the conflicts, and `git stash drop` to discard the stash when done.
     + 
     + CONFIGURATION
     + -------------
      
       ## Documentation/git-switch.adoc ##
     -@@ Documentation/git-switch.adoc: should result in deletion of the path).
     - 	`merge.conflictStyle` configuration variable.  Possible values are
     - 	`merge` (default), `diff3`, and `zdiff3`.
     +@@ Documentation/git-switch.adoc: variable.
     + 	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).
     ++	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 so you can use `git stash pop` to
     ++	recover and `git stash drop` when done.
     + 
     + `--conflict=<style>`::
     + 	The same as `--merge` option above, but changes the way the
     +@@ Documentation/git-switch.adoc: $ git switch mytopic
     + error: You have local changes to 'frotz'; not switching branches.
     + ------------
     + 
     +-You can give the `-m` flag to the command, which would try a three-way
     +-merge:
     ++You can give the `-m` flag to the command, which would save the local
     ++changes in a stash entry and reset the working tree to allow switching:
     + 
     + ------------
     + $ git switch -m mytopic
     +-Auto-merging frotz
     ++Created autostash: 7a9afa3
     ++Applied autostash.
     + ------------
     + 
     +-After this three-way merge, the local modifications are _not_
     ++After the switch, the local modifications are reapplied and are _not_
     + registered in your index file, so `git diff` would show you what
     + changes you made since the tip of the new branch.
       
     -+`--autostash`::
     -+`--no-autostash`::
     -+	When switching branches, if any of the paths that differ
     -+	between the current branch and the target branch have local
     -+	changes (in the index or the working tree), automatically
     -+	create a temporary stash entry before the operation begins,
     -+	and apply it after the operation ends.  If the local changes
     -+	do not overlap with the branch difference, the switch proceeds
     -+	without stashing.  When a stash entry is created and the
     -+	subsequent application results in conflicts, the stash entry
     -+	is saved so that you can use `git stash pop` to recover and
     -+	`git stash drop` when done.  Use with `--force` to always
     -+	stash local changes regardless of conflicts.
     -+
     - `-q`::
     - `--quiet`::
     - 	Quiet, suppress feedback messages.
      
       ## builtin/checkout.c ##
     +@@
     + #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"
      @@
       #include "repo-settings.h"
       #include "resolve-undo.h"
     @@ builtin/checkout.c
       #include "setup.h"
       #include "submodule.h"
       #include "symlinks.h"
     -@@ builtin/checkout.c: struct checkout_opts {
     - 	int only_merge_on_switching_branches;
     - 	int can_switch_when_in_progress;
     - 	int orphan_from_empty_tree;
     -+	int autostash;
     - 	int empty_pathspec_ok;
     - 	int checkout_index;
     - 	int checkout_worktree;
     +@@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *opts,
     + 
     + 		ret = unpack_trees(2, trees, &topts);
     + 		clear_unpack_trees_porcelain(&topts);
     +-		if (ret == -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);
     +-
     +-			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;
     +-		}
     ++		if (ret == -1)
     ++			return 1;
     + 	}
     + 
     + 	if (!cache_tree_fully_valid(the_repository->index->cache_tree))
     +@@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *opts,
     + 	if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
     + 		die(_("unable to write new index file"));
     + 
     +-	if (!opts->discard_changes && !opts->quiet && new_branch_info->commit)
     +-		show_local_changes(&new_branch_info->commit->object, &opts->diff_options);
     +-
     + 	return 0;
     + }
     + 
      @@ builtin/checkout.c: static void orphaned_commit_warning(struct commit *old_commit, struct commit *ne
       	release_revisions(&revs);
       }
     @@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
       			do_merge = 0;
       	}
       
     -+	if (opts->autostash) {
     ++	if (opts->merge) {
      +		if (repo_read_index(the_repository) < 0)
      +			die(_("index file corrupt"));
     -+		if (opts->discard_changes ||
     -+		    checkout_would_clobber_changes(&old_branch_info,
     ++		if (checkout_would_clobber_changes(&old_branch_info,
      +						   new_branch_info))
      +			create_autostash_ref(the_repository,
      +					     "CHECKOUT_AUTOSTASH");
     @@ builtin/checkout.c: 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(the_repository, "CHECKOUT_AUTOSTASH");
     ++
     ++	discard_index(the_repository->index);
     ++	if (repo_read_index(the_repository) < 0)
     ++		die(_("index file corrupt"));
     ++
     ++	if (!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);
       
     -@@ builtin/checkout.c: static int git_checkout_config(const char *var, const char *value,
     - 		opts->dwim_new_local_branch = git_config_bool(var, value);
     - 		return 0;
     - 	}
     -+	if (!strcmp(var, "checkout.autostash")) {
     -+		opts->autostash = git_config_bool(var, value);
     -+		return 0;
     -+	}
     - 
     - 	if (starts_with(var, "submodule."))
     - 		return git_default_submodule_config(var, value, NULL);
     -@@ builtin/checkout.c: static struct option *add_common_switch_branch_options(
     - 			   PARSE_OPT_NOCOMPLETE),
     - 		OPT_BOOL(0, "ignore-other-worktrees", &opts->ignore_other_worktrees,
     - 			 N_("do not check if another worktree is using this branch")),
     -+		OPT_AUTOSTASH(&opts->autostash),
     - 		OPT_END()
     - 	};
     - 	struct option *newopts = parse_options_concat(prevopts, options);
      
     - ## t/meson.build ##
     -@@ t/meson.build: integration_tests = [
     -   't2030-unresolve-info.sh',
     -   't2050-git-dir-relative.sh',
     -   't2060-switch.sh',
     -+  't2061-switch-autostash.sh',
     -   't2070-restore.sh',
     -   't2071-restore-patch.sh',
     -   't2072-restore-pathspec-file.sh',
     + ## sequencer.c ##
     +@@ sequencer.c: static void create_autostash_internal(struct repository *r,
     + 					&oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
     + 		}
     + 
     +-		printf(_("Created autostash: %s\n"), buf.buf);
     ++		fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
     + 		if (reset_head(r, &ropts) < 0)
     + 			die(_("could not reset --hard"));
     + 		discard_index(r->index);
      
     - ## t/t2061-switch-autostash.sh (new) ##
     -@@
     -+#!/bin/sh
     -+
     -+test_description='checkout/switch --autostash tests'
     -+
     -+GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
     -+export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
     -+
     -+. ./test-lib.sh
     -+
     -+test_expect_success 'setup' '
     -+	echo file0content >file0 &&
     -+	echo file1content >file1 &&
     -+	git add . &&
     -+	test_tick &&
     -+	git commit -m "initial commit" &&
     -+	git branch other-branch &&
     -+	echo file1main >file1 &&
     -+	git add . &&
     -+	test_tick &&
     -+	git commit -m "modify file1 on main" &&
     -+	git checkout other-branch &&
     -+	echo file1other >file1 &&
     -+	git add . &&
     -+	test_tick &&
     -+	git commit -m "modify file1 on other-branch" &&
     -+	echo file2content >file2 &&
     -+	git add . &&
     -+	test_tick &&
     -+	git commit -m "add file2 on other-branch" &&
     -+	git checkout main
     + ## t/t7201-co.sh ##
     +@@ t/t7201-co.sh: test_expect_success 'format of merge conflict from checkout -m' '
     + 	test_cmp expect current &&
     + 
     + 	cat <<-EOF >expect &&
     +-	<<<<<<< simple
     ++	<<<<<<< Updated upstream
     + 	a
     + 	c
     + 	e
     + 	=======
     + 	b
     + 	d
     +-	>>>>>>> local
     ++	>>>>>>> Stashed changes
     + 	EOF
     + 	test_cmp expect two
     + '
     +@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>' '
     + 	git checkout --merge --conflict=diff3 simple &&
     + 
     + 	cat <<-EOF >expect &&
     +-	<<<<<<< simple
     ++	<<<<<<< Updated upstream
     + 	a
     + 	c
     + 	e
     +-	||||||| main
     ++	||||||| Stash base
     + 	a
     + 	b
     + 	c
     +@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>' '
     + 	=======
     + 	b
     + 	d
     +-	>>>>>>> local
     ++	>>>>>>> Stashed changes
     + 	EOF
     + 	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
     ++	<<<<<<< Updated upstream
     ++	c
     ++	||||||| Stash base
     ++	b
     ++	c
     ++	d
     ++	=======
     ++	b
     ++	X
     ++	d
     ++	>>>>>>> Stashed changes
     ++	e
     ++	EOF
     ++	test_cmp expect two
      +'
      +
     -+test_expect_success 'switch --autostash skips stash when no conflict' '
     -+	git branch branch1 other-branch &&
     -+	echo dirty >file0 &&
     -+	git switch --autostash branch1 >actual 2>&1 &&
     -+	test_grep ! "Created autostash" actual &&
     -+	echo dirty >expected &&
     -+	test_cmp expected file0 &&
     -+	git switch main
     ++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 &&
     ++	<<<<<<< Updated upstream
     ++	a
     ++	c
     ++	e
     ++	||||||| Stash base
     ++	a
     ++	b
     ++	c
     ++	d
     ++	e
     ++	=======
     ++	b
     ++	d
     ++	>>>>>>> Stashed changes
     ++	EOF
     ++	test_cmp expect two
      +'
      +
     -+test_expect_success 'checkout --autostash skips stash when no conflict' '
     -+	git branch branch2 other-branch &&
     -+	echo dirty >file0 &&
     -+	git checkout --autostash branch2 >actual 2>&1 &&
     -+	test_grep ! "Created autostash" actual &&
     -+	echo dirty >expected &&
     -+	test_cmp expected file0 &&
     -+	git checkout main
     -+'
     ++test_expect_success 'checkout -m skips stash when no conflict' '
     ++	git checkout -f main &&
     ++	git clean -f &&
      +
     -+test_expect_success 'switch: checkout.autostash config skips stash when no conflict' '
     -+	git branch branch3 other-branch &&
     -+	echo dirty >file0 &&
     -+	test_config checkout.autostash true &&
     -+	git switch branch3 >actual 2>&1 &&
     ++	fill 0 x y z >same &&
     ++	git checkout -m side >actual 2>&1 &&
      +	test_grep ! "Created autostash" actual &&
     -+	echo dirty >expected &&
     -+	test_cmp expected file0 &&
     -+	git switch main
     ++	fill 0 x y z >expect &&
     ++	test_cmp expect same
      +'
      +
     -+test_expect_success 'checkout: checkout.autostash config skips stash when no conflict' '
     -+	git branch branch4 other-branch &&
     -+	echo dirty >file0 &&
     -+	test_config checkout.autostash true &&
     -+	git checkout branch4 >actual 2>&1 &&
     ++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 &&
     -+	echo dirty >expected &&
     -+	test_cmp expected file0 &&
     -+	git checkout main
     ++	fill 0 x y z >expect &&
     ++	test_cmp expect same
      +'
      +
     -+test_expect_success '--no-autostash overrides checkout.autostash' '
     -+	git branch branch5 other-branch &&
     -+	echo dirty >file1 &&
     -+	test_config checkout.autostash true &&
     -+	test_must_fail git switch --no-autostash branch5 2>stderr &&
     -+	test_grep ! "Created autostash" stderr &&
     -+	git checkout -- file1
     -+'
     ++test_expect_success 'checkout -m stashes and applies on conflicting changes' '
     ++	git checkout -f main &&
     ++	git clean -f &&
      +
     -+test_expect_success '--autostash overrides checkout.autostash=false' '
     -+	git branch branch6 other-branch &&
     -+	echo dirty >file0 &&
     -+	test_config checkout.autostash false &&
     -+	git switch --autostash branch6 >actual 2>&1 &&
     -+	test_grep ! "Created autostash" actual &&
     -+	echo dirty >expected &&
     -+	test_cmp expected file0 &&
     -+	git switch main
     ++	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 'autostash with non-conflicting dirty index' '
     -+	git branch branch7 other-branch &&
     -+	echo dirty-index >file0 &&
     -+	git add file0 &&
     -+	git switch --autostash branch7 >actual 2>&1 &&
     -+	test_grep ! "Created autostash" actual &&
     -+	echo dirty-index >expected &&
     -+	test_cmp expected file0 &&
     -+	git checkout -- file0 &&
     -+	git switch main
     ++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 'autostash bypasses conflicting local changes' '
     -+	git branch branch8 other-branch &&
     -+	echo dirty >file1 &&
     -+	test_must_fail git switch branch8 2>stderr &&
     ++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 switch --autostash branch8 >actual 2>&1 &&
     ++	git checkout -m side >actual 2>&1 &&
      +	test_grep "Created autostash" actual &&
      +	test_grep "Applying autostash resulted in conflicts" actual &&
      +	test_grep "Your changes are safe in the stash" actual &&
      +	git stash drop &&
     -+	git reset --hard &&
     -+	git switch main
     ++	git reset --hard
      +'
      +
     -+test_expect_success 'autostash is a no-op with clean worktree' '
     -+	git branch branch9 other-branch &&
     -+	git switch --autostash branch9 >actual 2>&1 &&
     -+	test_grep ! "Created autostash" actual &&
     -+	git switch main
     -+'
     -+
     -+test_expect_success '--autostash with --merge skips stash when no conflict' '
     -+	git branch branch10 other-branch &&
     -+	echo dirty >file0 &&
     -+	git switch --autostash --merge branch10 >actual 2>&1 &&
     -+	test_grep ! "Created autostash" actual &&
     -+	echo dirty >expected &&
     -+	test_cmp expected file0 &&
     -+	git switch main
     -+'
     ++test_expect_success 'checkout -m produces usable stash on conflict' '
     ++	git checkout -f main &&
     ++	git clean -f &&
      +
     -+test_expect_success 'autostash with staged conflicting changes' '
     -+	git branch branch11 other-branch &&
     -+	echo staged-change >file1 &&
     -+	git add file1 &&
     -+	git switch --autostash branch11 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applying autostash resulted in conflicts" actual &&
     ++	fill 1 2 3 4 5 >one &&
     ++	git checkout -m side >actual 2>&1 &&
      +	test_grep "Your changes are safe in the stash" actual &&
     -+	git stash drop &&
     -+	git reset --hard &&
     -+	git switch main
     ++	git checkout -f main &&
     ++	git stash pop &&
     ++	fill 1 2 3 4 5 >expect &&
     ++	test_cmp expect one
      +'
      +
     -+test_expect_success '--autostash with --force preserves dirty changes' '
     -+	git branch branch12 other-branch &&
     -+	echo dirty-force >file1 &&
     -+	git switch --autostash --force branch12 >actual 2>&1 &&
     ++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 "Applying autostash resulted in conflicts" actual &&
      +	test_grep "Your changes are safe in the stash" actual &&
      +	git stash drop &&
     -+	git reset --hard &&
     -+	git switch main
     ++	git reset --hard
      +'
      +
     -+test_expect_success '--autostash with new branch creation skips stash' '
     -+	echo dirty >file0 &&
     -+	git switch --autostash -c branch13 >actual 2>&1 &&
     ++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 &&
     -+	echo dirty >expected &&
     -+	test_cmp expected file0 &&
     -+	git switch main &&
     -+	git branch -D branch13
     ++	fill 0 x y z >expect &&
     ++	test_cmp expect same &&
     ++	git checkout main &&
     ++	git branch -D newbranch
      +'
      +
     -+test_expect_success 'autostash with conflicting changes that apply cleanly' '
     -+	git branch branch14 other-branch &&
     -+	echo file1other >file1 &&
     -+	git switch --autostash branch14 >actual 2>&1 &&
     -+	test_grep "Created autostash" actual &&
     -+	test_grep "Applied autostash" actual &&
     -+	echo file1other >expected &&
     -+	test_cmp expected file1 &&
     -+	git switch main
     -+'
     + test_expect_success 'switch to another branch while carrying a deletion' '
     + 	git checkout -f main &&
     + 	git reset --hard &&
     +
     + ## xdiff-interface.c ##
     +@@ xdiff-interface.c: 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";
     ++	}
     ++}
      +
     -+test_done
     + int git_xmerge_style = -1;
     + 
     + int git_xmerge_config(const char *var, const char *value,
      
     - ## t/t9902-completion.sh ##
     -@@ t/t9902-completion.sh: test_expect_success 'double dash "git checkout"' '
     - 	--ignore-other-worktrees Z
     - 	--recurse-submodules Z
     - 	--auto-advance Z
     -+	--autostash Z
     - 	--progress Z
     - 	--guess Z
     - 	--no-guess Z
     + ## xdiff-interface.h ##
     +@@ xdiff-interface.h: 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;

 Documentation/git-checkout.adoc |  50 +++++-----
 Documentation/git-switch.adoc   |  26 ++---
 builtin/checkout.c              | 160 +++++++++++++++---------------
 sequencer.c                     |   2 +-
 t/t7201-co.sh                   | 170 +++++++++++++++++++++++++++++++-
 xdiff-interface.c               |  12 +++
 xdiff-interface.h               |   1 +
 7 files changed, 293 insertions(+), 128 deletions(-)

index 43ccf47cf6..1e8adf6ef3 100644
@@ -251,20 +251,17 @@ 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.
-	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).
+	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 so you can use `git stash
+	pop` to recover and `git stash drop` when done.
 +
 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

@@ -578,39 +575,36 @@ $ git checkout mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would try a
-three-way merge:
+You can give the `-m` flag to the command, which would save the local
+changes in a stash entry and reset the working tree to allow switching:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
+Created autostash: 7a9afa3
+Applied autostash.
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and 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 a merge conflict happens during switching branches with
-the `-m` option, you would see something like this:
+When 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 the stash application results in conflicts,
+they are not resolved and the stash is saved to the stash list:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
-ERROR: Merge conflict in frotz
-fatal: merge program failed
+Created autostash: 7a9afa3
+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.
 ------------
 
-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
-------------
+At this point, `git stash pop` can be used to recover and resolve
+the conflicts, and `git stash drop` to discard the stash when done.
 
 CONFIGURATION
 -------------

index 87707e9265..350e760fd2 100644
@@ -126,15 +126,14 @@ variable.
 	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).
+	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 so you can use `git stash pop` to
+	recover and `git stash drop` when done.
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the

@@ -217,15 +216,16 @@ $ git switch mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would try a three-way
-merge:
+You can give the `-m` flag to the command, which would save the local
+changes in a stash entry and reset the working tree to allow switching:
 
 ------------
 $ git switch -m mytopic
-Auto-merging frotz
+Created autostash: 7a9afa3
+Applied autostash.
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 

index aafd0bc959..72f0afe609 100644
@@ -4677,7 +4677,7 @@ static void create_autostash_internal(struct repository *r,
 					&oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
 		}
 
-		printf(_("Created autostash: %s\n"), buf.buf);
+		fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
 		if (reset_head(r, &ropts) < 0)
 			die(_("could not reset --hard"));
 		discard_index(r->index);

index f043330f2a..5ee2b96d0a 100644
@@ -325,6 +325,18 @@ 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,

index fbc4ceec40..ce54e1c0e0 100644
@@ -55,6 +55,7 @@ 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;

base-commit: 67006b9db8b772423ad0706029286096307d2567

gitgitgadget

Almost all of the above is now stale, as we no longer call this the "autostash" feature. It turned into a project to vastly improve the "checkout --merge" option, so the proposed log message needs to be revamped to match.

Using the autostash mechanism to simplify checkout.c is a great direction, I think, provided we can maintain the high-quality conflict information (branch labels) that users expect from '-m'.

For a new iteration that invalidates almost everything from the previous round, it is easier if range-diff were omitted from the reviewers' point of view (I am not a GGG user, so I do not know if there is such an option to do so). It is not a huge deal as we can simply ignore the large block of lines as irrelevant ;-)

	if (!silent)
		printf(_("Created autostash: %s\n"), buf.buf);

My feeling is that this feature will drift far away from what I initially needed. I have never used 'checkout -m' but stash->checkout-unstash is a pattern I use a lot.

I wonder with how complicated this might turn out, if it would be better to have this as a separate feature called autostash (mirroring the same feature from git pull rebase which I have enabled).

Harald

Perhaps. But things like "checkout --autostash", which can entirely be done by the end user via a wrapper script or an alias, is not interesting enough from my point of view.

From: Harald Nordgren <[email protected]>

When switching branches with "git checkout -m", local modifications can block the switch. Teach the -m flow to create a temporary stash before switching and reapply it after. On success, only "Applied autostash." is shown. If reapplying causes conflicts, the stash is kept and the user is told they can resolve and run "git stash drop", or run "git reset --hard" and later "git stash pop" to recover their changes.

---
checkout: 'autostash' for branch switching

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2234%2FHaraldNordgren%2Fcheckout_autostash-v4
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2234/HaraldNordgren/checkout_autostash-v4
Pull-Request: https://github.com/git/git/pull/2234

Range-diff vs v3:

1: 05f1e53163 ! 1: 5d49c0031a checkout: add --autostash option for branch switching
@@ Metadata
Author: Harald Nordgren <[email protected]>

## Commit message ##
- checkout: add --autostash option for branch switching
+ checkout: -m (--merge) uses autostash when switching branches

- When switching branches, local modifications in the working tree can
- prevent the checkout from succeeding. While "git rebase" and "git
- merge" already support --autostash to handle this case automatically,
- "git checkout" and "git switch" require users to manually stash and
- unstash their changes.
-
- Teach "git checkout" and "git switch" to accept --autostash and
- --no-autostash options that automatically create a temporary stash
- entry before the branch switch begins and apply it after the switch
- completes. If the stash application results in conflicts, the stash
- entry is saved to the stash list so the user can resolve them later.
-
- Also add a checkout.autoStash configuration option that enables this
- behavior by default, which can be overridden with --no-autostash on
- the command line.
+ When switching branches with "git checkout -m", local modifications
+ can block the switch. Teach the -m flow to create a temporary stash
+ before switching and reapply it after. On success, only "Applied
+ autostash." is shown. If reapplying causes conflicts, the stash is
+ kept and the user is told they can resolve and run "git stash drop",
+ or run "git reset --hard" and later "git stash pop" to recover their
+ changes.

@@ Documentation/git-checkout.adoc: $ git checkout mytopic
------------
$ git checkout -m mytopic
-Auto-merging frotz
-+Created autostash: 7a9afa3
+Applied autostash.
------------

@@ Documentation/git-checkout.adoc: $ git checkout mytopic

-When a merge conflict happens during switching branches with -the -m option, you would see something like this:
-+When 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 the stash application results in conflicts, -+they are not resolved and the stash is saved to the stash list:
++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 the stash application results in conflicts, they are not ++resolved and the stash is saved to the stash list:

------------
$ git checkout -m mytopic
-Auto-merging frotz
-ERROR: Merge conflict in frotz
-fatal: merge program failed
-+Created autostash: 7a9afa3
-+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.
- ------------
+-------------
++Your local changes are stashed, however, applying it to carry ++forward your local changes resulted in conflicts:

-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:
--
--------------
++ - 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.
+ ------------
-$ edit frotz
-$ git add frotz
-------------
-+At this point, git stash pop can be used to recover and resolve -+the conflicts, and git stash drop to discard the stash when done. ++
++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.

CONFIGURATION
-------------
@@ builtin/checkout.c: static void orphaned_commit_warning(struct commit *old_commi
static int switch_branches(const struct checkout_opts *opts,
struct branch_info *new_branch_info)
{
+@@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
+ struct object_id rev;
+ int flag, writeout_error = 0;
+ int do_merge = 1;
++ struct strbuf old_commit_shortname = STRBUF_INIT;
++ const char *stash_label_ancestor = NULL;
+
+ trace2_cmd_mode("branch");
+
@@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
do_merge = 0;
}

++ if (old_branch_info.name)
++ stash_label_ancestor = 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_ancestor = old_commit_shortname.buf;
++ }
++
+ if (opts->merge) {
+ if (repo_read_index(the_repository) < 0)
+ die(_("index file corrupt"));
+ if (checkout_would_clobber_changes(&old_branch_info,
+ new_branch_info))
-+ create_autostash_ref(the_repository,
-+ "CHECKOUT_AUTOSTASH");
++ create_autostash_ref_silent(the_repository,
++ "CHECKOUT_AUTOSTASH");
+ }
+
if (do_merge) {
ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error); if (ret) {
-+ apply_autostash_ref(the_repository, "CHECKOUT_AUTOSTASH");
++ apply_autostash_ref_with_labels(the_repository,
++ "CHECKOUT_AUTOSTASH",
++ new_branch_info->name,
++ "local",
++ stash_label_ancestor);
branch_info_release(&old_branch_info);
++ strbuf_release(&old_commit_shortname);
return ret;
}
+ }
@@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,

update_refs_for_switch(opts, &old_branch_info, new_branch_info);
@@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
+ git_config_push_parameter(cfg.buf);
+ strbuf_release(&cfg);
+ }
-+ apply_autostash_ref(the_repository, "CHECKOUT_AUTOSTASH");
++ apply_autostash_ref_with_labels(the_repository, "CHECKOUT_AUTOSTASH",
++ new_branch_info->name, "local",
++ stash_label_ancestor);
+
+ discard_index(the_repository->index);
+ if (repo_read_index(the_repository) < 0)
@@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
+
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;
+ }
+
+ ## builtin/stash.c ##
+@@ builtin/stash.c: static void unstage_changes_unless_new(struct object_id *orig_tree)
+ die(_("could not write index"));
+ }
+
+-static int do_apply_stash(const char *prefix, struct stash_info *info,
+- int index, int quiet)
++static int do_apply_stash_with_labels(const char *prefix,
++ struct stash_info *info,
++ int index, int quiet,
++ const char *label1, const char *label2,
++ const char *label_ancestor)
+ {
+ int clean, ret;
+ int has_index = index;
+@@ builtin/stash.c: static int do_apply_stash(const char *prefix, struct stash_info *info,

+ init_ui_merge_options(&o, the_repository);
+
+- o.branch1 = "Updated upstream";
+- o.branch2 = "Stashed changes";
+- o.ancestor = "Stash base";
++ o.branch1 = label1 ? label1 : "Updated upstream";
++ o.branch2 = label2 ? label2 : "Stashed changes";
++ o.ancestor = label_ancestor ? label_ancestor : "Stash base";
+
+ if (oideq(&info->b_tree, &c_tree))
+ o.branch1 = "Version stash was based on";
+@@ builtin/stash.c: 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 *label1 = NULL, *label2 = NULL, *label_ancestor = 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, "ours-label", &label1, N_("label"),
++ N_("label for the upstream side in conflict markers")),
++ OPT_STRING(0, "theirs-label", &label2, N_("label"),
++ N_("label for the stashed side in conflict markers")),
++ OPT_STRING(0, "base-label", &label_ancestor, N_("label"),
++ N_("label for the base in diff3 conflict markers")),
+ OPT_END()
+ };
+
+@@ builtin/stash.c: 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(prefix, &info, index, quiet);
++ ret = do_apply_stash_with_labels(prefix, &info, index, quiet,
++ label1, label2, label_ancestor);
+ cleanup:
+ free_stash_info(&info);
+ return ret;

## sequencer.c ##
+@@ sequencer.c: 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)
++ const char *refname,
++ int silent)
+ {
+ struct strbuf buf = STRBUF_INIT;
+ struct lock_file lock_file = LOCK_INIT;
@@ sequencer.c: static void create_autostash_internal(struct repository *r,
&oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
}

- printf(_("Created autostash: %s\n"), buf.buf);
-+ fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
++ if (!silent)
++ fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
if (reset_head(r, &ropts) < 0)
die(_("could not reset --hard"));
discard_index(r->index);
+@@ sequencer.c: static void create_autostash_internal(struct repository *r,
+
+ void create_autostash(struct repository *r, const char *path)
+ {
+- create_autostash_internal(r, path, NULL);
++ create_autostash_internal(r, path, NULL, 0);
+ }
+
+ void create_autostash_ref(struct repository *r, const char *refname)
+ {
+- create_autostash_internal(r, NULL, refname);
++ create_autostash_internal(r, NULL, refname, 0);
+ }
+
+-static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply) ++void create_autostash_ref_silent(struct repository *r, const char *refname) ++{
++ create_autostash_internal(r, NULL, refname, 1);
++}
++
++static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
++ const char *label1, const char *label2,
++ const char *label_ancestor)
+ {
+ struct child_process child = CHILD_PROCESS_INIT;
+ int ret = 0;
+@@ sequencer.c: 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 (label1)
++ strvec_pushf(&child.args, "--ours-label=%s", label1);
++ if (label2)
++ strvec_pushf(&child.args, "--theirs-label=%s", label2);
++ if (label_ancestor)
++ strvec_pushf(&child.args, "--base-label=%s", label_ancestor);
+ strvec_push(&child.args, stash_oid);
+ ret = run_command(&child);
+ }
+@@ sequencer.c: 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,
+- _("%s\n"
++ _("Autostash exists; creating a new stash entry.\n"
+ "Your changes are safe in the stash.\n"
+ "You can run \"git stash pop\" or"
+- " \"git stash drop\" at any time.\n"),
+- attempt_apply ?
+- _("Applying autostash resulted in conflicts.") :
+- _("Autostash exists; creating a new stash entry."));
++ " \"git stash drop\" at any time.\n"));
+ }
+
+ return ret;
+@@ sequencer.c: 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);
++ ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply,
++ NULL, NULL, NULL);
+
+ unlink(path);
+ strbuf_release(&stash_oid);
+@@ sequencer.c: int apply_autostash(const char *path)
+
+ int apply_autostash_oid(const char *stash_oid)
+ {
+- return apply_save_autostash_oid(stash_oid, 1);
++ return apply_save_autostash_oid(stash_oid, 1, NULL, NULL, NULL);
+ }
+
+ static int apply_save_autostash_ref(struct repository *r, const char *refname,
+- int attempt_apply)
++ int attempt_apply,
++ const char *label1, const char *label2,
++ const char *label_ancestor)
+ {
+ struct object_id stash_oid;
+ char stash_oid_hex[GIT_MAX_HEXSZ + 1];
+@@ sequencer.c: 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);
++ ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply,
++ label1, label2, label_ancestor);
+
+ refs_delete_ref(get_main_ref_store(r), "", refname,
+ &stash_oid, REF_NO_DEREF);
+@@ sequencer.c: 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);
++ return apply_save_autostash_ref(r, refname, 0, NULL, NULL, NULL);
+ }
+
+ int apply_autostash_ref(struct repository *r, const char *refname)
+ {
+- return apply_save_autostash_ref(r, refname, 1);
++ 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 *label1, const char *label2,
++ const char *label_ancestor)
++{
++ return apply_save_autostash_ref(r, refname, 1,
++ label1, label2, label_ancestor);
+ }
+
+ static int checkout_onto(struct repository *r, struct replay_opts *opts,

- ## t/t7201-co.sh ##
-@@ t/t7201-co.sh: test_expect_success 'format of merge conflict from checkout -m' '
- test_cmp expect current &&
-
- cat <<-EOF >expect &&
-- <<<<<<< simple
-+ <<<<<<< Updated upstream
- a
- c
- e
- =======
- b
- d
-- >>>>>>> local
-+ >>>>>>> Stashed changes
+ ## sequencer.h ##
+@@ sequencer.h: 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 *label1, const char *label2,
++ const char *label_ancestor);
+
+ #define SUMMARY_INITIAL_COMMIT (1 << 0)
+ #define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)
+
+ ## t/t3420-rebase-autostash.sh ##
+@@ t/t3420-rebase-autostash.sh: create_expected_failure_apply () {
+ First, rewinding head to replay your work on top of it...
+ Applying: second commit
+ Applying: third commit
+- 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.
++ 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.
EOF
- test_cmp expect two
- '
-@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>' '
- git checkout --merge --conflict=diff3 simple &&
-
- cat <<-EOF >expect &&
-- <<<<<<< simple
-+ <<<<<<< Updated upstream
- a
- c
- e
-- ||||||| main
-+ ||||||| Stash base
- a
- b
- c
-@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>' '
- =======
- b
- d
-- >>>>>>> local
-+ >>>>>>> Stashed changes
+ }
+
+ create_expected_failure_merge () {
+ cat >expected <<-EOF
+ $(grep "^Created autostash: [0-9a-f][0-9a-f]*\$" actual)
+- 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.
++ 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.
+ Successfully rebased and updated refs/heads/rebased-feature-branch.
EOF
+ }
+
+ ## t/t7201-co.sh ##
+@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>' '
test_cmp expect two
'

@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+
+ cat <<-EOF >expect &&
+ a
-+ <<<<<<< Updated upstream
++ <<<<<<< simple
+ c
-+ ||||||| Stash base
++ ||||||| main
+ b
+ c
+ d
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+ b
+ X
+ d
-+ >>>>>>> Stashed changes
++ >>>>>>> local
+ e
+ EOF
+ test_cmp expect two
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+ git checkout -m simple &&
+
+ cat <<-EOF >expect &&
-+ <<<<<<< Updated upstream
++ <<<<<<< simple
+ a
+ c
+ e
-+ ||||||| Stash base
++ ||||||| main
+ a
+ b
+ c
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+ =======
+ b
+ d
-+ >>>>>>> Stashed changes
++ >>>>>>> local
+ EOF
+ test_cmp expect two
+'
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+
+ fill 1 2 3 4 5 6 7 >one &&
+ git checkout -m side >actual 2>&1 &&
-+ test_grep "Created autostash" actual &&
++ test_grep ! "Created autostash" actual &&
+ test_grep "Applied autostash" actual &&
+ fill 1 2 3 4 5 6 7 >expect &&
+ test_cmp expect one
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+ 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 ! "Created autostash" actual &&
+ test_grep "Applied autostash" actual &&
+ fill 0 x y z >expect &&
+ test_cmp expect same &&
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+ 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 "Applying autostash resulted in conflicts" actual &&
-+ test_grep "Your changes are safe in the stash" actual &&
++ test_grep ! "Created autostash" actual &&
++ test_grep "resulted in conflicts" actual &&
++ test_grep "git stash drop" actual &&
+ git stash drop &&
+ git reset --hard
+'
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+
+ fill 1 2 3 4 5 >one &&
+ git checkout -m side >actual 2>&1 &&
-+ test_grep "Your changes are safe in the stash" actual &&
++ test_grep "recover your local changes" actual &&
+ git checkout -f main &&
+ git stash pop &&
+ fill 1 2 3 4 5 >expect &&
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
+ fill 1 2 3 4 5 >one &&
+ git add one &&
+ git checkout -m side >actual 2>&1 &&
-+ test_grep "Created autostash" actual &&
-+ test_grep "Applying autostash resulted in conflicts" actual &&
-+ test_grep "Your changes are safe in the stash" actual &&
++ test_grep ! "Created autostash" actual &&
++ test_grep "resulted in conflicts" actual &&
++ test_grep "git stash drop" actual &&
+ git stash drop &&
+ git reset --hard
+'
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
git checkout -f main &&
git reset --hard &&

+ ## t/t7600-merge.sh ##
+@@ t/t7600-merge.sh: test_expect_success 'merge --squash --autostash conflict does not attempt to app
+ >unrelated &&
+ git add unrelated &&
+ test_must_fail git merge --squash c7 --autostash >out 2>err &&
+- ! grep "Applying autostash resulted in conflicts." err &&
++ ! grep "resulted in conflicts" err &&
+ grep "When finished, apply stashed changes with \git stash pop\" out
+ '
+
+@@ t/t7600-merge.sh: 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 "Applying autostash resulted in conflicts." err &&
++ test_grep "resulted in conflicts" err &&
+ git show HEAD:file >merge-result &&
+ test_cmp result.1-9 merge-result &&
+ git stash show -p >actual &&
+
## xdiff-interface.c ##
@@ xdiff-interface.c: int parse_conflict_style_name(const char *value)
return -1;

 Documentation/git-checkout.adoc |  56 +++++-----
 Documentation/git-switch.adoc   |  26 ++---
 builtin/checkout.c              | 179 +++++++++++++++++---------------
 builtin/stash.c                 |  30 ++++--
 sequencer.c                     |  67 +++++++++---
 sequencer.h                     |   4 +
 t/t3420-rebase-autostash.sh     |  24 +++--
 t/t7201-co.sh                   | 160 ++++++++++++++++++++++++++++
 t/t7600-merge.sh                |   4 +-
 xdiff-interface.c               |  12 +++
 xdiff-interface.h               |   1 +
 11 files changed, 412 insertions(+), 151 deletions(-)

index 43ccf47cf6..9d5f5c51ae 100644
@@ -251,20 +251,17 @@ 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.
-	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).
+	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 so you can use `git stash
+	pop` to recover and `git stash drop` when done.
 +
 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

@@ -578,39 +575,44 @@ $ git checkout mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would try a
-three-way merge:
+You can give the `-m` flag to the command, which would save the local
+changes in a stash entry and reset the working tree to allow switching:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
+Applied autostash.
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and 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 a merge conflict happens during switching branches with
-the `-m` option, you would see something like this:
+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 the stash application results in conflicts, they are not
+resolved and the stash is saved to the stash list:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
-ERROR: Merge conflict in frotz
-fatal: merge program failed
-------------
+Your local changes are stashed, however, applying it to carry
+forward your local changes resulted in conflicts:
 
-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:
+ - 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.
 ------------
-$ edit frotz
-$ git add frotz
-------------
+
+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`.
 
 CONFIGURATION
 -------------

index 87707e9265..350e760fd2 100644
@@ -126,15 +126,14 @@ variable.
 	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).
+	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 so you can use `git stash pop` to
+	recover and `git stash drop` when done.
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the

@@ -217,15 +216,16 @@ $ git switch mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would try a three-way
-merge:
+You can give the `-m` flag to the command, which would save the local
+changes in a stash entry and reset the working tree to allow switching:
 
 ------------
 $ git switch -m mytopic
-Auto-merging frotz
+Created autostash: 7a9afa3
+Applied autostash.
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 

index e79d612e57..1016d88e52 100644
@@ -590,8 +590,11 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
 		die(_("could not write index"));
 }
 
-static int do_apply_stash(const char *prefix, struct stash_info *info,
-			  int index, int quiet)
+static int do_apply_stash_with_labels(const char *prefix,
+				      struct stash_info *info,
+				      int index, int quiet,
+				      const char *label1, const char *label2,
+				      const char *label_ancestor)
 {
 	int clean, ret;
 	int has_index = index;

@@ -643,9 +646,9 @@ static int do_apply_stash(const char *prefix, struct stash_info *info,
 
 	init_ui_merge_options(&o, the_repository);
 
-	o.branch1 = "Updated upstream";
-	o.branch2 = "Stashed changes";
-	o.ancestor = "Stash base";
+	o.branch1 = label1 ? label1 : "Updated upstream";
+	o.branch2 = label2 ? label2 : "Stashed changes";
+	o.ancestor = label_ancestor ? label_ancestor : "Stash base";
 
 	if (oideq(&info->b_tree, &c_tree))
 		o.branch1 = "Version stash was based on";

@@ -717,17 +720,31 @@ 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 *label1 = NULL, *label2 = NULL, *label_ancestor = 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, "ours-label", &label1, N_("label"),
+			   N_("label for the upstream side in conflict markers")),
+		OPT_STRING(0, "theirs-label", &label2, N_("label"),
+			   N_("label for the stashed side in conflict markers")),
+		OPT_STRING(0, "base-label", &label_ancestor, N_("label"),
+			   N_("label for the base in diff3 conflict markers")),
 		OPT_END()
 	};
 

@@ -737,7 +754,8 @@ 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(prefix, &info, index, quiet);
+	ret = do_apply_stash_with_labels(prefix, &info, index, quiet,
+					 label1, label2, label_ancestor);
 cleanup:
 	free_stash_info(&info);
 	return ret;

index 719684c8a9..68b94d86e3 100644
@@ -227,11 +227,15 @@ 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 *label1, const char *label2,
+				    const char *label_ancestor);
 
 #define SUMMARY_INITIAL_COMMIT   (1 << 0)
 #define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)

index ad3ba6a984..e4e2cb19ce 100755
@@ -61,18 +61,30 @@ create_expected_failure_apply () {
 	First, rewinding head to replay your work on top of it...
 	Applying: second commit
 	Applying: third commit
-	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.
+	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.
 	EOF
 }
 
 create_expected_failure_merge () {
 	cat >expected <<-EOF
 	$(grep "^Created autostash: [0-9a-f][0-9a-f]*\$" actual)
-	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.
+	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.
 	Successfully rebased and updated refs/heads/rebased-feature-branch.
 	EOF
 }

index 9838094b66..b061cc1b4a 100755
@@ -342,7 +342,7 @@ test_expect_success 'merge --squash --autostash conflict does not attempt to app
 	>unrelated &&
 	git add unrelated &&
 	test_must_fail git merge --squash c7 --autostash >out 2>err &&
-	! grep "Applying autostash resulted in conflicts." err &&
+	! grep "resulted in conflicts" err &&
 	grep "When finished, apply stashed changes with \`git stash pop\`" out
 '
 

@@ -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 "Applying autostash resulted in conflicts." err &&
+	test_grep "resulted in conflicts" err &&
 	git show HEAD:file >merge-result &&
 	test_cmp result.1-9 merge-result &&
 	git stash show -p >actual &&

index f043330f2a..5ee2b96d0a 100644
@@ -325,6 +325,18 @@ 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,

index fbc4ceec40..ce54e1c0e0 100644
@@ -55,6 +55,7 @@ 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;

base-commit: dc6ecd5354dca88d51b6d6562777fc8fc10d77e1

gitgitgadget

I very much appreciate this, but somehow this "cc:" seems to have been ignored.

    $ git checkout master
    $ echo >>transport.c
    $ git checkout jk/transport-color-leakfix
    error: Your local changes to the following files would be overwritten...
        transport.c
    Please commit your changes or stash ...
    Aborting
    $ git checkout -m jk/transport-color-leakfix
    M	transport.c
    Switched to branch 'jk/transport-color-leakfix'

Harald Nordgren (4):
stash: add --ours-label, --theirs-label, --base-label for apply
sequencer: allow create_autostash to run silently
sequencer: teach autostash apply to take optional conflict marker
labels
checkout: -m (--merge) uses autostash when switching branches

 Documentation/git-checkout.adoc |  58 +++++-----
 Documentation/git-stash.adoc    |  11 +-
 Documentation/git-switch.adoc   |  27 ++---
 builtin/checkout.c              | 180 ++++++++++++++++++--------------
 builtin/stash.c                 |  32 ++++--
 sequencer.c                     |  67 +++++++++---
 sequencer.h                     |   4 +
 t/t3420-rebase-autostash.sh     |  24 +++--
 t/t3903-stash.sh                |  18 ++++
 t/t7201-co.sh                   | 160 ++++++++++++++++++++++++++++
 t/t7600-merge.sh                |   2 +-
 xdiff-interface.c               |  12 +++
 xdiff-interface.h               |   1 +
 13 files changed, 447 insertions(+), 149 deletions(-)

base-commit: dc6ecd5354dca88d51b6d6562777fc8fc10d77e1
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2234%2FHaraldNordgren%2Fcheckout_autostash-v5
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2234/HaraldNordgren/checkout_autostash-v5
Pull-Request: https://github.com/git/git/pull/2234

Range-diff vs v4:

 -:  ---------- > 1:  00d8920498 stash: add --ours-label, --theirs-label, --base-label for apply
 -:  ---------- > 2:  5d176f1700 sequencer: allow create_autostash to run silently
 -:  ---------- > 3:  3d6829438a sequencer: teach autostash apply to take optional conflict marker labels
 1:  5d49c0031a ! 4:  7f3735d40e checkout: -m (--merge) uses autostash when switching branches

@@ Documentation/git-checkout.adoc: working tree, by copying them from elsewhere, e
+ 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 so you can use `git stash
-+ pop to recover and git stash drop` when done.
++ 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.
+
When checking out paths from the index, this option lets you recreate the conflicted merge in the specified paths. This option cannot be
@@ Documentation/git-checkout.adoc: $ git checkout mytopic

-You can give the -m flag to the command, which would try a -three-way merge:
-+You can give the -m flag to the command, which would save the local -+changes in a stash entry and reset the working tree to allow switching:
++You can give the -m flag to the command, which would carry your local ++changes to the new branch:

------------
$ git checkout -m mytopic
-Auto-merging frotz
-+Applied autostash.
++Switched to branch 'mytopic'
------------

-After this three-way merge, the local modifications are _not_
@@ Documentation/git-switch.adoc: variable.
+ 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 so you can use git stash pop to
-+ recover and git stash drop when done.
++ 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.

--conflict=<style>::
The same as --merge option above, but changes the way the
@@ Documentation/git-switch.adoc: $ git switch mytopic

-You can give the -m flag to the command, which would try a three-way -merge:
-+You can give the -m flag to the command, which would save the local -+changes in a stash entry and reset the working tree to allow switching:
++You can give the -m flag to the command, which would carry your local ++changes to the new branch:

------------
$ git switch -m mytopic
-Auto-merging frotz
-+Created autostash: 7a9afa3
-+Applied autostash.
++Switched to branch 'mytopic'
------------

-After this three-way merge, the local modifications are _not_
@@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *op
}

if (!cache_tree_fully_valid(the_repository->index->cache_tree))
-@@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *opts,
- if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
- die(_("unable to write new index file"));
-
-- if (!opts->discard_changes && !opts->quiet && new_branch_info->commit)
-- show_local_changes(&new_branch_info->commit->object, &opts->diff_options);
--
- return 0;
- }
-
@@ builtin/checkout.c: static void orphaned_commit_warning(struct commit *old_commit, struct commit *ne
release_revisions(&revs);
}
@@ builtin/checkout.c: 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_ancestor = NULL;

@@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
+ if (repo_read_index(the_repository) < 0)
+ die(_("index file corrupt"));
+ if (checkout_would_clobber_changes(&old_branch_info,
-+ new_branch_info))
++ new_branch_info)) {
+ create_autostash_ref_silent(the_repository,
+ "CHECKOUT_AUTOSTASH");
++ created_autostash = 1;
++ }
+ }
+
if (do_merge) {
@@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
+ if (repo_read_index(the_repository) < 0)
+ die(_("index file corrupt"));
+
-+ if (!opts->discard_changes && !opts->quiet && new_branch_info->commit)
++ if (created_autostash && !opts->discard_changes && !opts->quiet &&
++ new_branch_info->commit)
+ show_local_changes(&new_branch_info->commit->object,
+ &opts->diff_options);
+
@@ builtin/stash.c: static int apply_stash(int argc, const char **argv, const char
return ret;

## sequencer.c ##
-@@ sequencer.c: 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)
-+ const char *refname,
-+ int silent)
- {
- struct strbuf buf = STRBUF_INIT;
- struct lock_file lock_file = LOCK_INIT;
-@@ sequencer.c: static void create_autostash_internal(struct repository *r,
- &oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
- }
-
-- printf(_("Created autostash: %s\n"), buf.buf);
-+ if (!silent)
-+ fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
- if (reset_head(r, &ropts) < 0)
- die(_("could not reset --hard"));
- discard_index(r->index);
-@@ sequencer.c: static void create_autostash_internal(struct repository *r,
-
- void create_autostash(struct repository *r, const char *path)
- {
-- create_autostash_internal(r, path, NULL);
-+ create_autostash_internal(r, path, NULL, 0);
- }
-
- void create_autostash_ref(struct repository *r, const char *refname)
- {
-- create_autostash_internal(r, NULL, refname);
-+ create_autostash_internal(r, NULL, refname, 0);
- }
-
--static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply) -+void create_autostash_ref_silent(struct repository *r, const char *refname) -+{
-+ create_autostash_internal(r, NULL, refname, 1);
-+}
-+
-+static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
-+ const char *label1, const char *label2,
-+ const char *label_ancestor)
- {
- struct child_process child = CHILD_PROCESS_INIT;
- int ret = 0;
-@@ sequencer.c: 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 (label1)
-+ strvec_pushf(&child.args, "--ours-label=%s", label1);
-+ if (label2)
-+ strvec_pushf(&child.args, "--theirs-label=%s", label2);
-+ if (label_ancestor)
-+ strvec_pushf(&child.args, "--base-label=%s", label_ancestor);
- strvec_push(&child.args, stash_oid);
- ret = run_command(&child);
- }
-@@ sequencer.c: static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply) +@@ sequencer.c: 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);
@@ sequencer.c: static int apply_save_autostash_oid(const char *stash_oid, int atte
}

return ret;
-@@ sequencer.c: 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);
-+ ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply,
-+ NULL, NULL, NULL);
-
- unlink(path);
- strbuf_release(&stash_oid);
-@@ sequencer.c: int apply_autostash(const char *path)
-
- int apply_autostash_oid(const char *stash_oid)
- {
-- return apply_save_autostash_oid(stash_oid, 1);
-+ return apply_save_autostash_oid(stash_oid, 1, NULL, NULL, NULL);
- }
-
- static int apply_save_autostash_ref(struct repository *r, const char *refname,
-- int attempt_apply)
-+ int attempt_apply,
-+ const char *label1, const char *label2,
-+ const char *label_ancestor)
- {
- struct object_id stash_oid;
- char stash_oid_hex[GIT_MAX_HEXSZ + 1];
-@@ sequencer.c: 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);
-+ ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply,
-+ label1, label2, label_ancestor);
-
- refs_delete_ref(get_main_ref_store(r), "", refname,
- &stash_oid, REF_NO_DEREF);
-@@ sequencer.c: 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);
-+ return apply_save_autostash_ref(r, refname, 0, NULL, NULL, NULL);
- }
-
- int apply_autostash_ref(struct repository *r, const char *refname)
- {
-- return apply_save_autostash_ref(r, refname, 1);
-+ 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 *label1, const char *label2,
-+ const char *label_ancestor)
-+{
-+ return apply_save_autostash_ref(r, refname, 1,
-+ label1, label2, label_ancestor);
- }
-
- static int checkout_onto(struct repository *r, struct replay_opts *opts,
-
- ## sequencer.h ##
-@@ sequencer.h: 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 *label1, const char *label2,
-+ const char *label_ancestor);
-
- #define SUMMARY_INITIAL_COMMIT (1 << 0)
- #define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)

## t/t3420-rebase-autostash.sh ##
@@ t/t3420-rebase-autostash.sh: create_expected_failure_apply () {
@@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
git reset --hard &&

## t/t7600-merge.sh ##
-@@ t/t7600-merge.sh: test_expect_success 'merge --squash --autostash conflict does not attempt to app
- >unrelated &&
- git add unrelated &&
- test_must_fail git merge --squash c7 --autostash >out 2>err &&
-- ! grep "Applying autostash resulted in conflicts." err &&
-+ ! grep "resulted in conflicts" err &&
- grep "When finished, apply stashed changes with \git stash pop\" out
- '
-
@@ t/t7600-merge.sh: 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 "Applying autostash resulted in conflicts." err &&
-+ test_grep "resulted in conflicts" err &&
++ test_grep "your local changes resulted in conflicts" err &&
git show HEAD:file >merge-result &&
test_cmp result.1-9 merge-result &&
git stash show -p >actual &&

gitgitgadget

From: Harald Nordgren <[email protected]>

Allow callers of "git stash apply" to pass custom labels for conflict markers instead of the default "Updated upstream" and "Stashed changes". Document the new options and add a test.

---
 Documentation/git-stash.adoc | 11 ++++++++++-
 builtin/stash.c              |  2 +-
 t/t3903-stash.sh             | 18 ++++++++++++++++++
 3 files changed, 29 insertions(+), 2 deletions(-)

index 235d57ddd8..43650a3c1a 100644
@@ -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] [<stash>]
+git stash apply [--index] [-q | --quiet] [--ours-label=<label>] [--theirs-label=<label>] [--base-label=<label>] [<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>]

@@ -197,6 +197,15 @@ 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).
 
+`--ours-label=<label>`::
+`--theirs-label=<label>`::
+`--base-label=<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".
+`--base-label` only has an effect with merge.conflictStyle=diff3.
+
 `-k`::
 `--keep-index`::
 `--no-keep-index`::

index e79d612e57..252e4df3a9 100644
@@ -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] [<stash>]")
+	N_("git stash apply [--index] [-q | --quiet] [--ours-label=<label>] [--theirs-label=<label>] [--base-label=<label>] [<stash>]")
 #define BUILTIN_STASH_BRANCH_USAGE \
 	N_("git stash branch <branchname> [<stash>]")
 #define BUILTIN_STASH_STORE_USAGE \

index 70879941c2..dd47c1322a 100755
@@ -1666,6 +1666,24 @@ 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 &&
+		echo base >file &&
+		git add file &&
+		git commit -m base &&
+		echo stashed >file &&
+		git stash push -m "stashed" &&
+		echo upstream >file &&
+		git add file &&
+		git commit -m upstream &&
+		test_must_fail git stash apply --ours-label=UP --theirs-label=STASH &&
+		grep "^<<<<<<< UP" file &&
+		grep "^>>>>>>> STASH" file
+	)
+'
+
 test_expect_success 'stash create reports a locked index' '
 	test_when_finished "rm -rf repo" &&
 	git init repo &&

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a silent parameter to create_autostash_internal and introduce create_autostash_ref_silent so that callers can create an autostash without printing the "Created autostash" message. Use stderr for the message when not silent.

---
 sequencer.c | 15 +++++++++++----
 sequencer.h |  1 +
 2 files changed, 12 insertions(+), 4 deletions(-)

index aafd0bc959..eebefd731b 100644
@@ -4632,7 +4632,8 @@ 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)
+				      const char *refname,
+				      int silent)
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct lock_file lock_file = LOCK_INIT;

@@ -4677,7 +4678,8 @@ static void create_autostash_internal(struct repository *r,
 					&oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
 		}
 
-		printf(_("Created autostash: %s\n"), buf.buf);
+		if (!silent)
+			fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
 		if (reset_head(r, &ropts) < 0)
 			die(_("could not reset --hard"));
 		discard_index(r->index);

@@ -4689,12 +4691,17 @@ static void create_autostash_internal(struct repository *r,
 
 void create_autostash(struct repository *r, const char *path)
 {
-	create_autostash_internal(r, path, NULL);
+	create_autostash_internal(r, path, NULL, 0);
 }
 
 void create_autostash_ref(struct repository *r, const char *refname)
 {
-	create_autostash_internal(r, NULL, refname);
+	create_autostash_internal(r, NULL, refname, 0);
+}
+
+void create_autostash_ref_silent(struct repository *r, const char *refname)
+{
+	create_autostash_internal(r, NULL, refname, 1);
 }
 
 static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)

index 719684c8a9..0b09d6799b 100644
@@ -227,6 +227,7 @@ 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);

gitgitgadget

From: Harald Nordgren <[email protected]>

Add label1, label2, and label_ancestor parameters to the autostash apply machinery so callers can pass custom conflict marker labels through to "git stash apply --ours-label/--theirs-label/--base-label". Introduce apply_autostash_ref_with_labels() for callers that want to pass labels.

---
 sequencer.c | 34 +++++++++++++++++++++++++++-------
 sequencer.h |  3 +++
 2 files changed, 30 insertions(+), 7 deletions(-)

index eebefd731b..080a25820a 100644
@@ -4704,7 +4704,9 @@ void create_autostash_ref_silent(struct repository *r, const char *refname)
 	create_autostash_internal(r, NULL, refname, 1);
 }
 
-static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
+static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
+				    const char *label1, const char *label2,
+				    const char *label_ancestor)
 {
 	struct child_process child = CHILD_PROCESS_INIT;
 	int ret = 0;

@@ -4715,6 +4717,12 @@ 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 (label1)
+			strvec_pushf(&child.args, "--ours-label=%s", label1);
+		if (label2)
+			strvec_pushf(&child.args, "--theirs-label=%s", label2);
+		if (label_ancestor)
+			strvec_pushf(&child.args, "--base-label=%s", label_ancestor);
 		strvec_push(&child.args, stash_oid);
 		ret = run_command(&child);
 	}

@@ -4759,7 +4767,8 @@ 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);
+	ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply,
+				      NULL, NULL, NULL);
 
 	unlink(path);
 	strbuf_release(&stash_oid);

@@ -4778,11 +4787,13 @@ int apply_autostash(const char *path)
 
 int apply_autostash_oid(const char *stash_oid)
 {
-	return apply_save_autostash_oid(stash_oid, 1);
+	return apply_save_autostash_oid(stash_oid, 1, NULL, NULL, NULL);
 }
 
 static int apply_save_autostash_ref(struct repository *r, const char *refname,
-				    int attempt_apply)
+				    int attempt_apply,
+				    const char *label1, const char *label2,
+				    const char *label_ancestor)
 {
 	struct object_id stash_oid;
 	char stash_oid_hex[GIT_MAX_HEXSZ + 1];

@@ -4798,7 +4809,8 @@ 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);
+	ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply,
+				       label1, label2, label_ancestor);
 
 	refs_delete_ref(get_main_ref_store(r), "", refname,
 			&stash_oid, REF_NO_DEREF);

@@ -4808,12 +4820,20 @@ 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);
+	return apply_save_autostash_ref(r, refname, 0, NULL, NULL, NULL);
 }
 
 int apply_autostash_ref(struct repository *r, const char *refname)
 {
-	return apply_save_autostash_ref(r, refname, 1);
+	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 *label1, const char *label2,
+				    const char *label_ancestor)
+{
+	return apply_save_autostash_ref(r, refname, 1,
+					label1, label2, label_ancestor);
 }
 
 static int checkout_onto(struct repository *r, struct replay_opts *opts,

index 0b09d6799b..68b94d86e3 100644
@@ -233,6 +233,9 @@ 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 *label1, const char *label2,
+				    const char *label_ancestor);
 
 #define SUMMARY_INITIAL_COMMIT   (1 << 0)
 #define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)

gitgitgadget

From: Harald Nordgren <[email protected]>

When switching branches with "git checkout -m", local modifications can block the switch. Teach the -m flow to create a temporary stash before switching and reapply it after. On success, only "Applied autostash." is shown. If reapplying causes conflicts, the stash is kept and the user is told they can resolve and run "git stash drop", or run "git reset --hard" and later "git stash pop" to recover their changes.

---
 Documentation/git-checkout.adoc |  58 +++++-----
 Documentation/git-switch.adoc   |  27 ++---
 builtin/checkout.c              | 180 ++++++++++++++++++--------------
 builtin/stash.c                 |  30 ++++--
 sequencer.c                     |  18 +++-
 t/t3420-rebase-autostash.sh     |  24 +++--
 t/t7201-co.sh                   | 160 ++++++++++++++++++++++++++++
 t/t7600-merge.sh                |   2 +-
 xdiff-interface.c               |  12 +++
 xdiff-interface.h               |   1 +
 10 files changed, 376 insertions(+), 136 deletions(-)

index 43ccf47cf6..18022e610e 100644
@@ -251,20 +251,19 @@ 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.
-	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).
+	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.
 +
 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

@@ -578,39 +577,44 @@ $ git checkout mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would try a
-three-way merge:
+You can give the `-m` flag to the command, which would carry your local
+changes to the new branch:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
+Switched to branch 'mytopic'
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and 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 a merge conflict happens during switching branches with
-the `-m` option, you would see something like this:
+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 the stash application results in conflicts, they are not
+resolved and the stash is saved to the stash list:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
-ERROR: Merge conflict in frotz
-fatal: merge program failed
-------------
+Your local changes are stashed, however, applying it to carry
+forward your local changes resulted in conflicts:
 
-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:
+ - 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.
 ------------
-$ edit frotz
-$ git add frotz
-------------
+
+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`.
 
 CONFIGURATION
 -------------

index 87707e9265..3147023dc3 100644
@@ -126,15 +126,16 @@ variable.
 	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).
+	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.
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the

@@ -217,15 +218,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 try a three-way
-merge:
+You can give the `-m` flag to the command, which would carry your local
+changes to the new branch:
 
 ------------
 $ git switch -m mytopic
-Auto-merging frotz
+Switched to branch 'mytopic'
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 

index 252e4df3a9..ab9c1359b1 100644
@@ -590,8 +590,11 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
 		die(_("could not write index"));
 }
 
-static int do_apply_stash(const char *prefix, struct stash_info *info,
-			  int index, int quiet)
+static int do_apply_stash_with_labels(const char *prefix,
+				      struct stash_info *info,
+				      int index, int quiet,
+				      const char *label1, const char *label2,
+				      const char *label_ancestor)
 {
 	int clean, ret;
 	int has_index = index;

@@ -643,9 +646,9 @@ static int do_apply_stash(const char *prefix, struct stash_info *info,
 
 	init_ui_merge_options(&o, the_repository);
 
-	o.branch1 = "Updated upstream";
-	o.branch2 = "Stashed changes";
-	o.ancestor = "Stash base";
+	o.branch1 = label1 ? label1 : "Updated upstream";
+	o.branch2 = label2 ? label2 : "Stashed changes";
+	o.ancestor = label_ancestor ? label_ancestor : "Stash base";
 
 	if (oideq(&info->b_tree, &c_tree))
 		o.branch1 = "Version stash was based on";

@@ -717,17 +720,31 @@ 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 *label1 = NULL, *label2 = NULL, *label_ancestor = 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, "ours-label", &label1, N_("label"),
+			   N_("label for the upstream side in conflict markers")),
+		OPT_STRING(0, "theirs-label", &label2, N_("label"),
+			   N_("label for the stashed side in conflict markers")),
+		OPT_STRING(0, "base-label", &label_ancestor, N_("label"),
+			   N_("label for the base in diff3 conflict markers")),
 		OPT_END()
 	};
 

@@ -737,7 +754,8 @@ 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(prefix, &info, index, quiet);
+	ret = do_apply_stash_with_labels(prefix, &info, index, quiet,
+					 label1, label2, label_ancestor);
 cleanup:
 	free_stash_info(&info);
 	return ret;

index 080a25820a..53e04d8a94 100644
@@ -4741,15 +4741,23 @@ 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,
-				_("%s\n"
+				_("Autostash exists; creating a new stash entry.\n"
 				  "Your changes are safe in the stash.\n"
 				  "You can run \"git stash pop\" or"
-				  " \"git stash drop\" at any time.\n"),
-				attempt_apply ?
-				_("Applying autostash resulted in conflicts.") :
-				_("Autostash exists; creating a new stash entry."));
+				  " \"git stash drop\" at any time.\n"));
 	}
 
 	return ret;

index ad3ba6a984..e4e2cb19ce 100755
@@ -61,18 +61,30 @@ create_expected_failure_apply () {
 	First, rewinding head to replay your work on top of it...
 	Applying: second commit
 	Applying: third commit
-	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.
+	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.
 	EOF
 }
 
 create_expected_failure_merge () {
 	cat >expected <<-EOF
 	$(grep "^Created autostash: [0-9a-f][0-9a-f]*\$" actual)
-	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.
+	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.
 	Successfully rebased and updated refs/heads/rebased-feature-branch.
 	EOF
 }

index 9838094b66..cbef8a534e 100755
@@ -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 "Applying autostash resulted in conflicts." err &&
+	test_grep "your local changes resulted in conflicts" err &&
 	git show HEAD:file >merge-result &&
 	test_cmp result.1-9 merge-result &&
 	git stash show -p >actual &&

index f043330f2a..5ee2b96d0a 100644
@@ -325,6 +325,18 @@ 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,

index fbc4ceec40..ce54e1c0e0 100644
@@ -55,6 +55,7 @@ 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;

gitgitgadget

Harald Nordgren (4):
stash: add --ours-label, --theirs-label, --base-label for apply
sequencer: allow create_autostash to run silently
sequencer: teach autostash apply to take optional conflict marker
labels
checkout: -m (--merge) uses autostash when switching branches

 Documentation/git-checkout.adoc |  58 ++++++------
 Documentation/git-stash.adoc    |  11 ++-
 Documentation/git-switch.adoc   |  27 +++---
 builtin/checkout.c              | 137 ++++++++++++---------------
 builtin/stash.c                 |  32 +++++--
 sequencer.c                     |  67 +++++++++----
 sequencer.h                     |   4 +
 t/t3420-rebase-autostash.sh     |  24 +++--
 t/t3903-stash.sh                |  18 ++++
 t/t7201-co.sh                   | 160 ++++++++++++++++++++++++++++++++
 t/t7600-merge.sh                |   2 +-
 xdiff-interface.c               |  12 +++
 xdiff-interface.h               |   1 +
 13 files changed, 403 insertions(+), 150 deletions(-)

base-commit: ca1db8a0f7dc0dbea892e99f5b37c5fe5861be71
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2234%2FHaraldNordgren%2Fcheckout_autostash-v6
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2234/HaraldNordgren/checkout_autostash-v6
Pull-Request: https://github.com/git/git/pull/2234

Range-diff vs v5:

 1:  00d8920498 = 1:  cd9c64ba60 stash: add --ours-label, --theirs-label, --base-label for apply
 2:  5d176f1700 = 2:  d572c4bb7d sequencer: allow create_autostash to run silently
 3:  3d6829438a = 3:  80a98116fc sequencer: teach autostash apply to take optional conflict marker labels
 4:  7f3735d40e ! 4:  7ecb0835b7 checkout: -m (--merge) uses autostash when switching branches
     @@ builtin/checkout.c
       #include "submodule.h"
       #include "symlinks.h"
      @@ builtin/checkout.c: 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)
     ++	if (repo_read_index_preload(the_repository, NULL, 0) < 0) {
     ++		rollback_lock_file(&lock_file);
     + 		return error(_("index file corrupt"));
     ++	}
     + 
     + 	resolve_undo_clear_index(the_repository->index);
     + 	if (opts->new_orphan_branch && opts->orphan_from_empty_tree) {
     +@@ builtin/checkout.c: 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)
     ++		if (!new_tree) {
     ++			rollback_lock_file(&lock_file);
     + 			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)
     ++		if (ret) {
     ++			rollback_lock_file(&lock_file);
     + 			return ret;
     ++		}
     + 	} else {
     + 		struct tree_desc trees[2];
     + 		struct tree *tree;
     +@@ builtin/checkout.c: 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;
     + 		}
     +@@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *opts,
       		ret = unpack_trees(2, trees, &topts);
       		clear_unpack_trees_porcelain(&topts);
     --		if (ret == -1) {
     + 		if (ret == -1) {
      -			/*
      -			 * Unpack couldn't do a trivial merge; either
      -			 * give up or do a real merge, depending on
     @@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *op
      -			strbuf_release(&old_commit_shortname);
      -			if (ret)
      -				return ret;
     --		}
     -+		if (ret == -1)
     ++			rollback_lock_file(&lock_file);
      +			return 1;
     + 		}
       	}
       
     - 	if (!cache_tree_fully_valid(the_repository->index->cache_tree))
     -@@ builtin/checkout.c: static void orphaned_commit_warning(struct commit *old_commit, struct commit *ne
     - 	release_revisions(&revs);
     - }
     - 
     -+static int checkout_would_clobber_changes(struct branch_info *old_branch_info,
     -+					  struct branch_info *new_branch_info)
     -+{
     -+	struct tree_desc trees[2];
     -+	struct tree *old_tree, *new_tree;
     -+	struct unpack_trees_options topts;
     -+	struct index_state tmp_index = INDEX_STATE_INIT(the_repository);
     -+	const struct object_id *old_commit_oid;
     -+	int ret;
     -+
     -+	if (!new_branch_info->commit)
     -+		return 0;
     -+
     -+	old_commit_oid = old_branch_info->commit ?
     -+		&old_branch_info->commit->object.oid :
     -+		the_hash_algo->empty_tree;
     -+	old_tree = repo_parse_tree_indirect(the_repository, old_commit_oid);
     -+	if (!old_tree)
     -+		return 0;
     -+
     -+	new_tree = repo_get_commit_tree(the_repository,
     -+					new_branch_info->commit);
     -+	if (!new_tree)
     -+		return 0;
     -+	if (repo_parse_tree(the_repository, new_tree) < 0)
     -+		return 0;
     -+
     -+	memset(&topts, 0, sizeof(topts));
     -+	topts.head_idx = -1;
     -+	topts.src_index = the_repository->index;
     -+	topts.dst_index = &tmp_index;
     -+	topts.initial_checkout = is_index_unborn(the_repository->index);
     -+	topts.merge = 1;
     -+	topts.update = 1;
     -+	topts.dry_run = 1;
     -+	topts.quiet = 1;
     -+	topts.fn = twoway_merge;
     -+
     -+	init_tree_desc(&trees[0], &old_tree->object.oid,
     -+		       old_tree->buffer, old_tree->size);
     -+	init_tree_desc(&trees[1], &new_tree->object.oid,
     -+		       new_tree->buffer, new_tree->size);
     -+
     -+	ret = unpack_trees(2, trees, &topts);
     -+	discard_index(&tmp_index);
     -+
     -+	return ret != 0;
     -+}
     -+
     - static int switch_branches(const struct checkout_opts *opts,
     - 			   struct branch_info *new_branch_info)
     - {
      @@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
       	struct object_id rev;
       	int flag, writeout_error = 0;
     @@ builtin/checkout.c: static int switch_branches(const struct checkout_opts *opts,
      +		stash_label_ancestor = old_commit_shortname.buf;
      +	}
      +
     -+	if (opts->merge) {
     -+		if (repo_read_index(the_repository) < 0)
     -+			die(_("index file corrupt"));
     -+		if (checkout_would_clobber_changes(&old_branch_info,
     -+						   new_branch_info)) {
     + 	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");
      +			created_autostash = 1;
     ++			ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
      +		}
     -+	}
     -+
     - 	if (do_merge) {
     - 		ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
       		if (ret) {
      +			apply_autostash_ref_with_labels(the_repository,
      +						       "CHECKOUT_AUTOSTASH",

gitgitgadget

From: Harald Nordgren <[email protected]>

Allow callers of "git stash apply" to pass custom labels for conflict markers instead of the default "Updated upstream" and "Stashed changes". Document the new options and add a test.

---
 Documentation/git-stash.adoc | 11 ++++++++++-
 builtin/stash.c              |  2 +-
 t/t3903-stash.sh             | 18 ++++++++++++++++++
 3 files changed, 29 insertions(+), 2 deletions(-)

index 235d57ddd8..43650a3c1a 100644
@@ -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] [<stash>]
+git stash apply [--index] [-q | --quiet] [--ours-label=<label>] [--theirs-label=<label>] [--base-label=<label>] [<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>]

@@ -197,6 +197,15 @@ 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).
 
+`--ours-label=<label>`::
+`--theirs-label=<label>`::
+`--base-label=<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".
+`--base-label` only has an effect with merge.conflictStyle=diff3.
+
 `-k`::
 `--keep-index`::
 `--no-keep-index`::

index e79d612e57..252e4df3a9 100644
@@ -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] [<stash>]")
+	N_("git stash apply [--index] [-q | --quiet] [--ours-label=<label>] [--theirs-label=<label>] [--base-label=<label>] [<stash>]")
 #define BUILTIN_STASH_BRANCH_USAGE \
 	N_("git stash branch <branchname> [<stash>]")
 #define BUILTIN_STASH_STORE_USAGE \

index 70879941c2..dd47c1322a 100755
@@ -1666,6 +1666,24 @@ 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 &&
+		echo base >file &&
+		git add file &&
+		git commit -m base &&
+		echo stashed >file &&
+		git stash push -m "stashed" &&
+		echo upstream >file &&
+		git add file &&
+		git commit -m upstream &&
+		test_must_fail git stash apply --ours-label=UP --theirs-label=STASH &&
+		grep "^<<<<<<< UP" file &&
+		grep "^>>>>>>> STASH" file
+	)
+'
+
 test_expect_success 'stash create reports a locked index' '
 	test_when_finished "rm -rf repo" &&
 	git init repo &&

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a silent parameter to create_autostash_internal and introduce create_autostash_ref_silent so that callers can create an autostash without printing the "Created autostash" message. Use stderr for the message when not silent.

---
 sequencer.c | 15 +++++++++++----
 sequencer.h |  1 +
 2 files changed, 12 insertions(+), 4 deletions(-)

index aafd0bc959..eebefd731b 100644
@@ -4632,7 +4632,8 @@ 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)
+				      const char *refname,
+				      int silent)
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct lock_file lock_file = LOCK_INIT;

@@ -4677,7 +4678,8 @@ static void create_autostash_internal(struct repository *r,
 					&oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
 		}
 
-		printf(_("Created autostash: %s\n"), buf.buf);
+		if (!silent)
+			fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
 		if (reset_head(r, &ropts) < 0)
 			die(_("could not reset --hard"));
 		discard_index(r->index);

@@ -4689,12 +4691,17 @@ static void create_autostash_internal(struct repository *r,
 
 void create_autostash(struct repository *r, const char *path)
 {
-	create_autostash_internal(r, path, NULL);
+	create_autostash_internal(r, path, NULL, 0);
 }
 
 void create_autostash_ref(struct repository *r, const char *refname)
 {
-	create_autostash_internal(r, NULL, refname);
+	create_autostash_internal(r, NULL, refname, 0);
+}
+
+void create_autostash_ref_silent(struct repository *r, const char *refname)
+{
+	create_autostash_internal(r, NULL, refname, 1);
 }
 
 static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)

index 719684c8a9..0b09d6799b 100644
@@ -227,6 +227,7 @@ 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);

gitgitgadget

From: Harald Nordgren <[email protected]>

Add label1, label2, and label_ancestor parameters to the autostash apply machinery so callers can pass custom conflict marker labels through to "git stash apply --ours-label/--theirs-label/--base-label". Introduce apply_autostash_ref_with_labels() for callers that want to pass labels.

---
 sequencer.c | 34 +++++++++++++++++++++++++++-------
 sequencer.h |  3 +++
 2 files changed, 30 insertions(+), 7 deletions(-)

index eebefd731b..080a25820a 100644
@@ -4704,7 +4704,9 @@ void create_autostash_ref_silent(struct repository *r, const char *refname)
 	create_autostash_internal(r, NULL, refname, 1);
 }
 
-static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
+static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
+				    const char *label1, const char *label2,
+				    const char *label_ancestor)
 {
 	struct child_process child = CHILD_PROCESS_INIT;
 	int ret = 0;

@@ -4715,6 +4717,12 @@ 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 (label1)
+			strvec_pushf(&child.args, "--ours-label=%s", label1);
+		if (label2)
+			strvec_pushf(&child.args, "--theirs-label=%s", label2);
+		if (label_ancestor)
+			strvec_pushf(&child.args, "--base-label=%s", label_ancestor);
 		strvec_push(&child.args, stash_oid);
 		ret = run_command(&child);
 	}

@@ -4759,7 +4767,8 @@ 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);
+	ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply,
+				      NULL, NULL, NULL);
 
 	unlink(path);
 	strbuf_release(&stash_oid);

@@ -4778,11 +4787,13 @@ int apply_autostash(const char *path)
 
 int apply_autostash_oid(const char *stash_oid)
 {
-	return apply_save_autostash_oid(stash_oid, 1);
+	return apply_save_autostash_oid(stash_oid, 1, NULL, NULL, NULL);
 }
 
 static int apply_save_autostash_ref(struct repository *r, const char *refname,
-				    int attempt_apply)
+				    int attempt_apply,
+				    const char *label1, const char *label2,
+				    const char *label_ancestor)
 {
 	struct object_id stash_oid;
 	char stash_oid_hex[GIT_MAX_HEXSZ + 1];

@@ -4798,7 +4809,8 @@ 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);
+	ret = apply_save_autostash_oid(stash_oid_hex, attempt_apply,
+				       label1, label2, label_ancestor);
 
 	refs_delete_ref(get_main_ref_store(r), "", refname,
 			&stash_oid, REF_NO_DEREF);

@@ -4808,12 +4820,20 @@ 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);
+	return apply_save_autostash_ref(r, refname, 0, NULL, NULL, NULL);
 }
 
 int apply_autostash_ref(struct repository *r, const char *refname)
 {
-	return apply_save_autostash_ref(r, refname, 1);
+	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 *label1, const char *label2,
+				    const char *label_ancestor)
+{
+	return apply_save_autostash_ref(r, refname, 1,
+					label1, label2, label_ancestor);
 }
 
 static int checkout_onto(struct repository *r, struct replay_opts *opts,

index 0b09d6799b..68b94d86e3 100644
@@ -233,6 +233,9 @@ 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 *label1, const char *label2,
+				    const char *label_ancestor);
 
 #define SUMMARY_INITIAL_COMMIT   (1 << 0)
 #define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)

gitgitgadget

From: Harald Nordgren <[email protected]>

When switching branches with "git checkout -m", local modifications can block the switch. Teach the -m flow to create a temporary stash before switching and reapply it after. On success, only "Applied autostash." is shown. If reapplying causes conflicts, the stash is kept and the user is told they can resolve and run "git stash drop", or run "git reset --hard" and later "git stash pop" to recover their changes.

---
 Documentation/git-checkout.adoc |  58 ++++++------
 Documentation/git-switch.adoc   |  27 +++---
 builtin/checkout.c              | 137 ++++++++++++---------------
 builtin/stash.c                 |  30 ++++--
 sequencer.c                     |  18 +++-
 t/t3420-rebase-autostash.sh     |  24 +++--
 t/t7201-co.sh                   | 160 ++++++++++++++++++++++++++++++++
 t/t7600-merge.sh                |   2 +-
 xdiff-interface.c               |  12 +++
 xdiff-interface.h               |   1 +
 10 files changed, 332 insertions(+), 137 deletions(-)

index 43ccf47cf6..18022e610e 100644
@@ -251,20 +251,19 @@ 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.
-	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).
+	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.
 +
 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

@@ -578,39 +577,44 @@ $ git checkout mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would try a
-three-way merge:
+You can give the `-m` flag to the command, which would carry your local
+changes to the new branch:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
+Switched to branch 'mytopic'
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and 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 a merge conflict happens during switching branches with
-the `-m` option, you would see something like this:
+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 the stash application results in conflicts, they are not
+resolved and the stash is saved to the stash list:
 
 ------------
 $ git checkout -m mytopic
-Auto-merging frotz
-ERROR: Merge conflict in frotz
-fatal: merge program failed
-------------
+Your local changes are stashed, however, applying it to carry
+forward your local changes resulted in conflicts:
 
-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:
+ - 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.
 ------------
-$ edit frotz
-$ git add frotz
-------------
+
+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`.
 
 CONFIGURATION
 -------------

index 87707e9265..3147023dc3 100644
@@ -126,15 +126,16 @@ variable.
 	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).
+	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.
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the

@@ -217,15 +218,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 try a three-way
-merge:
+You can give the `-m` flag to the command, which would carry your local
+changes to the new branch:
 
 ------------
 $ git switch -m mytopic
-Auto-merging frotz
+Switched to branch 'mytopic'
 ------------
 
-After this three-way merge, the local modifications are _not_
+After the switch, the local modifications are reapplied and are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 

index 252e4df3a9..ab9c1359b1 100644
@@ -590,8 +590,11 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
 		die(_("could not write index"));
 }
 
-static int do_apply_stash(const char *prefix, struct stash_info *info,
-			  int index, int quiet)
+static int do_apply_stash_with_labels(const char *prefix,
+				      struct stash_info *info,
+				      int index, int quiet,
+				      const char *label1, const char *label2,
+				      const char *label_ancestor)
 {
 	int clean, ret;
 	int has_index = index;

@@ -643,9 +646,9 @@ static int do_apply_stash(const char *prefix, struct stash_info *info,
 
 	init_ui_merge_options(&o, the_repository);
 
-	o.branch1 = "Updated upstream";
-	o.branch2 = "Stashed changes";
-	o.ancestor = "Stash base";
+	o.branch1 = label1 ? label1 : "Updated upstream";
+	o.branch2 = label2 ? label2 : "Stashed changes";
+	o.ancestor = label_ancestor ? label_ancestor : "Stash base";
 
 	if (oideq(&info->b_tree, &c_tree))
 		o.branch1 = "Version stash was based on";

@@ -717,17 +720,31 @@ 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 *label1 = NULL, *label2 = NULL, *label_ancestor = 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, "ours-label", &label1, N_("label"),
+			   N_("label for the upstream side in conflict markers")),
+		OPT_STRING(0, "theirs-label", &label2, N_("label"),
+			   N_("label for the stashed side in conflict markers")),
+		OPT_STRING(0, "base-label", &label_ancestor, N_("label"),
+			   N_("label for the base in diff3 conflict markers")),
 		OPT_END()
 	};
 

@@ -737,7 +754,8 @@ 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(prefix, &info, index, quiet);
+	ret = do_apply_stash_with_labels(prefix, &info, index, quiet,
+					 label1, label2, label_ancestor);
 cleanup:
 	free_stash_info(&info);
 	return ret;

index 080a25820a..53e04d8a94 100644
@@ -4741,15 +4741,23 @@ 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,
-				_("%s\n"
+				_("Autostash exists; creating a new stash entry.\n"
 				  "Your changes are safe in the stash.\n"
 				  "You can run \"git stash pop\" or"
-				  " \"git stash drop\" at any time.\n"),
-				attempt_apply ?
-				_("Applying autostash resulted in conflicts.") :
-				_("Autostash exists; creating a new stash entry."));
+				  " \"git stash drop\" at any time.\n"));
 	}
 
 	return ret;

index ad3ba6a984..e4e2cb19ce 100755
@@ -61,18 +61,30 @@ create_expected_failure_apply () {
 	First, rewinding head to replay your work on top of it...
 	Applying: second commit
 	Applying: third commit
-	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.
+	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.
 	EOF
 }
 
 create_expected_failure_merge () {
 	cat >expected <<-EOF
 	$(grep "^Created autostash: [0-9a-f][0-9a-f]*\$" actual)
-	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.
+	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.
 	Successfully rebased and updated refs/heads/rebased-feature-branch.
 	EOF
 }

index 9838094b66..cbef8a534e 100755
@@ -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 "Applying autostash resulted in conflicts." err &&
+	test_grep "your local changes resulted in conflicts" err &&
 	git show HEAD:file >merge-result &&
 	test_cmp result.1-9 merge-result &&
 	git stash show -p >actual &&

index f043330f2a..5ee2b96d0a 100644
@@ -325,6 +325,18 @@ 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,

index fbc4ceec40..ce54e1c0e0 100644
@@ -55,6 +55,7 @@ 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;

gitgitgadget

Harald Nordgren (4):
stash: add --ours-label, --theirs-label, --base-label for apply
sequencer: allow create_autostash to run silently
sequencer: teach autostash apply to take optional conflict marker
labels
checkout: -m (--merge) uses autostash when switching branches

 Documentation/git-checkout.adoc |  58 +++++-----
 Documentation/git-stash.adoc    |  11 +-
 Documentation/git-switch.adoc   |  27 ++---
 builtin/checkout.c              | 138 ++++++++++-------------
 builtin/stash.c                 |  32 ++++--
 sequencer.c                     |  67 +++++++++---
 sequencer.h                     |   4 +
 t/t3420-rebase-autostash.sh     |  24 +++-
 t/t3903-stash.sh                |  18 +++
 t/t7201-co.sh                   | 188 ++++++++++++++++++++++++++++++++
 t/t7600-merge.sh                |   2 +-
 xdiff-interface.c               |  12 ++
 xdiff-interface.h               |   1 +
 13 files changed, 431 insertions(+), 151 deletions(-)

base-commit: b15384c06f77bc2d34d0d3623a8a58218313a561
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2234%2FHaraldNordgren%2Fcheckout_autostash-v7
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2234/HaraldNordgren/checkout_autostash-v7
Pull-Request: https://github.com/git/git/pull/2234

Range-diff vs v6:

1: cd9c64ba60 ! 1: 284075600a stash: add --ours-label, --theirs-label, --base-label for apply
@@ Documentation/git-stash.adoc: git stash list [<log-options>]
-git stash apply [--index] [-q | --quiet] [<stash>]
+git stash apply [--index] [-q | --quiet] [--ours-label=<label>] [--theirs-label=<label>] [--base-label=<label>] [<stash>]
git stash branch <branchname> [<stash>]
- git stash [push [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
+ git stash [push] [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
[-u | --include-untracked] [-a | --all] [(-m | --message) <message>]
@@ Documentation/git-stash.adoc: the index's ones. However, this can fail, when you have conflicts
(which are stored in the index, where you therefore can no longer

 2:  d572c4bb7d = 2:  64261e3cb6 sequencer: allow create_autostash to run silently
 3:  80a98116fc = 3:  c0d6b4b4c0 sequencer: teach autostash apply to take optional conflict marker labels
 4:  7ecb0835b7 ! 4:  1c29e19971 checkout: -m (--merge) uses autostash when switching branches
     @@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *op
      -					0, 0);
      -			init_ui_merge_options(&o, the_repository);
      -			o.verbosity = 0;
     --			work = write_in_core_index_as_tree(the_repository);
     +-			work = write_in_core_index_as_tree(the_repository,
     +-							   the_repository->index);
      -
      -			ret = reset_tree(new_tree,
      -					 opts, 1,
     @@ t/t7201-co.sh: test_expect_success 'checkout --merge --conflict=diff3 <branch>'
      +	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 checkout -m nonoverlap_base 2>stderr &&
     ++	test_grep "Applied autostash" stderr &&
     ++	test_grep ! "resulted in conflicts" stderr &&
     ++
     ++	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 &&

gitgitgadget

From: Harald Nordgren <[email protected]>

Allow callers of "git stash apply" to pass custom labels for conflict markers instead of the default "Updated upstream" and "Stashed changes". Document the new options and add a test.

---
 Documentation/git-stash.adoc | 11 ++++++++++-
 builtin/stash.c              |  2 +-
 t/t3903-stash.sh             | 18 ++++++++++++++++++
 3 files changed, 29 insertions(+), 2 deletions(-)

index b05c990ecd..6829ba1140 100644
@@ -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] [<stash>]
+git stash apply [--index] [-q | --quiet] [--ours-label=<label>] [--theirs-label=<label>] [--base-label=<label>] [<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,6 +195,15 @@ 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).
 
+`--ours-label=<label>`::
+`--theirs-label=<label>`::
+`--base-label=<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".
+`--base-label` only has an effect with merge.conflictStyle=diff3.
+
 `-k`::
 `--keep-index`::
 `--no-keep-index`::

index 0d27b2fb1f..54bcb6ac73 100644
@@ -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] [<stash>]")
+	N_("git stash apply [--index] [-q | --quiet] [--ours-label=<label>] [--theirs-label=<label>] [--base-label=<label>] [<stash>]")
 #define BUILTIN_STASH_BRANCH_USAGE \
 	N_("git stash branch <branchname> [<stash>]")
 #define BUILTIN_STASH_STORE_USAGE \

index 70879941c2..dd47c1322a 100755
@@ -1666,6 +1666,24 @@ 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 &&
+		echo base >file &&
+		git add file &&
+		git commit -m base &&
+		echo stashed >file &&
+		git stash push -m "stashed" &&
+		echo upstream >file &&
+		git add file &&
+		git commit -m upstream &&
+		test_must_fail git stash apply --ours-label=UP --theirs-label=STASH &&
+		grep "^<<<<<<< UP" file &&
+		grep "^>>>>>>> STASH" file
+	)
+'
+
 test_expect_success 'stash create reports a locked index' '
 	test_when_finished "rm -rf repo" &&
 	git init repo &&

gitgitgadget

Fixed, thanks!

Harald

From: Harald Nordgren <[email protected]>

Add a silent parameter to create_autostash_internal and introduce create_autostash_ref_silent so that callers can create an autostash without printing the "Created autostash" message. Use stderr for the message when not silent.

---
 sequencer.c | 15 +++++++++++----
 sequencer.h |  1 +
 2 files changed, 12 insertions(+), 4 deletions(-)

index b7d8dca47f..e500a94a59 100644
@@ -4657,7 +4657,8 @@ 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)
+				      const char *refname,
+				      int silent)
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct lock_file lock_file = LOCK_INIT;

@@ -4702,7 +4703,8 @@ static void create_autostash_internal(struct repository *r,
 					&oid, null_oid(the_hash_algo), 0, UPDATE_REFS_DIE_ON_ERR);
 		}
 
-		printf(_("Created autostash: %s\n"), buf.buf);
+		if (!silent)
+			fprintf(stderr, _("Created autostash: %s\n"), buf.buf);
 		if (reset_head(r, &ropts) < 0)
 			die(_("could not reset --hard"));
 		discard_index(r->index);

@@ -4714,12 +4716,17 @@ static void create_autostash_internal(struct repository *r,
 
 void create_autostash(struct repository *r, const char *path)
 {
-	create_autostash_internal(r, path, NULL);
+	create_autostash_internal(r, path, NULL, 0);
 }
 
 void create_autostash_ref(struct repository *r, const char *refname)
 {
-	create_autostash_internal(r, NULL, refname);
+	create_autostash_internal(r, NULL, refname, 0);
+}
+
+void create_autostash_ref_silent(struct repository *r, const char *refname)
+{
+	create_autostash_internal(r, NULL, refname, 1);
 }
 
 static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)

index a6fa670c7c..570f804457 100644
@@ -230,6 +230,7 @@ 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);

gitgitgadget

From: Harald Nordgren <[email protected]>

Add label1, label2, and label_ancestor parameters to the autostash apply machinery so callers can pass custom conflict marker labels through to "git stash apply --ours-label/--theirs-label/--base-label". Introduce apply_autostash_ref_with_labels() for callers that want to pass labels.

---
 sequencer.c | 34 +++++++++++++++++++++++++++-------
 sequencer.h |  3 +++
 2 files changed, 30 insertions(+), 7 deletions(-)

index e500a94a59..79dceab579 100644
@@ -4729,7 +4729,9 @@ void create_autostash_ref_silent(struct repository *r, const char *refname)
 	create_autostash_internal(r, NULL, refname, 1);
 }
 
-static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
+static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply,
+				    const char *label1, const char *label2,
+				    const char *label_ancestor)
 {
 	struct child_process child = CHILD_PROCESS_INIT;
 	int ret = 0;

@@ -4740,6 +4742,12 @@ 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 (label1)
+			strvec_pushf(&child.args, "--ours-label=%s", label1);
+		if (label2)
+			strvec_pushf(&child.args, "--theirs-label=%s", label2);
+		if (label_ancestor)
+			strvec_pushf(&child.args, "--base-label=%s", label_ancestor);
 		strvec_push(&child.args, stash_oid);
 		ret = run_command(&child);
 	}

@@ -4784,7 +4792,8 @@ 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);
+	ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply,
+				      NULL, NULL, NULL);
 
 	unlink(path);
 	strbuf_release(&stash_oid);