3 #include "parse-options.h"
8 #include "cache-tree.h"
9 #include "unpack-trees.h"
11 #include "run-command.h"
12 #include "merge-recursive.h"
18 #include "xdiff-interface.h"
20 #include "resolve-undo.h"
21 #include "submodule.h"
23 static const char * const checkout_usage[] = {
24 "git checkout [options] <branch>",
25 "git checkout [options] [<branch>] -- <file>...",
29 struct checkout_opts {
36 const char *new_branch;
37 const char *new_orphan_branch;
39 enum branch_track track;
40 struct diff_options diff_options;
43 static int post_checkout_hook(struct commit *old, struct commit *new,
46 return run_hook(NULL, "post-checkout",
47 sha1_to_hex(old ? old->object.sha1 : null_sha1),
48 sha1_to_hex(new ? new->object.sha1 : null_sha1),
49 changed ? "1" : "0", NULL);
50 /* "new" can be NULL when checking out from the index before
55 static int update_some(const unsigned char *sha1, const char *base, int baselen,
56 const char *pathname, unsigned mode, int stage, void *context)
59 struct cache_entry *ce;
62 return READ_TREE_RECURSIVE;
64 len = baselen + strlen(pathname);
65 ce = xcalloc(1, cache_entry_size(len));
66 hashcpy(ce->sha1, sha1);
67 memcpy(ce->name, base, baselen);
68 memcpy(ce->name + baselen, pathname, len - baselen);
69 ce->ce_flags = create_ce_flags(len, 0);
70 ce->ce_mode = create_ce_mode(mode);
71 add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
75 static int read_tree_some(struct tree *tree, const char **pathspec)
77 read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
79 /* update the index with the given tree's info
80 * for all args, expanding wildcards, and exit
81 * with any non-zero return code.
86 static int skip_same_name(struct cache_entry *ce, int pos)
88 while (++pos < active_nr &&
89 !strcmp(active_cache[pos]->name, ce->name))
94 static int check_stage(int stage, struct cache_entry *ce, int pos)
96 while (pos < active_nr &&
97 !strcmp(active_cache[pos]->name, ce->name)) {
98 if (ce_stage(active_cache[pos]) == stage)
102 return error("path '%s' does not have %s version",
104 (stage == 2) ? "our" : "their");
107 static int check_all_stages(struct cache_entry *ce, int pos)
109 if (ce_stage(ce) != 1 ||
110 active_nr <= pos + 2 ||
111 strcmp(active_cache[pos+1]->name, ce->name) ||
112 ce_stage(active_cache[pos+1]) != 2 ||
113 strcmp(active_cache[pos+2]->name, ce->name) ||
114 ce_stage(active_cache[pos+2]) != 3)
115 return error("path '%s' does not have all three versions",
120 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
121 struct checkout *state)
123 while (pos < active_nr &&
124 !strcmp(active_cache[pos]->name, ce->name)) {
125 if (ce_stage(active_cache[pos]) == stage)
126 return checkout_entry(active_cache[pos], state, NULL);
129 return error("path '%s' does not have %s version",
131 (stage == 2) ? "our" : "their");
134 static int checkout_merged(int pos, struct checkout *state)
136 struct cache_entry *ce = active_cache[pos];
137 const char *path = ce->name;
138 mmfile_t ancestor, ours, theirs;
140 unsigned char sha1[20];
141 mmbuffer_t result_buf;
143 if (ce_stage(ce) != 1 ||
144 active_nr <= pos + 2 ||
145 strcmp(active_cache[pos+1]->name, path) ||
146 ce_stage(active_cache[pos+1]) != 2 ||
147 strcmp(active_cache[pos+2]->name, path) ||
148 ce_stage(active_cache[pos+2]) != 3)
149 return error("path '%s' does not have all 3 versions", path);
151 read_mmblob(&ancestor, active_cache[pos]->sha1);
152 read_mmblob(&ours, active_cache[pos+1]->sha1);
153 read_mmblob(&theirs, active_cache[pos+2]->sha1);
155 status = ll_merge(&result_buf, path, &ancestor, "base",
156 &ours, "ours", &theirs, "theirs", 0);
160 if (status < 0 || !result_buf.ptr) {
161 free(result_buf.ptr);
162 return error("path '%s': cannot merge", path);
167 * There is absolutely no reason to write this as a blob object
168 * and create a phony cache entry just to leak. This hack is
169 * primarily to get to the write_entry() machinery that massages
170 * the contents to work-tree format and writes out which only
171 * allows it for a cache entry. The code in write_entry() needs
172 * to be refactored to allow us to feed a <buffer, size, mode>
173 * instead of a cache entry. Such a refactoring would help
174 * merge_recursive as well (it also writes the merge result to the
175 * object database even when it may contain conflicts).
177 if (write_sha1_file(result_buf.ptr, result_buf.size,
179 die("Unable to add merge result for '%s'", path);
180 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
184 die("make_cache_entry failed for path '%s'", path);
185 status = checkout_entry(ce, state, NULL);
189 static int checkout_paths(struct tree *source_tree, const char **pathspec,
190 struct checkout_opts *opts)
193 struct checkout state;
194 static char *ps_matched;
195 unsigned char rev[20];
199 int stage = opts->writeout_stage;
200 int merge = opts->merge;
202 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
204 newfd = hold_locked_index(lock_file, 1);
205 if (read_cache_preload(pathspec) < 0)
206 return error("corrupt index file");
209 read_tree_some(source_tree, pathspec);
211 for (pos = 0; pathspec[pos]; pos++)
213 ps_matched = xcalloc(1, pos);
215 for (pos = 0; pos < active_nr; pos++) {
216 struct cache_entry *ce = active_cache[pos];
217 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
220 if (report_path_error(ps_matched, pathspec, 0))
223 /* "checkout -m path" to recreate conflicted state */
225 unmerge_cache(pathspec);
227 /* Any unmerged paths? */
228 for (pos = 0; pos < active_nr; pos++) {
229 struct cache_entry *ce = active_cache[pos];
230 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
234 warning("path '%s' is unmerged", ce->name);
236 errs |= check_stage(stage, ce, pos);
237 } else if (opts->merge) {
238 errs |= check_all_stages(ce, pos);
241 error("path '%s' is unmerged", ce->name);
243 pos = skip_same_name(ce, pos) - 1;
249 /* Now we are committed to check them out */
250 memset(&state, 0, sizeof(state));
252 state.refresh_cache = 1;
253 for (pos = 0; pos < active_nr; pos++) {
254 struct cache_entry *ce = active_cache[pos];
255 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
257 errs |= checkout_entry(ce, &state, NULL);
261 errs |= checkout_stage(stage, ce, pos, &state);
263 errs |= checkout_merged(pos, &state);
264 pos = skip_same_name(ce, pos) - 1;
268 if (write_cache(newfd, active_cache, active_nr) ||
269 commit_locked_index(lock_file))
270 die("unable to write new index file");
272 resolve_ref("HEAD", rev, 0, &flag);
273 head = lookup_commit_reference_gently(rev, 1);
275 errs |= post_checkout_hook(head, head, 0);
279 static void show_local_changes(struct object *head, struct diff_options *opts)
282 /* I think we want full paths, even if we're in a subdirectory. */
283 init_revisions(&rev, NULL);
285 rev.diffopt.flags = opts->flags;
286 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
287 if (diff_setup_done(&rev.diffopt) < 0)
288 die("diff_setup_done failed");
289 add_pending_object(&rev, head, NULL);
290 run_diff_index(&rev, 0);
293 static void describe_detached_head(char *msg, struct commit *commit)
295 struct strbuf sb = STRBUF_INIT;
296 struct pretty_print_context ctx = {0};
297 parse_commit(commit);
298 pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
299 fprintf(stderr, "%s %s... %s\n", msg,
300 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
304 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
306 struct unpack_trees_options opts;
307 struct tree_desc tree_desc;
309 memset(&opts, 0, sizeof(opts));
311 opts.update = worktree;
312 opts.skip_unmerged = !worktree;
315 opts.fn = oneway_merge;
316 opts.verbose_update = !o->quiet;
317 opts.src_index = &the_index;
318 opts.dst_index = &the_index;
320 init_tree_desc(&tree_desc, tree->buffer, tree->size);
321 switch (unpack_trees(1, &tree_desc, &opts)) {
323 o->writeout_error = 1;
325 * We return 0 nevertheless, as the index is all right
326 * and more importantly we have made best efforts to
327 * update paths in the work tree, and we cannot revert
338 const char *name; /* The short name used */
339 const char *path; /* The full name of a real branch */
340 struct commit *commit; /* The named commit */
343 static void setup_branch_path(struct branch_info *branch)
345 struct strbuf buf = STRBUF_INIT;
347 strbuf_branchname(&buf, branch->name);
348 if (strcmp(buf.buf, branch->name))
349 branch->name = xstrdup(buf.buf);
350 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
351 branch->path = strbuf_detach(&buf, NULL);
354 static int merge_working_tree(struct checkout_opts *opts,
355 struct branch_info *old, struct branch_info *new)
358 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
359 int newfd = hold_locked_index(lock_file, 1);
361 if (read_cache_preload(NULL) < 0)
362 return error("corrupt index file");
364 resolve_undo_clear();
366 ret = reset_tree(new->commit->tree, opts, 1);
370 struct tree_desc trees[2];
372 struct unpack_trees_options topts;
374 memset(&topts, 0, sizeof(topts));
376 topts.src_index = &the_index;
377 topts.dst_index = &the_index;
379 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
381 refresh_cache(REFRESH_QUIET);
383 if (unmerged_cache()) {
384 error("you need to resolve your current index first");
388 /* 2-way merge to the new branch */
389 topts.initial_checkout = is_cache_unborn();
392 topts.gently = opts->merge && old->commit;
393 topts.verbose_update = !opts->quiet;
394 topts.fn = twoway_merge;
395 topts.dir = xcalloc(1, sizeof(*topts.dir));
396 topts.dir->flags |= DIR_SHOW_IGNORED;
397 topts.dir->exclude_per_dir = ".gitignore";
398 tree = parse_tree_indirect(old->commit ?
399 old->commit->object.sha1 :
400 (unsigned char *)EMPTY_TREE_SHA1_BIN);
401 init_tree_desc(&trees[0], tree->buffer, tree->size);
402 tree = parse_tree_indirect(new->commit->object.sha1);
403 init_tree_desc(&trees[1], tree->buffer, tree->size);
405 ret = unpack_trees(2, trees, &topts);
408 * Unpack couldn't do a trivial merge; either
409 * give up or do a real merge, depending on
410 * whether the merge flag was used.
414 struct merge_options o;
419 * Without old->commit, the below is the same as
420 * the two-tree unpack we already tried and failed.
425 /* Do more real merge */
428 * We update the index fully, then write the
429 * tree from the index, then merge the new
430 * branch with the current tree, with the old
431 * branch as the base. Then we reset the index
432 * (but not the working tree) to the new
433 * branch, leaving the working tree as the
434 * merged version, but skipping unmerged
435 * entries in the index.
438 add_files_to_cache(NULL, NULL, 0);
439 init_merge_options(&o);
441 work = write_tree_from_memory(&o);
443 ret = reset_tree(new->commit->tree, opts, 1);
446 o.ancestor = old->name;
447 o.branch1 = new->name;
449 merge_trees(&o, new->commit->tree, work,
450 old->commit->tree, &result);
451 ret = reset_tree(new->commit->tree, opts, 0);
457 if (write_cache(newfd, active_cache, active_nr) ||
458 commit_locked_index(lock_file))
459 die("unable to write new index file");
461 if (!opts->force && !opts->quiet)
462 show_local_changes(&new->commit->object, &opts->diff_options);
467 static void report_tracking(struct branch_info *new)
469 struct strbuf sb = STRBUF_INIT;
470 struct branch *branch = branch_get(new->name);
472 if (!format_tracking_info(branch, &sb))
474 fputs(sb.buf, stdout);
478 static void detach_advice(const char *old_path, const char *new_name)
481 "Note: checking out '%s'.\n\n"
482 "You are in 'detached HEAD' state. You can look around, make experimental\n"
483 "changes and commit them, and you can discard any commits you make in this\n"
484 "state without impacting any branches by performing another checkout.\n\n"
485 "If you want to create a new branch to retain commits you create, you may\n"
486 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
487 " git checkout -b new_branch_name\n\n";
489 fprintf(stderr, fmt, new_name);
492 static void update_refs_for_switch(struct checkout_opts *opts,
493 struct branch_info *old,
494 struct branch_info *new)
496 struct strbuf msg = STRBUF_INIT;
497 const char *old_desc;
498 if (opts->new_branch) {
499 if (opts->new_orphan_branch) {
500 if (opts->new_branch_log && !log_all_ref_updates) {
502 char log_file[PATH_MAX];
503 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
505 temp = log_all_ref_updates;
506 log_all_ref_updates = 1;
507 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
508 fprintf(stderr, "Can not do reflog for '%s'\n",
509 opts->new_orphan_branch);
510 log_all_ref_updates = temp;
513 log_all_ref_updates = temp;
517 create_branch(old->name, opts->new_branch, new->name, 0,
518 opts->new_branch_log, opts->track);
519 new->name = opts->new_branch;
520 setup_branch_path(new);
523 old_desc = old->name;
524 if (!old_desc && old->commit)
525 old_desc = sha1_to_hex(old->commit->object.sha1);
526 strbuf_addf(&msg, "checkout: moving from %s to %s",
527 old_desc ? old_desc : "(invalid)", new->name);
530 create_symref("HEAD", new->path, msg.buf);
532 if (old->path && !strcmp(new->path, old->path))
533 fprintf(stderr, "Already on '%s'\n",
536 fprintf(stderr, "Switched to%s branch '%s'\n",
537 opts->new_branch ? " a new" : "",
540 if (old->path && old->name) {
541 char log_file[PATH_MAX], ref_file[PATH_MAX];
543 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
544 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
545 if (!file_exists(ref_file) && file_exists(log_file))
546 remove_path(log_file);
548 } else if (strcmp(new->name, "HEAD")) {
549 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
550 REF_NODEREF, DIE_ON_ERR);
552 if (old->path && advice_detached_head)
553 detach_advice(old->path, new->name);
554 describe_detached_head("HEAD is now at", new->commit);
557 remove_branch_state();
558 strbuf_release(&msg);
559 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
560 report_tracking(new);
563 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
566 struct branch_info old;
567 unsigned char rev[20];
569 memset(&old, 0, sizeof(old));
570 old.path = resolve_ref("HEAD", rev, 0, &flag);
571 old.commit = lookup_commit_reference_gently(rev, 1);
572 if (!(flag & REF_ISSYMREF))
575 if (old.path && !prefixcmp(old.path, "refs/heads/"))
576 old.name = old.path + strlen("refs/heads/");
580 new->commit = old.commit;
582 die("You are on a branch yet to be born");
583 parse_commit(new->commit);
586 ret = merge_working_tree(opts, &old, new);
591 * If we were on a detached HEAD, but have now moved to
592 * a new commit, we want to mention the old commit once more
593 * to remind the user that it might be lost.
595 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
596 describe_detached_head("Previous HEAD position was", old.commit);
598 update_refs_for_switch(opts, &old, new);
600 ret = post_checkout_hook(old.commit, new->commit, 1);
601 return ret || opts->writeout_error;
604 static int git_checkout_config(const char *var, const char *value, void *cb)
606 if (!strcmp(var, "diff.ignoresubmodules")) {
607 struct checkout_opts *opts = cb;
608 handle_ignore_submodules_arg(&opts->diff_options, value);
612 if (!prefixcmp(var, "submodule."))
613 return parse_submodule_config_option(var, value);
615 return git_xmerge_config(var, value, NULL);
618 static int interactive_checkout(const char *revision, const char **pathspec,
619 struct checkout_opts *opts)
621 return run_add_interactive(revision, "--patch=checkout", pathspec);
624 struct tracking_name_data {
630 static int check_tracking_name(const char *refname, const unsigned char *sha1,
631 int flags, void *cb_data)
633 struct tracking_name_data *cb = cb_data;
636 if (prefixcmp(refname, "refs/remotes/"))
638 slash = strchr(refname + 13, '/');
639 if (!slash || strcmp(slash + 1, cb->name))
645 cb->remote = xstrdup(refname);
649 static const char *unique_tracking_name(const char *name)
651 struct tracking_name_data cb_data = { NULL, NULL, 1 };
653 for_each_ref(check_tracking_name, &cb_data);
655 return cb_data.remote;
656 free(cb_data.remote);
660 int cmd_checkout(int argc, const char **argv, const char *prefix)
662 struct checkout_opts opts;
663 unsigned char rev[20];
665 struct branch_info new;
666 struct tree *source_tree = NULL;
667 char *conflict_style = NULL;
669 int dwim_new_local_branch = 1;
670 struct option options[] = {
671 OPT__QUIET(&opts.quiet),
672 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
673 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
674 OPT_SET_INT('t', "track", &opts.track, "track",
675 BRANCH_TRACK_EXPLICIT),
676 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
677 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
679 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
681 OPT_BOOLEAN('f', "force", &opts.force, "force"),
682 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
683 OPT_STRING(0, "conflict", &conflict_style, "style",
684 "conflict style (merge or diff3)"),
685 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
686 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
687 "second guess 'git checkout no-such-branch'",
688 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
693 memset(&opts, 0, sizeof(opts));
694 memset(&new, 0, sizeof(new));
697 git_config(git_checkout_config, &opts);
699 opts.track = BRANCH_TRACK_UNSPECIFIED;
701 argc = parse_options(argc, argv, prefix, options, checkout_usage,
702 PARSE_OPT_KEEP_DASHDASH);
704 if (patch_mode && (opts.track > 0 || opts.new_branch
705 || opts.new_branch_log || opts.merge || opts.force))
706 die ("--patch is incompatible with all other options");
708 /* --track without -b should DWIM */
709 if (0 < opts.track && !opts.new_branch) {
710 const char *argv0 = argv[0];
711 if (!argc || !strcmp(argv0, "--"))
712 die ("--track needs a branch name");
713 if (!prefixcmp(argv0, "refs/"))
715 if (!prefixcmp(argv0, "remotes/"))
717 argv0 = strchr(argv0, '/');
718 if (!argv0 || !argv0[1])
719 die ("Missing branch name; try -b");
720 opts.new_branch = argv0 + 1;
723 if (opts.new_orphan_branch) {
725 die("--orphan and -b are mutually exclusive");
727 die("--orphan cannot be used with -t");
728 opts.new_branch = opts.new_orphan_branch;
731 if (conflict_style) {
732 opts.merge = 1; /* implied */
733 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
736 if (opts.force && opts.merge)
737 die("git checkout: -f and -m are incompatible");
740 * case 1: git checkout <ref> -- [<paths>]
742 * <ref> must be a valid tree, everything after the '--' must be
745 * case 2: git checkout -- [<paths>]
747 * everything after the '--' must be paths.
749 * case 3: git checkout <something> [<paths>]
751 * With no paths, if <something> is a commit, that is to
752 * switch to the branch or detach HEAD at it. As a special case,
753 * if <something> is A...B (missing A or B means HEAD but you can
754 * omit at most one side), and if there is a unique merge base
755 * between A and B, A...B names that merge base.
757 * With no paths, if <something> is _not_ a commit, no -t nor -b
758 * was given, and there is a tracking branch whose name is
759 * <something> in one and only one remote, then this is a short-hand
760 * to fork local <something> from that remote tracking branch.
762 * Otherwise <something> shall not be ambiguous.
763 * - If it's *only* a reference, treat it like case (1).
764 * - If it's only a path, treat it like case (2).
769 if (!strcmp(argv[0], "--")) { /* case (2) */
776 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
778 if (!strcmp(arg, "-"))
781 if (get_sha1_mb(arg, rev)) {
782 if (has_dash_dash) /* case (1) */
783 die("invalid reference: %s", arg);
785 dwim_new_local_branch &&
786 opts.track == BRANCH_TRACK_UNSPECIFIED &&
788 !check_filename(NULL, arg) &&
790 const char *remote = unique_tracking_name(arg);
791 if (!remote || get_sha1(remote, rev))
793 opts.new_branch = arg;
795 /* DWIMmed to create local branch */
801 /* we can't end up being in (2) anymore, eat the argument */
806 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
807 setup_branch_path(&new);
809 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
810 resolve_ref(new.path, rev, 1, NULL))
814 parse_commit(new.commit);
815 source_tree = new.commit->tree;
817 source_tree = parse_tree_indirect(rev);
819 if (!source_tree) /* case (1): want a tree */
820 die("reference is not a tree: %s", arg);
821 if (!has_dash_dash) {/* case (3 -> 1) */
823 * Do not complain the most common case
824 * git checkout branch
825 * even if there happen to be a file called 'branch';
826 * it would be extremely annoying.
829 verify_non_filename(NULL, arg);
839 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
840 opts.track = git_branch_track;
843 const char **pathspec = get_pathspec(prefix, argv);
846 die("invalid path specification");
849 return interactive_checkout(new.name, pathspec, &opts);
852 if (opts.new_branch) {
854 die("git checkout: updating paths is incompatible with switching branches.\nDid you intend to checkout '%s' which can not be resolved as commit?", argv[0]);
856 die("git checkout: updating paths is incompatible with switching branches.");
860 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
861 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
863 return checkout_paths(source_tree, pathspec, &opts);
867 return interactive_checkout(new.name, NULL, &opts);
869 if (opts.new_branch) {
870 struct strbuf buf = STRBUF_INIT;
871 if (strbuf_check_branch_ref(&buf, opts.new_branch))
872 die("git checkout: we do not like '%s' as a branch name.",
874 if (!get_sha1(buf.buf, rev))
875 die("git checkout: branch %s already exists", opts.new_branch);
876 strbuf_release(&buf);
879 if (new.name && !new.commit) {
880 die("Cannot switch branch to a non-commit.");
882 if (opts.writeout_stage)
883 die("--ours/--theirs is incompatible with switching branches.");
885 return switch_branches(&opts, &new);