builtin/checkout.c

   1 #include "cache.h"
   2 #include "builtin.h"
   3 #include "parse-options.h"
   4 #include "refs.h"
   5 #include "commit.h"
   6 #include "tree.h"
   7 #include "tree-walk.h"
   8 #include "cache-tree.h"
   9 #include "unpack-trees.h"
  10 #include "dir.h"
  11 #include "run-command.h"
  12 #include "merge-recursive.h"
  13 #include "branch.h"
  14 #include "diff.h"
  15 #include "revision.h"
  16 #include "remote.h"
  17 #include "blob.h"
  18 #include "xdiff-interface.h"
  19 #include "ll-merge.h"
  20 #include "resolve-undo.h"
  21
  22 static const char * const checkout_usage[] = {
  23         "git checkout [options] <branch>",
  24         "git checkout [options] [<branch>] -- <file>...",
  25         NULL,
  26 };
  27
  28 struct checkout_opts {
  29         int quiet;
  30         int merge;
  31         int force;
  32         int writeout_stage;
  33         int writeout_error;
  34
  35         const char *new_branch;
  36         const char *new_orphan_branch;
  37         int new_branch_log;
  38         enum branch_track track;
  39 };
  40
  41 static int post_checkout_hook(struct commit *old, struct commit *new,
  42                               int changed)
  43 {
  44         return run_hook(NULL, "post-checkout",
  45                         sha1_to_hex(old ? old->object.sha1 : null_sha1),
  46                         sha1_to_hex(new ? new->object.sha1 : null_sha1),
  47                         changed ? "1" : "0", NULL);
  48         /* "new" can be NULL when checking out from the index before
  49            a commit exists. */
  50
  51 }
  52
  53 static int update_some(const unsigned char *sha1, const char *base, int baselen,
  54                 const char *pathname, unsigned mode, int stage, void *context)
  55 {
  56         int len;
  57         struct cache_entry *ce;
  58
  59         if (S_ISDIR(mode))
  60                 return READ_TREE_RECURSIVE;
  61
  62         len = baselen + strlen(pathname);
  63         ce = xcalloc(1, cache_entry_size(len));
  64         hashcpy(ce->sha1, sha1);
  65         memcpy(ce->name, base, baselen);
  66         memcpy(ce->name + baselen, pathname, len - baselen);
  67         ce->ce_flags = create_ce_flags(len, 0);
  68         ce->ce_mode = create_ce_mode(mode);
  69         add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  70         return 0;
  71 }
  72
  73 static int read_tree_some(struct tree *tree, const char **pathspec)
  74 {
  75         read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  76
  77         /* update the index with the given tree's info
  78          * for all args, expanding wildcards, and exit
  79          * with any non-zero return code.
  80          */
  81         return 0;
  82 }
  83
  84 static int skip_same_name(struct cache_entry *ce, int pos)
  85 {
  86         while (++pos < active_nr &&
  87                !strcmp(active_cache[pos]->name, ce->name))
  88                 ; /* skip */
  89         return pos;
  90 }
  91
  92 static int check_stage(int stage, struct cache_entry *ce, int pos)
  93 {
  94         while (pos < active_nr &&
  95                !strcmp(active_cache[pos]->name, ce->name)) {
  96                 if (ce_stage(active_cache[pos]) == stage)
  97                         return 0;
  98                 pos++;
  99         }
 100         return error("path '%s' does not have %s version",
 101                      ce->name,
 102                      (stage == 2) ? "our" : "their");
 103 }
 104
 105 static int check_all_stages(struct cache_entry *ce, int pos)
 106 {
 107         if (ce_stage(ce) != 1 ||
 108             active_nr <= pos + 2 ||
 109             strcmp(active_cache[pos+1]->name, ce->name) ||
 110             ce_stage(active_cache[pos+1]) != 2 ||
 111             strcmp(active_cache[pos+2]->name, ce->name) ||
 112             ce_stage(active_cache[pos+2]) != 3)
 113                 return error("path '%s' does not have all three versions",
 114                              ce->name);
 115         return 0;
 116 }
 117
 118 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 119                           struct checkout *state)
 120 {
 121         while (pos < active_nr &&
 122                !strcmp(active_cache[pos]->name, ce->name)) {
 123                 if (ce_stage(active_cache[pos]) == stage)
 124                         return checkout_entry(active_cache[pos], state, NULL);
 125                 pos++;
 126         }
 127         return error("path '%s' does not have %s version",
 128                      ce->name,
 129                      (stage == 2) ? "our" : "their");
 130 }
 131
 132 static int checkout_merged(int pos, struct checkout *state)
 133 {
 134         struct cache_entry *ce = active_cache[pos];
 135         const char *path = ce->name;
 136         mmfile_t ancestor, ours, theirs;
 137         int status;
 138         unsigned char sha1[20];
 139         mmbuffer_t result_buf;
 140
 141         if (ce_stage(ce) != 1 ||
 142             active_nr <= pos + 2 ||
 143             strcmp(active_cache[pos+1]->name, path) ||
 144             ce_stage(active_cache[pos+1]) != 2 ||
 145             strcmp(active_cache[pos+2]->name, path) ||
 146             ce_stage(active_cache[pos+2]) != 3)
 147                 return error("path '%s' does not have all 3 versions", path);
 148
 149         read_mmblob(&ancestor, active_cache[pos]->sha1);
 150         read_mmblob(&ours, active_cache[pos+1]->sha1);
 151         read_mmblob(&theirs, active_cache[pos+2]->sha1);
 152
 153         status = ll_merge(&result_buf, path, &ancestor,
 154                           &ours, "ours", &theirs, "theirs", 0);
 155         free(ancestor.ptr);
 156         free(ours.ptr);
 157         free(theirs.ptr);
 158         if (status < 0 || !result_buf.ptr) {
 159                 free(result_buf.ptr);
 160                 return error("path '%s': cannot merge", path);
 161         }
 162
 163         /*
 164          * NEEDSWORK:
 165          * There is absolutely no reason to write this as a blob object
 166          * and create a phony cache entry just to leak.  This hack is
 167          * primarily to get to the write_entry() machinery that massages
 168          * the contents to work-tree format and writes out which only
 169          * allows it for a cache entry.  The code in write_entry() needs
 170          * to be refactored to allow us to feed a <buffer, size, mode>
 171          * instead of a cache entry.  Such a refactoring would help
 172          * merge_recursive as well (it also writes the merge result to the
 173          * object database even when it may contain conflicts).
 174          */
 175         if (write_sha1_file(result_buf.ptr, result_buf.size,
 176                             blob_type, sha1))
 177                 die("Unable to add merge result for '%s'", path);
 178         ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
 179                               sha1,
 180                               path, 2, 0);
 181         if (!ce)
 182                 die("make_cache_entry failed for path '%s'", path);
 183         status = checkout_entry(ce, state, NULL);
 184         return status;
 185 }
 186
 187 static int checkout_paths(struct tree *source_tree, const char **pathspec,
 188                           struct checkout_opts *opts)
 189 {
 190         int pos;
 191         struct checkout state;
 192         static char *ps_matched;
 193         unsigned char rev[20];
 194         int flag;
 195         struct commit *head;
 196         int errs = 0;
 197         int stage = opts->writeout_stage;
 198         int merge = opts->merge;
 199         int newfd;
 200         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 201
 202         newfd = hold_locked_index(lock_file, 1);
 203         if (read_cache_preload(pathspec) < 0)
 204                 return error("corrupt index file");
 205
 206         if (source_tree)
 207                 read_tree_some(source_tree, pathspec);
 208
 209         for (pos = 0; pathspec[pos]; pos++)
 210                 ;
 211         ps_matched = xcalloc(1, pos);
 212
 213         for (pos = 0; pos < active_nr; pos++) {
 214                 struct cache_entry *ce = active_cache[pos];
 215                 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 216         }
 217
 218         if (report_path_error(ps_matched, pathspec, 0))
 219                 return 1;
 220
 221         /* "checkout -m path" to recreate conflicted state */
 222         if (opts->merge)
 223                 unmerge_cache(pathspec);
 224
 225         /* Any unmerged paths? */
 226         for (pos = 0; pos < active_nr; pos++) {
 227                 struct cache_entry *ce = active_cache[pos];
 228                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 229                         if (!ce_stage(ce))
 230                                 continue;
 231                         if (opts->force) {
 232                                 warning("path '%s' is unmerged", ce->name);
 233                         } else if (stage) {
 234                                 errs |= check_stage(stage, ce, pos);
 235                         } else if (opts->merge) {
 236                                 errs |= check_all_stages(ce, pos);
 237                         } else {
 238                                 errs = 1;
 239                                 error("path '%s' is unmerged", ce->name);
 240                         }
 241                         pos = skip_same_name(ce, pos) - 1;
 242                 }
 243         }
 244         if (errs)
 245                 return 1;
 246
 247         /* Now we are committed to check them out */
 248         memset(&state, 0, sizeof(state));
 249         state.force = 1;
 250         state.refresh_cache = 1;
 251         for (pos = 0; pos < active_nr; pos++) {
 252                 struct cache_entry *ce = active_cache[pos];
 253                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 254                         if (!ce_stage(ce)) {
 255                                 errs |= checkout_entry(ce, &state, NULL);
 256                                 continue;
 257                         }
 258                         if (stage)
 259                                 errs |= checkout_stage(stage, ce, pos, &state);
 260                         else if (merge)
 261                                 errs |= checkout_merged(pos, &state);
 262                         pos = skip_same_name(ce, pos) - 1;
 263                 }
 264         }
 265
 266         if (write_cache(newfd, active_cache, active_nr) ||
 267             commit_locked_index(lock_file))
 268                 die("unable to write new index file");
 269
 270         resolve_ref("HEAD", rev, 0, &flag);
 271         head = lookup_commit_reference_gently(rev, 1);
 272
 273         errs |= post_checkout_hook(head, head, 0);
 274         return errs;
 275 }
 276
 277 static void show_local_changes(struct object *head)
 278 {
 279         struct rev_info rev;
 280         /* I think we want full paths, even if we're in a subdirectory. */
 281         init_revisions(&rev, NULL);
 282         rev.abbrev = 0;
 283         rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 284         if (diff_setup_done(&rev.diffopt) < 0)
 285                 die("diff_setup_done failed");
 286         add_pending_object(&rev, head, NULL);
 287         run_diff_index(&rev, 0);
 288 }
 289
 290 static void describe_detached_head(char *msg, struct commit *commit)
 291 {
 292         struct strbuf sb = STRBUF_INIT;
 293         struct pretty_print_context ctx = {0};
 294         parse_commit(commit);
 295         pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
 296         fprintf(stderr, "%s %s... %s\n", msg,
 297                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 298         strbuf_release(&sb);
 299 }
 300
 301 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 302 {
 303         struct unpack_trees_options opts;
 304         struct tree_desc tree_desc;
 305
 306         memset(&opts, 0, sizeof(opts));
 307         opts.head_idx = -1;
 308         opts.update = worktree;
 309         opts.skip_unmerged = !worktree;
 310         opts.reset = 1;
 311         opts.merge = 1;
 312         opts.fn = oneway_merge;
 313         opts.verbose_update = !o->quiet;
 314         opts.src_index = &the_index;
 315         opts.dst_index = &the_index;
 316         parse_tree(tree);
 317         init_tree_desc(&tree_desc, tree->buffer, tree->size);
 318         switch (unpack_trees(1, &tree_desc, &opts)) {
 319         case -2:
 320                 o->writeout_error = 1;
 321                 /*
 322                  * We return 0 nevertheless, as the index is all right
 323                  * and more importantly we have made best efforts to
 324                  * update paths in the work tree, and we cannot revert
 325                  * them.
 326                  */
 327         case 0:
 328                 return 0;
 329         default:
 330                 return 128;
 331         }
 332 }
 333
 334 struct branch_info {
 335         const char *name; /* The short name used */
 336         const char *path; /* The full name of a real branch */
 337         struct commit *commit; /* The named commit */
 338 };
 339
 340 static void setup_branch_path(struct branch_info *branch)
 341 {
 342         struct strbuf buf = STRBUF_INIT;
 343
 344         strbuf_branchname(&buf, branch->name);
 345         if (strcmp(buf.buf, branch->name))
 346                 branch->name = xstrdup(buf.buf);
 347         strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 348         branch->path = strbuf_detach(&buf, NULL);
 349 }
 350
 351 static int merge_working_tree(struct checkout_opts *opts,
 352                               struct branch_info *old, struct branch_info *new)
 353 {
 354         int ret;
 355         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 356         int newfd = hold_locked_index(lock_file, 1);
 357
 358         if (read_cache_preload(NULL) < 0)
 359                 return error("corrupt index file");
 360
 361         resolve_undo_clear();
 362         if (opts->force) {
 363                 ret = reset_tree(new->commit->tree, opts, 1);
 364                 if (ret)
 365                         return ret;
 366         } else {
 367                 struct tree_desc trees[2];
 368                 struct tree *tree;
 369                 struct unpack_trees_options topts;
 370
 371                 memset(&topts, 0, sizeof(topts));
 372                 topts.head_idx = -1;
 373                 topts.src_index = &the_index;
 374                 topts.dst_index = &the_index;
 375
 376                 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
 377
 378                 refresh_cache(REFRESH_QUIET);
 379
 380                 if (unmerged_cache()) {
 381                         error("you need to resolve your current index first");
 382                         return 1;
 383                 }
 384
 385                 /* 2-way merge to the new branch */
 386                 topts.initial_checkout = is_cache_unborn();
 387                 topts.update = 1;
 388                 topts.merge = 1;
 389                 topts.gently = opts->merge && old->commit;
 390                 topts.verbose_update = !opts->quiet;
 391                 topts.fn = twoway_merge;
 392                 topts.dir = xcalloc(1, sizeof(*topts.dir));
 393                 topts.dir->flags |= DIR_SHOW_IGNORED;
 394                 topts.dir->exclude_per_dir = ".gitignore";
 395                 tree = parse_tree_indirect(old->commit ?
 396                                            old->commit->object.sha1 :
 397                                            (unsigned char *)EMPTY_TREE_SHA1_BIN);
 398                 init_tree_desc(&trees[0], tree->buffer, tree->size);
 399                 tree = parse_tree_indirect(new->commit->object.sha1);
 400                 init_tree_desc(&trees[1], tree->buffer, tree->size);
 401
 402                 ret = unpack_trees(2, trees, &topts);
 403                 if (ret == -1) {
 404                         /*
 405                          * Unpack couldn't do a trivial merge; either
 406                          * give up or do a real merge, depending on
 407                          * whether the merge flag was used.
 408                          */
 409                         struct tree *result;
 410                         struct tree *work;
 411                         struct merge_options o;
 412                         if (!opts->merge)
 413                                 return 1;
 414
 415                         /*
 416                          * Without old->commit, the below is the same as
 417                          * the two-tree unpack we already tried and failed.
 418                          */
 419                         if (!old->commit)
 420                                 return 1;
 421
 422                         /* Do more real merge */
 423
 424                         /*
 425                          * We update the index fully, then write the
 426                          * tree from the index, then merge the new
 427                          * branch with the current tree, with the old
 428                          * branch as the base. Then we reset the index
 429                          * (but not the working tree) to the new
 430                          * branch, leaving the working tree as the
 431                          * merged version, but skipping unmerged
 432                          * entries in the index.
 433                          */
 434
 435                         add_files_to_cache(NULL, NULL, 0);
 436                         init_merge_options(&o);
 437                         o.verbosity = 0;
 438                         work = write_tree_from_memory(&o);
 439
 440                         ret = reset_tree(new->commit->tree, opts, 1);
 441                         if (ret)
 442                                 return ret;
 443                         o.branch1 = new->name;
 444                         o.branch2 = "local";
 445                         merge_trees(&o, new->commit->tree, work,
 446                                 old->commit->tree, &result);
 447                         ret = reset_tree(new->commit->tree, opts, 0);
 448                         if (ret)
 449                                 return ret;
 450                 }
 451         }
 452
 453         if (write_cache(newfd, active_cache, active_nr) ||
 454             commit_locked_index(lock_file))
 455                 die("unable to write new index file");
 456
 457         if (!opts->force && !opts->quiet)
 458                 show_local_changes(&new->commit->object);
 459
 460         return 0;
 461 }
 462
 463 static void report_tracking(struct branch_info *new)
 464 {
 465         struct strbuf sb = STRBUF_INIT;
 466         struct branch *branch = branch_get(new->name);
 467
 468         if (!format_tracking_info(branch, &sb))
 469                 return;
 470         fputs(sb.buf, stdout);
 471         strbuf_release(&sb);
 472 }
 473
 474 static void detach_advice(const char *old_path, const char *new_name)
 475 {
 476         const char fmt[] =
 477         "Note: checking out '%s'.\n\n"
 478         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 479         "changes and commit them, and you can discard any commits you make in this\n"
 480         "state without impacting any branches by performing another checkout.\n\n"
 481         "If you want to create a new branch to retain commits you create, you may\n"
 482         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 483         "  git checkout -b new_branch_name\n\n";
 484
 485         fprintf(stderr, fmt, new_name);
 486 }
 487
 488 static void update_refs_for_switch(struct checkout_opts *opts,
 489                                    struct branch_info *old,
 490                                    struct branch_info *new)
 491 {
 492         struct strbuf msg = STRBUF_INIT;
 493         const char *old_desc;
 494         if (opts->new_branch) {
 495                 if (!opts->new_orphan_branch)
 496                         create_branch(old->name, opts->new_branch, new->name, 0,
 497                                       opts->new_branch_log, opts->track);
 498                 new->name = opts->new_branch;
 499                 setup_branch_path(new);
 500         }
 501
 502         old_desc = old->name;
 503         if (!old_desc && old->commit)
 504                 old_desc = sha1_to_hex(old->commit->object.sha1);
 505         strbuf_addf(&msg, "checkout: moving from %s to %s",
 506                     old_desc ? old_desc : "(invalid)", new->name);
 507
 508         if (new->path) {
 509                 create_symref("HEAD", new->path, msg.buf);
 510                 if (!opts->quiet) {
 511                         if (old->path && !strcmp(new->path, old->path))
 512                                 fprintf(stderr, "Already on '%s'\n",
 513                                         new->name);
 514                         else
 515                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 516                                         opts->new_branch ? " a new" : "",
 517                                         new->name);
 518                 }
 519         } else if (strcmp(new->name, "HEAD")) {
 520                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 521                            REF_NODEREF, DIE_ON_ERR);
 522                 if (!opts->quiet) {
 523                         if (old->path && advice_detached_head)
 524                                 detach_advice(old->path, new->name);
 525                         describe_detached_head("HEAD is now at", new->commit);
 526                 }
 527         }
 528         remove_branch_state();
 529         strbuf_release(&msg);
 530         if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 531                 report_tracking(new);
 532 }
 533
 534 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 535 {
 536         int ret = 0;
 537         struct branch_info old;
 538         unsigned char rev[20];
 539         int flag;
 540         memset(&old, 0, sizeof(old));
 541         old.path = resolve_ref("HEAD", rev, 0, &flag);
 542         old.commit = lookup_commit_reference_gently(rev, 1);
 543         if (!(flag & REF_ISSYMREF))
 544                 old.path = NULL;
 545
 546         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 547                 old.name = old.path + strlen("refs/heads/");
 548
 549         if (!new->name) {
 550                 new->name = "HEAD";
 551                 new->commit = old.commit;
 552                 if (!new->commit)
 553                         die("You are on a branch yet to be born");
 554                 parse_commit(new->commit);
 555         }
 556
 557         ret = merge_working_tree(opts, &old, new);
 558         if (ret)
 559                 return ret;
 560
 561         /*
 562          * If we were on a detached HEAD, but have now moved to
 563          * a new commit, we want to mention the old commit once more
 564          * to remind the user that it might be lost.
 565          */
 566         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 567                 describe_detached_head("Previous HEAD position was", old.commit);
 568
 569         update_refs_for_switch(opts, &old, new);
 570
 571         ret = post_checkout_hook(old.commit, new->commit, 1);
 572         return ret || opts->writeout_error;
 573 }
 574
 575 static int git_checkout_config(const char *var, const char *value, void *cb)
 576 {
 577         return git_xmerge_config(var, value, cb);
 578 }
 579
 580 static int interactive_checkout(const char *revision, const char **pathspec,
 581                                 struct checkout_opts *opts)
 582 {
 583         return run_add_interactive(revision, "--patch=checkout", pathspec);
 584 }
 585
 586 struct tracking_name_data {
 587         const char *name;
 588         char *remote;
 589         int unique;
 590 };
 591
 592 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 593                                int flags, void *cb_data)
 594 {
 595         struct tracking_name_data *cb = cb_data;
 596         const char *slash;
 597
 598         if (prefixcmp(refname, "refs/remotes/"))
 599                 return 0;
 600         slash = strchr(refname + 13, '/');
 601         if (!slash || strcmp(slash + 1, cb->name))
 602                 return 0;
 603         if (cb->remote) {
 604                 cb->unique = 0;
 605                 return 0;
 606         }
 607         cb->remote = xstrdup(refname);
 608         return 0;
 609 }
 610
 611 static const char *unique_tracking_name(const char *name)
 612 {
 613         struct tracking_name_data cb_data = { name, NULL, 1 };
 614         for_each_ref(check_tracking_name, &cb_data);
 615         if (cb_data.unique)
 616                 return cb_data.remote;
 617         free(cb_data.remote);
 618         return NULL;
 619 }
 620
 621 int cmd_checkout(int argc, const char **argv, const char *prefix)
 622 {
 623         struct checkout_opts opts;
 624         unsigned char rev[20];
 625         const char *arg;
 626         struct branch_info new;
 627         struct tree *source_tree = NULL;
 628         char *conflict_style = NULL;
 629         int patch_mode = 0;
 630         int dwim_new_local_branch = 1;
 631         struct option options[] = {
 632                 OPT__QUIET(&opts.quiet),
 633                 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
 634                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 635                 OPT_SET_INT('t', "track",  &opts.track, "track",
 636                         BRANCH_TRACK_EXPLICIT),
 637                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 638                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 639                             2),
 640                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 641                             3),
 642                 OPT_BOOLEAN('f', "force", &opts.force, "force"),
 643                 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 644                 OPT_STRING(0, "conflict", &conflict_style, "style",
 645                            "conflict style (merge or diff3)"),
 646                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 647                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 648                   "second guess 'git checkout no-such-branch'",
 649                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 650                 OPT_END(),
 651         };
 652         int has_dash_dash;
 653
 654         memset(&opts, 0, sizeof(opts));
 655         memset(&new, 0, sizeof(new));
 656
 657         git_config(git_checkout_config, NULL);
 658
 659         opts.track = BRANCH_TRACK_UNSPECIFIED;
 660
 661         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 662                              PARSE_OPT_KEEP_DASHDASH);
 663
 664         if (patch_mode && (opts.track > 0 || opts.new_branch
 665                            || opts.new_branch_log || opts.merge || opts.force))
 666                 die ("--patch is incompatible with all other options");
 667
 668         /* --track without -b should DWIM */
 669         if (0 < opts.track && !opts.new_branch) {
 670                 const char *argv0 = argv[0];
 671                 if (!argc || !strcmp(argv0, "--"))
 672                         die ("--track needs a branch name");
 673                 if (!prefixcmp(argv0, "refs/"))
 674                         argv0 += 5;
 675                 if (!prefixcmp(argv0, "remotes/"))
 676                         argv0 += 8;
 677                 argv0 = strchr(argv0, '/');
 678                 if (!argv0 || !argv0[1])
 679                         die ("Missing branch name; try -b");
 680                 opts.new_branch = argv0 + 1;
 681         }
 682
 683         if (opts.new_orphan_branch) {
 684                 if (opts.new_branch)
 685                         die("--orphan and -b are mutually exclusive");
 686                 if (opts.track > 0 || opts.new_branch_log)
 687                         die("--orphan cannot be used with -t or -l");
 688                 opts.new_branch = opts.new_orphan_branch;
 689         }
 690
 691         if (conflict_style) {
 692                 opts.merge = 1; /* implied */
 693                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 694         }
 695
 696         if (opts.force && opts.merge)
 697                 die("git checkout: -f and -m are incompatible");
 698
 699         /*
 700          * case 1: git checkout <ref> -- [<paths>]
 701          *
 702          *   <ref> must be a valid tree, everything after the '--' must be
 703          *   a path.
 704          *
 705          * case 2: git checkout -- [<paths>]
 706          *
 707          *   everything after the '--' must be paths.
 708          *
 709          * case 3: git checkout <something> [<paths>]
 710          *
 711          *   With no paths, if <something> is a commit, that is to
 712          *   switch to the branch or detach HEAD at it.  As a special case,
 713          *   if <something> is A...B (missing A or B means HEAD but you can
 714          *   omit at most one side), and if there is a unique merge base
 715          *   between A and B, A...B names that merge base.
 716          *
 717          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 718          *   was given, and there is a tracking branch whose name is
 719          *   <something> in one and only one remote, then this is a short-hand
 720          *   to fork local <something> from that remote tracking branch.
 721          *
 722          *   Otherwise <something> shall not be ambiguous.
 723          *   - If it's *only* a reference, treat it like case (1).
 724          *   - If it's only a path, treat it like case (2).
 725          *   - else: fail.
 726          *
 727          */
 728         if (argc) {
 729                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 730                         argv++;
 731                         argc--;
 732                         goto no_reference;
 733                 }
 734
 735                 arg = argv[0];
 736                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 737
 738                 if (!strcmp(arg, "-"))
 739                         arg = "@{-1}";
 740
 741                 if (get_sha1_mb(arg, rev)) {
 742                         if (has_dash_dash)          /* case (1) */
 743                                 die("invalid reference: %s", arg);
 744                         if (!patch_mode &&
 745                             dwim_new_local_branch &&
 746                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 747                             !opts.new_branch &&
 748                             !check_filename(NULL, arg) &&
 749                             argc == 1) {
 750                                 const char *remote = unique_tracking_name(arg);
 751                                 if (!remote || get_sha1(remote, rev))
 752                                         goto no_reference;
 753                                 opts.new_branch = arg;
 754                                 arg = remote;
 755                                 /* DWIMmed to create local branch */
 756                         }
 757                         else
 758                                 goto no_reference;
 759                 }
 760
 761                 /* we can't end up being in (2) anymore, eat the argument */
 762                 argv++;
 763                 argc--;
 764
 765                 new.name = arg;
 766                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 767                         setup_branch_path(&new);
 768
 769                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 770                             resolve_ref(new.path, rev, 1, NULL))
 771                                 ;
 772                         else
 773                                 new.path = NULL;
 774                         parse_commit(new.commit);
 775                         source_tree = new.commit->tree;
 776                 } else
 777                         source_tree = parse_tree_indirect(rev);
 778
 779                 if (!source_tree)                   /* case (1): want a tree */
 780                         die("reference is not a tree: %s", arg);
 781                 if (!has_dash_dash) {/* case (3 -> 1) */
 782                         /*
 783                          * Do not complain the most common case
 784                          *      git checkout branch
 785                          * even if there happen to be a file called 'branch';
 786                          * it would be extremely annoying.
 787                          */
 788                         if (argc)
 789                                 verify_non_filename(NULL, arg);
 790                 }
 791                 else {
 792                         argv++;
 793                         argc--;
 794                 }
 795         }
 796
 797 no_reference:
 798
 799         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 800                 opts.track = git_branch_track;
 801
 802         if (argc) {
 803                 const char **pathspec = get_pathspec(prefix, argv);
 804
 805                 if (!pathspec)
 806                         die("invalid path specification");
 807
 808                 if (patch_mode)
 809                         return interactive_checkout(new.name, pathspec, &opts);
 810
 811                 /* Checkout paths */
 812                 if (opts.new_branch) {
 813                         if (argc == 1) {
 814                                 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]);
 815                         } else {
 816                                 die("git checkout: updating paths is incompatible with switching branches.");
 817                         }
 818                 }
 819
 820                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 821                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 822
 823                 return checkout_paths(source_tree, pathspec, &opts);
 824         }
 825
 826         if (patch_mode)
 827                 return interactive_checkout(new.name, NULL, &opts);
 828
 829         if (opts.new_branch) {
 830                 struct strbuf buf = STRBUF_INIT;
 831                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 832                         die("git checkout: we do not like '%s' as a branch name.",
 833                             opts.new_branch);
 834                 if (!get_sha1(buf.buf, rev))
 835                         die("git checkout: branch %s already exists", opts.new_branch);
 836                 strbuf_release(&buf);
 837         }
 838
 839         if (new.name && !new.commit) {
 840                 die("Cannot switch branch to a non-commit.");
 841         }
 842         if (opts.writeout_stage)
 843                 die("--ours/--theirs is incompatible with switching branches.");
 844
 845         return switch_branches(&opts, &new);
 846 }