Revert "Merge branch 'hn/git-checkout-m-with-stash' into next"

This reverts commit b4e5a96, reversing
changes made to 0e6c98f, as the topic
is still getting rerolled.

Author: gitster

Documentation/git-checkout.adoc

@@ -251,19 +251,20 @@ working tree, by copying them from elsewhere, extracting a tarball, etc.
 	are different between the current branch and the branch to
 	which you are switching, the command refuses to switch
 	branches in order to preserve your modifications in context.
-	With this option, the conflicting local changes are
-	automatically stashed before the switch and reapplied
-	afterwards.  If the local changes do not overlap with the
-	differences between branches, the switch proceeds without
-	stashing.  If reapplying the stash results in conflicts, the
-	entry is saved to the stash list.  Resolve the conflicts
-	and run `git stash drop` when done, or clear the working
-	tree (e.g. with `git reset --hard`) before running `git stash
-	pop` later to re-apply your changes.
+	However, with this option, a three-way merge between the current
+	branch, your working tree contents, and the new branch
+	is done, and you will be on the new branch.
++
+When a merge conflict happens, the index entries for conflicting
+paths are left unmerged, and you need to resolve the conflicts
+and mark the resolved paths with `git add` (or `git rm` if the merge
+should result in deletion of the path).
 +
 When checking out paths from the index, this option lets you recreate
 the conflicted merge in the specified paths.  This option cannot be
 used when checking out paths from a tree-ish.
++
+When switching branches with `--merge`, staged changes may be lost.
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the
@@ -577,44 +578,39 @@ $ git checkout mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would carry your local
-changes to the new branch:
+You can give the `-m` flag to the command, which would try a
+three-way merge:
 
 ------------
 $ git checkout -m mytopic
-Switched to branch 'mytopic'
+Auto-merging frotz
 ------------
 
-After the switch, the local modifications are reapplied and are _not_
+After this three-way merge, the local modifications are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 
 === 3. Merge conflict
 
-When the `--merge` (`-m`) option is in effect and the locally
-modified files overlap with files that need to be updated by the
-branch switch, the changes are stashed and reapplied after the
-switch.  If this process results in conflicts, a stash entry is saved
-and made available in `git stash list`:
+When a merge conflict happens during switching branches with
+the `-m` option, you would see something like this:
 
 ------------
 $ git checkout -m mytopic
-Your local changes are stashed, however, applying it to carry
-forward your local changes resulted in conflicts:
+Auto-merging frotz
+ERROR: Merge conflict in frotz
+fatal: merge program failed
+------------
 
- - You can try resolving them now.  If you resolved them
-   successfully, discard the stash entry with "git stash drop".
+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:
 
- - 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.
 ------------
-
-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`.
+$ edit frotz
+$ git add frotz
+------------
 
 CONFIGURATION
 -------------

Documentation/git-stash.adoc

@@ -12,7 +12,7 @@ git stash list [<log-options>]
 git stash show [-u | --include-untracked | --only-untracked] [<diff-options>] [<stash>]
 git stash drop [-q | --quiet] [<stash>]
 git stash pop [--index] [-q | --quiet] [<stash>]
-git stash apply [--index] [-q | --quiet] [--label-ours=<label>] [--label-theirs=<label>] [--label-base=<label>] [<stash>]
+git stash apply [--index] [-q | --quiet] [<stash>]
 git stash branch <branchname> [<stash>]
 git stash [push] [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
 	     [-u | --include-untracked] [-a | --all] [(-m | --message) <message>]
@@ -195,15 +195,6 @@ the index's ones. However, this can fail, when you have conflicts
 (which are stored in the index, where you therefore can no longer
 apply the changes as they were originally).
 
-`--label-ours=<label>`::
-`--label-theirs=<label>`::
-`--label-base=<label>`::
-	These options are only valid for the `apply` command.
-+
-Use the given labels in conflict markers instead of the default
-"Updated upstream", "Stashed changes", and "Stash base".
-`--label-base` only has an effect with merge.conflictStyle=diff3.
-
 `-k`::
 `--keep-index`::
 `--no-keep-index`::

Documentation/git-switch.adoc

@@ -123,19 +123,18 @@ variable.
 
 `-m`::
 `--merge`::
-	If you have local modifications to one or more files that
-	are different between the current branch and the branch to
-	which you are switching, the command normally refuses to
-	switch branches in order to preserve your modifications in
-	context.  However, with this option, the conflicting local
-	changes are automatically stashed before the switch and
-	reapplied afterwards.  If the local changes do not overlap
-	with the differences between branches, the switch proceeds
-	without stashing.  If reapplying the stash results in
-	conflicts, the entry is saved to the stash list.  Resolve
-	the conflicts and run `git stash drop` when done, or clear
-	the working tree (e.g. with `git reset --hard`) before
-	running `git stash pop` later to re-apply your changes.
+	If you have local modifications to one or more files that are
+	different between the current branch and the branch to which
+	you are switching, the command refuses to switch branches in
+	order to preserve your modifications in context.  However,
+	with this option, a three-way merge between the current
+	branch, your working tree contents, and the new branch is
+	done, and you will be on the new branch.
++
+When a merge conflict happens, the index entries for conflicting
+paths are left unmerged, and you need to resolve the conflicts
+and mark the resolved paths with `git add` (or `git rm` if the merge
+should result in deletion of the path).
 
 `--conflict=<style>`::
 	The same as `--merge` option above, but changes the way the
@@ -218,15 +217,15 @@ $ git switch mytopic
 error: You have local changes to 'frotz'; not switching branches.
 ------------
 
-You can give the `-m` flag to the command, which would carry your local
-changes to the new branch:
+You can give the `-m` flag to the command, which would try a three-way
+merge:
 
 ------------
 $ git switch -m mytopic
-Switched to branch 'mytopic'
+Auto-merging frotz
 ------------
 
-After the switch, the local modifications are reapplied and are _not_
+After this three-way merge, the local modifications are _not_
 registered in your index file, so `git diff` would show you what
 changes you made since the tip of the new branch.
 

builtin/checkout.c

@@ -17,6 +17,7 @@
 #include "merge-ll.h"
 #include "lockfile.h"
 #include "mem-pool.h"
+#include "merge-ort-wrappers.h"
 #include "object-file.h"
 #include "object-name.h"
 #include "odb.h"
@@ -29,7 +30,6 @@
 #include "repo-settings.h"
 #include "resolve-undo.h"
 #include "revision.h"
-#include "sequencer.h"
 #include "setup.h"
 #include "strvec.h"
 #include "submodule.h"
@@ -790,10 +790,8 @@ static int merge_working_tree(const struct checkout_opts *opts,
 	struct tree *new_tree;
 
 	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
-	if (repo_read_index_preload(the_repository, NULL, 0) < 0) {
-		rollback_lock_file(&lock_file);
+	if (repo_read_index_preload(the_repository, NULL, 0) < 0)
 		return error(_("index file corrupt"));
-	}
 
 	resolve_undo_clear_index(the_repository->index);
 	if (opts->new_orphan_branch && opts->orphan_from_empty_tree) {
@@ -806,18 +804,14 @@ static int merge_working_tree(const struct checkout_opts *opts,
 	} else {
 		new_tree = repo_get_commit_tree(the_repository,
 						new_branch_info->commit);
-		if (!new_tree) {
-			rollback_lock_file(&lock_file);
+		if (!new_tree)
 			return error(_("unable to read tree (%s)"),
 				     oid_to_hex(&new_branch_info->commit->object.oid));
-		}
 	}
 	if (opts->discard_changes) {
 		ret = reset_tree(new_tree, opts, 1, writeout_error, new_branch_info);
-		if (ret) {
-			rollback_lock_file(&lock_file);
+		if (ret)
 			return ret;
-		}
 	} else {
 		struct tree_desc trees[2];
 		struct tree *tree;
@@ -827,7 +821,6 @@ static int merge_working_tree(const struct checkout_opts *opts,
 		refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);
 
 		if (unmerged_index(the_repository->index)) {
-			rollback_lock_file(&lock_file);
 			error(_("you need to resolve your current index first"));
 			return 1;
 		}
@@ -860,8 +853,82 @@ static int merge_working_tree(const struct checkout_opts *opts,
 		ret = unpack_trees(2, trees, &topts);
 		clear_unpack_trees_porcelain(&topts);
 		if (ret == -1) {
-			rollback_lock_file(&lock_file);
-			return 1;
+			/*
+			 * Unpack couldn't do a trivial merge; either
+			 * give up or do a real merge, depending on
+			 * whether the merge flag was used.
+			 */
+			struct tree *work;
+			struct tree *old_tree;
+			struct merge_options o;
+			struct strbuf sb = STRBUF_INIT;
+			struct strbuf old_commit_shortname = STRBUF_INIT;
+
+			if (!opts->merge)
+				return 1;
+
+			/*
+			 * Without old_branch_info->commit, the below is the same as
+			 * the two-tree unpack we already tried and failed.
+			 */
+			if (!old_branch_info->commit)
+				return 1;
+			old_tree = repo_get_commit_tree(the_repository,
+							old_branch_info->commit);
+
+			if (repo_index_has_changes(the_repository, old_tree, &sb))
+				die(_("cannot continue with staged changes in "
+				      "the following files:\n%s"), sb.buf);
+			strbuf_release(&sb);
+
+			/* Do more real merge */
+
+			/*
+			 * We update the index fully, then write the
+			 * tree from the index, then merge the new
+			 * branch with the current tree, with the old
+			 * branch as the base. Then we reset the index
+			 * (but not the working tree) to the new
+			 * branch, leaving the working tree as the
+			 * merged version, but skipping unmerged
+			 * entries in the index.
+			 */
+
+			add_files_to_cache(the_repository, NULL, NULL, NULL, 0,
+					0, 0);
+			init_ui_merge_options(&o, the_repository);
+			o.verbosity = 0;
+			work = write_in_core_index_as_tree(the_repository,
+							   the_repository->index);
+
+			ret = reset_tree(new_tree,
+					 opts, 1,
+					 writeout_error, new_branch_info);
+			if (ret)
+				return ret;
+			o.ancestor = old_branch_info->name;
+			if (!old_branch_info->name) {
+				strbuf_add_unique_abbrev(&old_commit_shortname,
+							 &old_branch_info->commit->object.oid,
+							 DEFAULT_ABBREV);
+				o.ancestor = old_commit_shortname.buf;
+			}
+			o.branch1 = new_branch_info->name;
+			o.branch2 = "local";
+			o.conflict_style = opts->conflict_style;
+			ret = merge_ort_nonrecursive(&o,
+						     new_tree,
+						     work,
+						     old_tree);
+			if (ret < 0)
+				die(NULL);
+			ret = reset_tree(new_tree,
+					 opts, 0,
+					 writeout_error, new_branch_info);
+			strbuf_release(&o.obuf);
+			strbuf_release(&old_commit_shortname);
+			if (ret)
+				return ret;
 		}
 	}
 
@@ -1106,9 +1173,6 @@ static int switch_branches(const struct checkout_opts *opts,
 	struct object_id rev;
 	int flag, writeout_error = 0;
 	int do_merge = 1;
-	int created_autostash = 0;
-	struct strbuf old_commit_shortname = STRBUF_INIT;
-	const char *stash_label_base = NULL;
 
 	trace2_cmd_mode("branch");
 
@@ -1146,31 +1210,10 @@ static int switch_branches(const struct checkout_opts *opts,
 			do_merge = 0;
 	}
 
-	if (old_branch_info.name)
-		stash_label_base = old_branch_info.name;
-	else if (old_branch_info.commit) {
-		strbuf_add_unique_abbrev(&old_commit_shortname,
-					 &old_branch_info.commit->object.oid,
-					 DEFAULT_ABBREV);
-		stash_label_base = old_commit_shortname.buf;
-	}
-
 	if (do_merge) {
 		ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
-		if (ret && opts->merge) {
-			create_autostash_ref_silent(the_repository,
-						   "CHECKOUT_AUTOSTASH_HEAD");
-			created_autostash = 1;
-			ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
-		}
 		if (ret) {
-			apply_autostash_ref_with_labels(the_repository,
-						       "CHECKOUT_AUTOSTASH_HEAD",
-						       new_branch_info->name,
-						       "local",
-						       stash_label_base);
 			branch_info_release(&old_branch_info);
-			strbuf_release(&old_commit_shortname);
 			return ret;
 		}
 	}
@@ -1180,29 +1223,8 @@ static int switch_branches(const struct checkout_opts *opts,
 
 	update_refs_for_switch(opts, &old_branch_info, new_branch_info);
 
-	if (opts->conflict_style >= 0) {
-		struct strbuf cfg = STRBUF_INIT;
-		strbuf_addf(&cfg, "merge.conflictStyle=%s",
-			    conflict_style_name(opts->conflict_style));
-		git_config_push_parameter(cfg.buf);
-		strbuf_release(&cfg);
-	}
-	apply_autostash_ref_with_labels(the_repository, "CHECKOUT_AUTOSTASH_HEAD",
-				       new_branch_info->name, "local",
-				       stash_label_base);
-
-	discard_index(the_repository->index);
-	if (repo_read_index(the_repository) < 0)
-		die(_("index file corrupt"));
-
-	if (created_autostash && !opts->discard_changes && !opts->quiet &&
-	    new_branch_info->commit)
-		show_local_changes(&new_branch_info->commit->object,
-				   &opts->diff_options);
-
 	ret = post_checkout_hook(old_branch_info.commit, new_branch_info->commit, 1);
 	branch_info_release(&old_branch_info);
-	strbuf_release(&old_commit_shortname);
 
 	return ret || writeout_error;
 }