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, "base",
 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.ancestor = old->name;
 444                         o.branch1 = new->name;
 445                         o.branch2 = "local";
 446                         merge_trees(&o, new->commit->tree, work,
 447                                 old->commit->tree, &result);
 448                         ret = reset_tree(new->commit->tree, opts, 0);
 449                         if (ret)
 450                                 return ret;
 451                 }
 452         }
 453
 454         if (write_cache(newfd, active_cache, active_nr) ||
 455             commit_locked_index(lock_file))
 456                 die("unable to write new index file");
 457
 458         if (!opts->force && !opts->quiet)
 459                 show_local_changes(&new->commit->object);
 460
 461         return 0;
 462 }
 463
 464 static void report_tracking(struct branch_info *new)
 465 {
 466         struct strbuf sb = STRBUF_INIT;
 467         struct branch *branch = branch_get(new->name);
 468
 469         if (!format_tracking_info(branch, &sb))
 470                 return;
 471         fputs(sb.buf, stdout);
 472         strbuf_release(&sb);
 473 }
 474
 475 static void detach_advice(const char *old_path, const char *new_name)
 476 {
 477         const char fmt[] =
 478         "Note: checking out '%s'.\n\n"
 479         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 480         "changes and commit them, and you can discard any commits you make in this\n"
 481         "state without impacting any branches by performing another checkout.\n\n"
 482         "If you want to create a new branch to retain commits you create, you may\n"
 483         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 484         "  git checkout -b new_branch_name\n\n";
 485
 486         fprintf(stderr, fmt, new_name);
 487 }
 488
 489 static void update_refs_for_switch(struct checkout_opts *opts,
 490                                    struct branch_info *old,
 491                                    struct branch_info *new)
 492 {
 493         struct strbuf msg = STRBUF_INIT;
 494         const char *old_desc;
 495         if (opts->new_branch) {
 496                 if (!opts->new_orphan_branch)
 497                         create_branch(old->name, opts->new_branch, new->name, 0,
 498                                       opts->new_branch_log, opts->track);
 499                 new->name = opts->new_branch;
 500                 setup_branch_path(new);
 501         }
 502
 503         old_desc = old->name;
 504         if (!old_desc && old->commit)
 505                 old_desc = sha1_to_hex(old->commit->object.sha1);
 506         strbuf_addf(&msg, "checkout: moving from %s to %s",
 507                     old_desc ? old_desc : "(invalid)", new->name);
 508
 509         if (new->path) {
 510                 create_symref("HEAD", new->path, msg.buf);
 511                 if (!opts->quiet) {
 512                         if (old->path && !strcmp(new->path, old->path))
 513                                 fprintf(stderr, "Already on '%s'\n",
 514                                         new->name);
 515                         else
 516                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 517                                         opts->new_branch ? " a new" : "",
 518                                         new->name);
 519                 }
 520         } else if (strcmp(new->name, "HEAD")) {
 521                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 522                            REF_NODEREF, DIE_ON_ERR);
 523                 if (!opts->quiet) {
 524                         if (old->path && advice_detached_head)
 525                                 detach_advice(old->path, new->name);
 526                         describe_detached_head("HEAD is now at", new->commit);
 527                 }
 528         }
 529         remove_branch_state();
 530         strbuf_release(&msg);
 531         if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 532                 report_tracking(new);
 533 }
 534
 535 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 536 {
 537         int ret = 0;
 538         struct branch_info old;
 539         unsigned char rev[20];
 540         int flag;
 541         memset(&old, 0, sizeof(old));
 542         old.path = resolve_ref("HEAD", rev, 0, &flag);
 543         old.commit = lookup_commit_reference_gently(rev, 1);
 544         if (!(flag & REF_ISSYMREF))
 545                 old.path = NULL;
 546
 547         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 548                 old.name = old.path + strlen("refs/heads/");
 549
 550         if (!new->name) {
 551                 new->name = "HEAD";
 552                 new->commit = old.commit;
 553                 if (!new->commit)
 554                         die("You are on a branch yet to be born");
 555                 parse_commit(new->commit);
 556         }
 557
 558         ret = merge_working_tree(opts, &old, new);
 559         if (ret)
 560                 return ret;
 561
 562         /*
 563          * If we were on a detached HEAD, but have now moved to
 564          * a new commit, we want to mention the old commit once more
 565          * to remind the user that it might be lost.
 566          */
 567         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 568                 describe_detached_head("Previous HEAD position was", old.commit);
 569
 570         update_refs_for_switch(opts, &old, new);
 571
 572         ret = post_checkout_hook(old.commit, new->commit, 1);
 573         return ret || opts->writeout_error;
 574 }
 575
 576 static int git_checkout_config(const char *var, const char *value, void *cb)
 577 {
 578         return git_xmerge_config(var, value, cb);
 579 }
 580
 581 static int interactive_checkout(const char *revision, const char **pathspec,
 582                                 struct checkout_opts *opts)
 583 {
 584         return run_add_interactive(revision, "--patch=checkout", pathspec);
 585 }
 586
 587 struct tracking_name_data {
 588         const char *name;
 589         char *remote;
 590         int unique;
 591 };
 592
 593 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 594                                int flags, void *cb_data)
 595 {
 596         struct tracking_name_data *cb = cb_data;
 597         const char *slash;
 598
 599         if (prefixcmp(refname, "refs/remotes/"))
 600                 return 0;
 601         slash = strchr(refname + 13, '/');
 602         if (!slash || strcmp(slash + 1, cb->name))
 603                 return 0;
 604         if (cb->remote) {
 605                 cb->unique = 0;
 606                 return 0;
 607         }
 608         cb->remote = xstrdup(refname);
 609         return 0;
 610 }
 611
 612 static const char *unique_tracking_name(const char *name)
 613 {
 614         struct tracking_name_data cb_data = { name, NULL, 1 };
 615         for_each_ref(check_tracking_name, &cb_data);
 616         if (cb_data.unique)
 617                 return cb_data.remote;
 618         free(cb_data.remote);
 619         return NULL;
 620 }
 621
 622 int cmd_checkout(int argc, const char **argv, const char *prefix)
 623 {
 624         struct checkout_opts opts;
 625         unsigned char rev[20];
 626         const char *arg;
 627         struct branch_info new;
 628         struct tree *source_tree = NULL;
 629         char *conflict_style = NULL;
 630         int patch_mode = 0;
 631         int dwim_new_local_branch = 1;
 632         struct option options[] = {
 633                 OPT__QUIET(&opts.quiet),
 634                 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
 635                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 636                 OPT_SET_INT('t', "track",  &opts.track, "track",
 637                         BRANCH_TRACK_EXPLICIT),
 638                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 639                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 640                             2),
 641                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 642                             3),
 643                 OPT_BOOLEAN('f', "force", &opts.force, "force"),
 644                 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 645                 OPT_STRING(0, "conflict", &conflict_style, "style",
 646                            "conflict style (merge or diff3)"),
 647                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 648                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 649                   "second guess 'git checkout no-such-branch'",
 650                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 651                 OPT_END(),
 652         };
 653         int has_dash_dash;
 654
 655         memset(&opts, 0, sizeof(opts));
 656         memset(&new, 0, sizeof(new));
 657
 658         git_config(git_checkout_config, NULL);
 659
 660         opts.track = BRANCH_TRACK_UNSPECIFIED;
 661
 662         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 663                              PARSE_OPT_KEEP_DASHDASH);
 664
 665         if (patch_mode && (opts.track > 0 || opts.new_branch
 666                            || opts.new_branch_log || opts.merge || opts.force))
 667                 die ("--patch is incompatible with all other options");
 668
 669         /* --track without -b should DWIM */
 670         if (0 < opts.track && !opts.new_branch) {
 671                 const char *argv0 = argv[0];
 672                 if (!argc || !strcmp(argv0, "--"))
 673                         die ("--track needs a branch name");
 674                 if (!prefixcmp(argv0, "refs/"))
 675                         argv0 += 5;
 676                 if (!prefixcmp(argv0, "remotes/"))
 677                         argv0 += 8;
 678                 argv0 = strchr(argv0, '/');
 679                 if (!argv0 || !argv0[1])
 680                         die ("Missing branch name; try -b");
 681                 opts.new_branch = argv0 + 1;
 682         }
 683
 684         if (opts.new_orphan_branch) {
 685                 if (opts.new_branch)
 686                         die("--orphan and -b are mutually exclusive");
 687                 if (opts.track > 0 || opts.new_branch_log)
 688                         die("--orphan cannot be used with -t or -l");
 689                 opts.new_branch = opts.new_orphan_branch;
 690         }
 691
 692         if (conflict_style) {
 693                 opts.merge = 1; /* implied */
 694                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 695         }
 696
 697         if (opts.force && opts.merge)
 698                 die("git checkout: -f and -m are incompatible");
 699
 700         /*
 701          * case 1: git checkout <ref> -- [<paths>]
 702          *
 703          *   <ref> must be a valid tree, everything after the '--' must be
 704          *   a path.
 705          *
 706          * case 2: git checkout -- [<paths>]
 707          *
 708          *   everything after the '--' must be paths.
 709          *
 710          * case 3: git checkout <something> [<paths>]
 711          *
 712          *   With no paths, if <something> is a commit, that is to
 713          *   switch to the branch or detach HEAD at it.  As a special case,
 714          *   if <something> is A...B (missing A or B means HEAD but you can
 715          *   omit at most one side), and if there is a unique merge base
 716          *   between A and B, A...B names that merge base.
 717          *
 718          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 719          *   was given, and there is a tracking branch whose name is
 720          *   <something> in one and only one remote, then this is a short-hand
 721          *   to fork local <something> from that remote tracking branch.
 722          *
 723          *   Otherwise <something> shall not be ambiguous.
 724          *   - If it's *only* a reference, treat it like case (1).
 725          *   - If it's only a path, treat it like case (2).
 726          *   - else: fail.
 727          *
 728          */
 729         if (argc) {
 730                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 731                         argv++;
 732                         argc--;
 733                         goto no_reference;
 734                 }
 735
 736                 arg = argv[0];
 737                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 738
 739                 if (!strcmp(arg, "-"))
 740                         arg = "@{-1}";
 741
 742                 if (get_sha1_mb(arg, rev)) {
 743                         if (has_dash_dash)          /* case (1) */
 744                                 die("invalid reference: %s", arg);
 745                         if (!patch_mode &&
 746                             dwim_new_local_branch &&
 747                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 748                             !opts.new_branch &&
 749                             !check_filename(NULL, arg) &&
 750                             argc == 1) {
 751                                 const char *remote = unique_tracking_name(arg);
 752                                 if (!remote || get_sha1(remote, rev))
 753                                         goto no_reference;
 754                                 opts.new_branch = arg;
 755                                 arg = remote;
 756                                 /* DWIMmed to create local branch */
 757                         }
 758                         else
 759                                 goto no_reference;
 760                 }
 761
 762                 /* we can't end up being in (2) anymore, eat the argument */
 763                 argv++;
 764                 argc--;
 765
 766                 new.name = arg;
 767                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 768                         setup_branch_path(&new);
 769
 770                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 771                             resolve_ref(new.path, rev, 1, NULL))
 772                                 ;
 773                         else
 774                                 new.path = NULL;
 775                         parse_commit(new.commit);
 776                         source_tree = new.commit->tree;
 777                 } else
 778                         source_tree = parse_tree_indirect(rev);
 779
 780                 if (!source_tree)                   /* case (1): want a tree */
 781                         die("reference is not a tree: %s", arg);
 782                 if (!has_dash_dash) {/* case (3 -> 1) */
 783                         /*
 784                          * Do not complain the most common case
 785                          *      git checkout branch
 786                          * even if there happen to be a file called 'branch';
 787                          * it would be extremely annoying.
 788                          */
 789                         if (argc)
 790                                 verify_non_filename(NULL, arg);
 791                 }
 792                 else {
 793                         argv++;
 794                         argc--;
 795                 }
 796         }
 797
 798 no_reference:
 799
 800         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 801                 opts.track = git_branch_track;
 802
 803         if (argc) {
 804                 const char **pathspec = get_pathspec(prefix, argv);
 805
 806                 if (!pathspec)
 807                         die("invalid path specification");
 808
 809                 if (patch_mode)
 810                         return interactive_checkout(new.name, pathspec, &opts);
 811
 812                 /* Checkout paths */
 813                 if (opts.new_branch) {
 814                         if (argc == 1) {
 815                                 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]);
 816                         } else {
 817                                 die("git checkout: updating paths is incompatible with switching branches.");
 818                         }
 819                 }
 820
 821                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 822                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 823
 824                 return checkout_paths(source_tree, pathspec, &opts);
 825         }
 826
 827         if (patch_mode)
 828                 return interactive_checkout(new.name, NULL, &opts);
 829
 830         if (opts.new_branch) {
 831                 struct strbuf buf = STRBUF_INIT;
 832                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 833                         die("git checkout: we do not like '%s' as a branch name.",
 834                             opts.new_branch);
 835                 if (!get_sha1(buf.buf, rev))
 836                         die("git checkout: branch %s already exists", opts.new_branch);
 837                 strbuf_release(&buf);
 838         }
 839
 840         if (new.name && !new.commit) {
 841                 die("Cannot switch branch to a non-commit.");
 842         }
 843         if (opts.writeout_stage)
 844                 die("--ours/--theirs is incompatible with switching branches.");
 845
 846         return switch_branches(&opts, &new);
 847 }