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 #include "submodule.h"
  22
  23 static const char * const checkout_usage[] = {
  24         "git checkout [options] <branch>",
  25         "git checkout [options] [<branch>] -- <file>...",
  26         NULL,
  27 };
  28
  29 struct checkout_opts {
  30         int quiet;
  31         int merge;
  32         int force;
  33         int force_detach;
  34         int writeout_stage;
  35         int writeout_error;
  36
  37         /* not set by parse_options */
  38         int branch_exists;
  39
  40         const char *new_branch;
  41         const char *new_branch_force;
  42         const char *new_orphan_branch;
  43         int new_branch_log;
  44         enum branch_track track;
  45         struct diff_options diff_options;
  46 };
  47
  48 static int post_checkout_hook(struct commit *old, struct commit *new,
  49                               int changed)
  50 {
  51         return run_hook(NULL, "post-checkout",
  52                         sha1_to_hex(old ? old->object.sha1 : null_sha1),
  53                         sha1_to_hex(new ? new->object.sha1 : null_sha1),
  54                         changed ? "1" : "0", NULL);
  55         /* "new" can be NULL when checking out from the index before
  56            a commit exists. */
  57
  58 }
  59
  60 static int update_some(const unsigned char *sha1, const char *base, int baselen,
  61                 const char *pathname, unsigned mode, int stage, void *context)
  62 {
  63         int len;
  64         struct cache_entry *ce;
  65
  66         if (S_ISDIR(mode))
  67                 return READ_TREE_RECURSIVE;
  68
  69         len = baselen + strlen(pathname);
  70         ce = xcalloc(1, cache_entry_size(len));
  71         hashcpy(ce->sha1, sha1);
  72         memcpy(ce->name, base, baselen);
  73         memcpy(ce->name + baselen, pathname, len - baselen);
  74         ce->ce_flags = create_ce_flags(len, 0);
  75         ce->ce_mode = create_ce_mode(mode);
  76         add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  77         return 0;
  78 }
  79
  80 static int read_tree_some(struct tree *tree, const char **pathspec)
  81 {
  82         read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  83
  84         /* update the index with the given tree's info
  85          * for all args, expanding wildcards, and exit
  86          * with any non-zero return code.
  87          */
  88         return 0;
  89 }
  90
  91 static int skip_same_name(struct cache_entry *ce, int pos)
  92 {
  93         while (++pos < active_nr &&
  94                !strcmp(active_cache[pos]->name, ce->name))
  95                 ; /* skip */
  96         return pos;
  97 }
  98
  99 static int check_stage(int stage, struct cache_entry *ce, int pos)
 100 {
 101         while (pos < active_nr &&
 102                !strcmp(active_cache[pos]->name, ce->name)) {
 103                 if (ce_stage(active_cache[pos]) == stage)
 104                         return 0;
 105                 pos++;
 106         }
 107         return error("path '%s' does not have %s version",
 108                      ce->name,
 109                      (stage == 2) ? "our" : "their");
 110 }
 111
 112 static int check_all_stages(struct cache_entry *ce, int pos)
 113 {
 114         if (ce_stage(ce) != 1 ||
 115             active_nr <= pos + 2 ||
 116             strcmp(active_cache[pos+1]->name, ce->name) ||
 117             ce_stage(active_cache[pos+1]) != 2 ||
 118             strcmp(active_cache[pos+2]->name, ce->name) ||
 119             ce_stage(active_cache[pos+2]) != 3)
 120                 return error("path '%s' does not have all three versions",
 121                              ce->name);
 122         return 0;
 123 }
 124
 125 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 126                           struct checkout *state)
 127 {
 128         while (pos < active_nr &&
 129                !strcmp(active_cache[pos]->name, ce->name)) {
 130                 if (ce_stage(active_cache[pos]) == stage)
 131                         return checkout_entry(active_cache[pos], state, NULL);
 132                 pos++;
 133         }
 134         return error("path '%s' does not have %s version",
 135                      ce->name,
 136                      (stage == 2) ? "our" : "their");
 137 }
 138
 139 static int checkout_merged(int pos, struct checkout *state)
 140 {
 141         struct cache_entry *ce = active_cache[pos];
 142         const char *path = ce->name;
 143         mmfile_t ancestor, ours, theirs;
 144         int status;
 145         unsigned char sha1[20];
 146         mmbuffer_t result_buf;
 147
 148         if (ce_stage(ce) != 1 ||
 149             active_nr <= pos + 2 ||
 150             strcmp(active_cache[pos+1]->name, path) ||
 151             ce_stage(active_cache[pos+1]) != 2 ||
 152             strcmp(active_cache[pos+2]->name, path) ||
 153             ce_stage(active_cache[pos+2]) != 3)
 154                 return error("path '%s' does not have all 3 versions", path);
 155
 156         read_mmblob(&ancestor, active_cache[pos]->sha1);
 157         read_mmblob(&ours, active_cache[pos+1]->sha1);
 158         read_mmblob(&theirs, active_cache[pos+2]->sha1);
 159
 160         /*
 161          * NEEDSWORK: re-create conflicts from merges with
 162          * merge.renormalize set, too
 163          */
 164         status = ll_merge(&result_buf, path, &ancestor, "base",
 165                           &ours, "ours", &theirs, "theirs", NULL);
 166         free(ancestor.ptr);
 167         free(ours.ptr);
 168         free(theirs.ptr);
 169         if (status < 0 || !result_buf.ptr) {
 170                 free(result_buf.ptr);
 171                 return error("path '%s': cannot merge", path);
 172         }
 173
 174         /*
 175          * NEEDSWORK:
 176          * There is absolutely no reason to write this as a blob object
 177          * and create a phony cache entry just to leak.  This hack is
 178          * primarily to get to the write_entry() machinery that massages
 179          * the contents to work-tree format and writes out which only
 180          * allows it for a cache entry.  The code in write_entry() needs
 181          * to be refactored to allow us to feed a <buffer, size, mode>
 182          * instead of a cache entry.  Such a refactoring would help
 183          * merge_recursive as well (it also writes the merge result to the
 184          * object database even when it may contain conflicts).
 185          */
 186         if (write_sha1_file(result_buf.ptr, result_buf.size,
 187                             blob_type, sha1))
 188                 die("Unable to add merge result for '%s'", path);
 189         ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
 190                               sha1,
 191                               path, 2, 0);
 192         if (!ce)
 193                 die("make_cache_entry failed for path '%s'", path);
 194         status = checkout_entry(ce, state, NULL);
 195         return status;
 196 }
 197
 198 static int checkout_paths(struct tree *source_tree, const char **pathspec,
 199                           struct checkout_opts *opts)
 200 {
 201         int pos;
 202         struct checkout state;
 203         static char *ps_matched;
 204         unsigned char rev[20];
 205         int flag;
 206         struct commit *head;
 207         int errs = 0;
 208         int stage = opts->writeout_stage;
 209         int merge = opts->merge;
 210         int newfd;
 211         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 212
 213         newfd = hold_locked_index(lock_file, 1);
 214         if (read_cache_preload(pathspec) < 0)
 215                 return error("corrupt index file");
 216
 217         if (source_tree)
 218                 read_tree_some(source_tree, pathspec);
 219
 220         for (pos = 0; pathspec[pos]; pos++)
 221                 ;
 222         ps_matched = xcalloc(1, pos);
 223
 224         for (pos = 0; pos < active_nr; pos++) {
 225                 struct cache_entry *ce = active_cache[pos];
 226                 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 227         }
 228
 229         if (report_path_error(ps_matched, pathspec, 0))
 230                 return 1;
 231
 232         /* "checkout -m path" to recreate conflicted state */
 233         if (opts->merge)
 234                 unmerge_cache(pathspec);
 235
 236         /* Any unmerged paths? */
 237         for (pos = 0; pos < active_nr; pos++) {
 238                 struct cache_entry *ce = active_cache[pos];
 239                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 240                         if (!ce_stage(ce))
 241                                 continue;
 242                         if (opts->force) {
 243                                 warning("path '%s' is unmerged", ce->name);
 244                         } else if (stage) {
 245                                 errs |= check_stage(stage, ce, pos);
 246                         } else if (opts->merge) {
 247                                 errs |= check_all_stages(ce, pos);
 248                         } else {
 249                                 errs = 1;
 250                                 error("path '%s' is unmerged", ce->name);
 251                         }
 252                         pos = skip_same_name(ce, pos) - 1;
 253                 }
 254         }
 255         if (errs)
 256                 return 1;
 257
 258         /* Now we are committed to check them out */
 259         memset(&state, 0, sizeof(state));
 260         state.force = 1;
 261         state.refresh_cache = 1;
 262         for (pos = 0; pos < active_nr; pos++) {
 263                 struct cache_entry *ce = active_cache[pos];
 264                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 265                         if (!ce_stage(ce)) {
 266                                 errs |= checkout_entry(ce, &state, NULL);
 267                                 continue;
 268                         }
 269                         if (stage)
 270                                 errs |= checkout_stage(stage, ce, pos, &state);
 271                         else if (merge)
 272                                 errs |= checkout_merged(pos, &state);
 273                         pos = skip_same_name(ce, pos) - 1;
 274                 }
 275         }
 276
 277         if (write_cache(newfd, active_cache, active_nr) ||
 278             commit_locked_index(lock_file))
 279                 die("unable to write new index file");
 280
 281         resolve_ref("HEAD", rev, 0, &flag);
 282         head = lookup_commit_reference_gently(rev, 1);
 283
 284         errs |= post_checkout_hook(head, head, 0);
 285         return errs;
 286 }
 287
 288 static void show_local_changes(struct object *head, struct diff_options *opts)
 289 {
 290         struct rev_info rev;
 291         /* I think we want full paths, even if we're in a subdirectory. */
 292         init_revisions(&rev, NULL);
 293         rev.diffopt.flags = opts->flags;
 294         rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 295         if (diff_setup_done(&rev.diffopt) < 0)
 296                 die("diff_setup_done failed");
 297         add_pending_object(&rev, head, NULL);
 298         run_diff_index(&rev, 0);
 299 }
 300
 301 static void describe_detached_head(const char *msg, struct commit *commit)
 302 {
 303         struct strbuf sb = STRBUF_INIT;
 304         struct pretty_print_context ctx = {0};
 305         parse_commit(commit);
 306         pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
 307         fprintf(stderr, "%s %s... %s\n", msg,
 308                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 309         strbuf_release(&sb);
 310 }
 311
 312 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 313 {
 314         struct unpack_trees_options opts;
 315         struct tree_desc tree_desc;
 316
 317         memset(&opts, 0, sizeof(opts));
 318         opts.head_idx = -1;
 319         opts.update = worktree;
 320         opts.skip_unmerged = !worktree;
 321         opts.reset = 1;
 322         opts.merge = 1;
 323         opts.fn = oneway_merge;
 324         opts.verbose_update = !o->quiet;
 325         opts.src_index = &the_index;
 326         opts.dst_index = &the_index;
 327         parse_tree(tree);
 328         init_tree_desc(&tree_desc, tree->buffer, tree->size);
 329         switch (unpack_trees(1, &tree_desc, &opts)) {
 330         case -2:
 331                 o->writeout_error = 1;
 332                 /*
 333                  * We return 0 nevertheless, as the index is all right
 334                  * and more importantly we have made best efforts to
 335                  * update paths in the work tree, and we cannot revert
 336                  * them.
 337                  */
 338         case 0:
 339                 return 0;
 340         default:
 341                 return 128;
 342         }
 343 }
 344
 345 struct branch_info {
 346         const char *name; /* The short name used */
 347         const char *path; /* The full name of a real branch */
 348         struct commit *commit; /* The named commit */
 349 };
 350
 351 static void setup_branch_path(struct branch_info *branch)
 352 {
 353         struct strbuf buf = STRBUF_INIT;
 354
 355         strbuf_branchname(&buf, branch->name);
 356         if (strcmp(buf.buf, branch->name))
 357                 branch->name = xstrdup(buf.buf);
 358         strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 359         branch->path = strbuf_detach(&buf, NULL);
 360 }
 361
 362 static int merge_working_tree(struct checkout_opts *opts,
 363                               struct branch_info *old, struct branch_info *new)
 364 {
 365         int ret;
 366         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 367         int newfd = hold_locked_index(lock_file, 1);
 368
 369         if (read_cache_preload(NULL) < 0)
 370                 return error("corrupt index file");
 371
 372         resolve_undo_clear();
 373         if (opts->force) {
 374                 ret = reset_tree(new->commit->tree, opts, 1);
 375                 if (ret)
 376                         return ret;
 377         } else {
 378                 struct tree_desc trees[2];
 379                 struct tree *tree;
 380                 struct unpack_trees_options topts;
 381
 382                 memset(&topts, 0, sizeof(topts));
 383                 topts.head_idx = -1;
 384                 topts.src_index = &the_index;
 385                 topts.dst_index = &the_index;
 386
 387                 setup_unpack_trees_porcelain(&topts, "checkout");
 388
 389                 refresh_cache(REFRESH_QUIET);
 390
 391                 if (unmerged_cache()) {
 392                         error("you need to resolve your current index first");
 393                         return 1;
 394                 }
 395
 396                 /* 2-way merge to the new branch */
 397                 topts.initial_checkout = is_cache_unborn();
 398                 topts.update = 1;
 399                 topts.merge = 1;
 400                 topts.gently = opts->merge && old->commit;
 401                 topts.verbose_update = !opts->quiet;
 402                 topts.fn = twoway_merge;
 403                 topts.dir = xcalloc(1, sizeof(*topts.dir));
 404                 topts.dir->flags |= DIR_SHOW_IGNORED;
 405                 topts.dir->exclude_per_dir = ".gitignore";
 406                 tree = parse_tree_indirect(old->commit ?
 407                                            old->commit->object.sha1 :
 408                                            EMPTY_TREE_SHA1_BIN);
 409                 init_tree_desc(&trees[0], tree->buffer, tree->size);
 410                 tree = parse_tree_indirect(new->commit->object.sha1);
 411                 init_tree_desc(&trees[1], tree->buffer, tree->size);
 412
 413                 ret = unpack_trees(2, trees, &topts);
 414                 if (ret == -1) {
 415                         /*
 416                          * Unpack couldn't do a trivial merge; either
 417                          * give up or do a real merge, depending on
 418                          * whether the merge flag was used.
 419                          */
 420                         struct tree *result;
 421                         struct tree *work;
 422                         struct merge_options o;
 423                         if (!opts->merge)
 424                                 return 1;
 425
 426                         /*
 427                          * Without old->commit, the below is the same as
 428                          * the two-tree unpack we already tried and failed.
 429                          */
 430                         if (!old->commit)
 431                                 return 1;
 432
 433                         /* Do more real merge */
 434
 435                         /*
 436                          * We update the index fully, then write the
 437                          * tree from the index, then merge the new
 438                          * branch with the current tree, with the old
 439                          * branch as the base. Then we reset the index
 440                          * (but not the working tree) to the new
 441                          * branch, leaving the working tree as the
 442                          * merged version, but skipping unmerged
 443                          * entries in the index.
 444                          */
 445
 446                         add_files_to_cache(NULL, NULL, 0);
 447                         /*
 448                          * NEEDSWORK: carrying over local changes
 449                          * when branches have different end-of-line
 450                          * normalization (or clean+smudge rules) is
 451                          * a pain; plumb in an option to set
 452                          * o.renormalize?
 453                          */
 454                         init_merge_options(&o);
 455                         o.verbosity = 0;
 456                         work = write_tree_from_memory(&o);
 457
 458                         ret = reset_tree(new->commit->tree, opts, 1);
 459                         if (ret)
 460                                 return ret;
 461                         o.ancestor = old->name;
 462                         o.branch1 = new->name;
 463                         o.branch2 = "local";
 464                         merge_trees(&o, new->commit->tree, work,
 465                                 old->commit->tree, &result);
 466                         ret = reset_tree(new->commit->tree, opts, 0);
 467                         if (ret)
 468                                 return ret;
 469                 }
 470         }
 471
 472         if (write_cache(newfd, active_cache, active_nr) ||
 473             commit_locked_index(lock_file))
 474                 die("unable to write new index file");
 475
 476         if (!opts->force && !opts->quiet)
 477                 show_local_changes(&new->commit->object, &opts->diff_options);
 478
 479         return 0;
 480 }
 481
 482 static void report_tracking(struct branch_info *new)
 483 {
 484         struct strbuf sb = STRBUF_INIT;
 485         struct branch *branch = branch_get(new->name);
 486
 487         if (!format_tracking_info(branch, &sb))
 488                 return;
 489         fputs(sb.buf, stdout);
 490         strbuf_release(&sb);
 491 }
 492
 493 static void detach_advice(const char *old_path, const char *new_name)
 494 {
 495         const char fmt[] =
 496         "Note: checking out '%s'.\n\n"
 497         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 498         "changes and commit them, and you can discard any commits you make in this\n"
 499         "state without impacting any branches by performing another checkout.\n\n"
 500         "If you want to create a new branch to retain commits you create, you may\n"
 501         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 502         "  git checkout -b new_branch_name\n\n";
 503
 504         fprintf(stderr, fmt, new_name);
 505 }
 506
 507 static void update_refs_for_switch(struct checkout_opts *opts,
 508                                    struct branch_info *old,
 509                                    struct branch_info *new)
 510 {
 511         struct strbuf msg = STRBUF_INIT;
 512         const char *old_desc;
 513         if (opts->new_branch) {
 514                 if (opts->new_orphan_branch) {
 515                         if (opts->new_branch_log && !log_all_ref_updates) {
 516                                 int temp;
 517                                 char log_file[PATH_MAX];
 518                                 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
 519
 520                                 temp = log_all_ref_updates;
 521                                 log_all_ref_updates = 1;
 522                                 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
 523                                         fprintf(stderr, "Can not do reflog for '%s'\n",
 524                                             opts->new_orphan_branch);
 525                                         log_all_ref_updates = temp;
 526                                         return;
 527                                 }
 528                                 log_all_ref_updates = temp;
 529                         }
 530                 }
 531                 else
 532                         create_branch(old->name, opts->new_branch, new->name,
 533                                       opts->new_branch_force ? 1 : 0,
 534                                       opts->new_branch_log, opts->track);
 535                 new->name = opts->new_branch;
 536                 setup_branch_path(new);
 537         }
 538
 539         old_desc = old->name;
 540         if (!old_desc && old->commit)
 541                 old_desc = sha1_to_hex(old->commit->object.sha1);
 542         strbuf_addf(&msg, "checkout: moving from %s to %s",
 543                     old_desc ? old_desc : "(invalid)", new->name);
 544
 545         if (!strcmp(new->name, "HEAD") && !new->path && !opts->force_detach) {
 546                 /* Nothing to do. */
 547         } else if (opts->force_detach || !new->path) {  /* No longer on any branch. */
 548                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 549                            REF_NODEREF, DIE_ON_ERR);
 550                 if (!opts->quiet) {
 551                         if (old->path && advice_detached_head)
 552                                 detach_advice(old->path, new->name);
 553                         describe_detached_head("HEAD is now at", new->commit);
 554                 }
 555         } else if (new->path) { /* Switch branches. */
 556                 create_symref("HEAD", new->path, msg.buf);
 557                 if (!opts->quiet) {
 558                         if (old->path && !strcmp(new->path, old->path))
 559                                 fprintf(stderr, "Already on '%s'\n",
 560                                         new->name);
 561                         else if (opts->new_branch)
 562                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 563                                         opts->branch_exists ? " and reset" : " a new",
 564                                         new->name);
 565                         else
 566                                 fprintf(stderr, "Switched to branch '%s'\n",
 567                                         new->name);
 568                 }
 569                 if (old->path && old->name) {
 570                         char log_file[PATH_MAX], ref_file[PATH_MAX];
 571
 572                         git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 573                         git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 574                         if (!file_exists(ref_file) && file_exists(log_file))
 575                                 remove_path(log_file);
 576                 }
 577         }
 578         remove_branch_state();
 579         strbuf_release(&msg);
 580         if (!opts->quiet &&
 581             (new->path || (!opts->force_detach && !strcmp(new->name, "HEAD"))))
 582                 report_tracking(new);
 583 }
 584
 585 struct rev_list_args {
 586         int argc;
 587         int alloc;
 588         const char **argv;
 589 };
 590
 591 static void add_one_rev_list_arg(struct rev_list_args *args, const char *s)
 592 {
 593         ALLOC_GROW(args->argv, args->argc + 1, args->alloc);
 594         args->argv[args->argc++] = s;
 595 }
 596
 597 static int add_one_ref_to_rev_list_arg(const char *refname,
 598                                        const unsigned char *sha1,
 599                                        int flags,
 600                                        void *cb_data)
 601 {
 602         add_one_rev_list_arg(cb_data, refname);
 603         return 0;
 604 }
 605
 606 static int clear_commit_marks_from_one_ref(const char *refname,
 607                                       const unsigned char *sha1,
 608                                       int flags,
 609                                       void *cb_data)
 610 {
 611         struct commit *commit = lookup_commit_reference_gently(sha1, 1);
 612         if (commit)
 613                 clear_commit_marks(commit, -1);
 614         return 0;
 615 }
 616
 617 static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
 618 {
 619         struct pretty_print_context ctx = { 0 };
 620
 621         parse_commit(commit);
 622         strbuf_addstr(sb, "  ");
 623         strbuf_addstr(sb,
 624                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
 625         strbuf_addch(sb, ' ');
 626         pretty_print_commit(CMIT_FMT_ONELINE, commit, sb, &ctx);
 627         strbuf_addch(sb, '\n');
 628 }
 629
 630 #define ORPHAN_CUTOFF 4
 631 static void suggest_reattach(struct commit *commit, struct rev_info *revs)
 632 {
 633         struct commit *c, *last = NULL;
 634         struct strbuf sb = STRBUF_INIT;
 635         int lost = 0;
 636         while ((c = get_revision(revs)) != NULL) {
 637                 if (lost < ORPHAN_CUTOFF)
 638                         describe_one_orphan(&sb, c);
 639                 last = c;
 640                 lost++;
 641         }
 642         if (ORPHAN_CUTOFF < lost) {
 643                 int more = lost - ORPHAN_CUTOFF;
 644                 if (more == 1)
 645                         describe_one_orphan(&sb, last);
 646                 else
 647                         strbuf_addf(&sb, " ... and %d more.\n", more);
 648         }
 649
 650         fprintf(stderr,
 651                 "Warning: you are leaving %d commit%s behind, "
 652                 "not connected to\n"
 653                 "any of your branches:\n\n"
 654                 "%s\n"
 655                 "If you want to keep them by creating a new branch, "
 656                 "this may be a good time\nto do so with:\n\n"
 657                 " git branch new_branch_name %s\n\n",
 658                 lost, ((1 < lost) ? "s" : ""),
 659                 sb.buf,
 660                 sha1_to_hex(commit->object.sha1));
 661         strbuf_release(&sb);
 662 }
 663
 664 /*
 665  * We are about to leave commit that was at the tip of a detached
 666  * HEAD.  If it is not reachable from any ref, this is the last chance
 667  * for the user to do so without resorting to reflog.
 668  */
 669 static void orphaned_commit_warning(struct commit *commit)
 670 {
 671         struct rev_list_args args = { 0, 0, NULL };
 672         struct rev_info revs;
 673
 674         add_one_rev_list_arg(&args, "(internal)");
 675         add_one_rev_list_arg(&args, sha1_to_hex(commit->object.sha1));
 676         add_one_rev_list_arg(&args, "--not");
 677         for_each_ref(add_one_ref_to_rev_list_arg, &args);
 678         add_one_rev_list_arg(&args, "--");
 679         add_one_rev_list_arg(&args, NULL);
 680
 681         init_revisions(&revs, NULL);
 682         if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
 683                 die("internal error: only -- alone should have been left");
 684         if (prepare_revision_walk(&revs))
 685                 die("internal error in revision walk");
 686         if (!(commit->object.flags & UNINTERESTING))
 687                 suggest_reattach(commit, &revs);
 688         else
 689                 describe_detached_head("Previous HEAD position was", commit);
 690
 691         clear_commit_marks(commit, -1);
 692         for_each_ref(clear_commit_marks_from_one_ref, NULL);
 693 }
 694
 695 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 696 {
 697         int ret = 0;
 698         struct branch_info old;
 699         unsigned char rev[20];
 700         int flag;
 701         memset(&old, 0, sizeof(old));
 702         old.path = resolve_ref("HEAD", rev, 0, &flag);
 703         old.commit = lookup_commit_reference_gently(rev, 1);
 704         if (!(flag & REF_ISSYMREF))
 705                 old.path = NULL;
 706
 707         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 708                 old.name = old.path + strlen("refs/heads/");
 709
 710         if (!new->name) {
 711                 new->name = "HEAD";
 712                 new->commit = old.commit;
 713                 if (!new->commit)
 714                         die("You are on a branch yet to be born");
 715                 parse_commit(new->commit);
 716         }
 717
 718         ret = merge_working_tree(opts, &old, new);
 719         if (ret)
 720                 return ret;
 721
 722         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 723                 orphaned_commit_warning(old.commit);
 724
 725         update_refs_for_switch(opts, &old, new);
 726
 727         ret = post_checkout_hook(old.commit, new->commit, 1);
 728         return ret || opts->writeout_error;
 729 }
 730
 731 static int git_checkout_config(const char *var, const char *value, void *cb)
 732 {
 733         if (!strcmp(var, "diff.ignoresubmodules")) {
 734                 struct checkout_opts *opts = cb;
 735                 handle_ignore_submodules_arg(&opts->diff_options, value);
 736                 return 0;
 737         }
 738
 739         if (!prefixcmp(var, "submodule."))
 740                 return parse_submodule_config_option(var, value);
 741
 742         return git_xmerge_config(var, value, NULL);
 743 }
 744
 745 static int interactive_checkout(const char *revision, const char **pathspec,
 746                                 struct checkout_opts *opts)
 747 {
 748         return run_add_interactive(revision, "--patch=checkout", pathspec);
 749 }
 750
 751 struct tracking_name_data {
 752         const char *name;
 753         char *remote;
 754         int unique;
 755 };
 756
 757 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 758                                int flags, void *cb_data)
 759 {
 760         struct tracking_name_data *cb = cb_data;
 761         const char *slash;
 762
 763         if (prefixcmp(refname, "refs/remotes/"))
 764                 return 0;
 765         slash = strchr(refname + 13, '/');
 766         if (!slash || strcmp(slash + 1, cb->name))
 767                 return 0;
 768         if (cb->remote) {
 769                 cb->unique = 0;
 770                 return 0;
 771         }
 772         cb->remote = xstrdup(refname);
 773         return 0;
 774 }
 775
 776 static const char *unique_tracking_name(const char *name)
 777 {
 778         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 779         cb_data.name = name;
 780         for_each_ref(check_tracking_name, &cb_data);
 781         if (cb_data.unique)
 782                 return cb_data.remote;
 783         free(cb_data.remote);
 784         return NULL;
 785 }
 786
 787 static int parse_branchname_arg(int argc, const char **argv,
 788                                 int dwim_new_local_branch_ok,
 789                                 struct branch_info *new,
 790                                 struct tree **source_tree,
 791                                 unsigned char rev[20],
 792                                 const char **new_branch)
 793 {
 794         int argcount = 0;
 795         unsigned char branch_rev[20];
 796         const char *arg;
 797         int has_dash_dash;
 798
 799         /*
 800          * case 1: git checkout <ref> -- [<paths>]
 801          *
 802          *   <ref> must be a valid tree, everything after the '--' must be
 803          *   a path.
 804          *
 805          * case 2: git checkout -- [<paths>]
 806          *
 807          *   everything after the '--' must be paths.
 808          *
 809          * case 3: git checkout <something> [<paths>]
 810          *
 811          *   With no paths, if <something> is a commit, that is to
 812          *   switch to the branch or detach HEAD at it.  As a special case,
 813          *   if <something> is A...B (missing A or B means HEAD but you can
 814          *   omit at most one side), and if there is a unique merge base
 815          *   between A and B, A...B names that merge base.
 816          *
 817          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 818          *   was given, and there is a tracking branch whose name is
 819          *   <something> in one and only one remote, then this is a short-hand
 820          *   to fork local <something> from that remote-tracking branch.
 821          *
 822          *   Otherwise <something> shall not be ambiguous.
 823          *   - If it's *only* a reference, treat it like case (1).
 824          *   - If it's only a path, treat it like case (2).
 825          *   - else: fail.
 826          *
 827          */
 828         if (!argc)
 829                 return 0;
 830
 831         if (!strcmp(argv[0], "--"))     /* case (2) */
 832                 return 1;
 833
 834         arg = argv[0];
 835         has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 836
 837         if (!strcmp(arg, "-"))
 838                 arg = "@{-1}";
 839
 840         if (get_sha1_mb(arg, rev)) {
 841                 if (has_dash_dash)          /* case (1) */
 842                         die("invalid reference: %s", arg);
 843                 if (dwim_new_local_branch_ok &&
 844                     !check_filename(NULL, arg) &&
 845                     argc == 1) {
 846                         const char *remote = unique_tracking_name(arg);
 847                         if (!remote || get_sha1(remote, rev))
 848                                 return argcount;
 849                         *new_branch = arg;
 850                         arg = remote;
 851                         /* DWIMmed to create local branch */
 852                 } else {
 853                         return argcount;
 854                 }
 855         }
 856
 857         /* we can't end up being in (2) anymore, eat the argument */
 858         argcount++;
 859         argv++;
 860         argc--;
 861
 862         new->name = arg;
 863         setup_branch_path(new);
 864
 865         if (check_ref_format(new->path) == CHECK_REF_FORMAT_OK &&
 866             resolve_ref(new->path, branch_rev, 1, NULL))
 867                 hashcpy(rev, branch_rev);
 868         else
 869                 new->path = NULL; /* not an existing branch */
 870
 871         new->commit = lookup_commit_reference_gently(rev, 1);
 872         if (!new->commit) {
 873                 /* not a commit */
 874                 *source_tree = parse_tree_indirect(rev);
 875         } else {
 876                 parse_commit(new->commit);
 877                 *source_tree = new->commit->tree;
 878         }
 879
 880         if (!*source_tree)                   /* case (1): want a tree */
 881                 die("reference is not a tree: %s", arg);
 882         if (!has_dash_dash) {/* case (3 -> 1) */
 883                 /*
 884                  * Do not complain the most common case
 885                  *      git checkout branch
 886                  * even if there happen to be a file called 'branch';
 887                  * it would be extremely annoying.
 888                  */
 889                 if (argc)
 890                         verify_non_filename(NULL, arg);
 891         } else {
 892                 argcount++;
 893                 argv++;
 894                 argc--;
 895         }
 896
 897         return argcount;
 898 }
 899
 900 int cmd_checkout(int argc, const char **argv, const char *prefix)
 901 {
 902         struct checkout_opts opts;
 903         unsigned char rev[20];
 904         struct branch_info new;
 905         struct tree *source_tree = NULL;
 906         char *conflict_style = NULL;
 907         int patch_mode = 0;
 908         int dwim_new_local_branch = 1;
 909         struct option options[] = {
 910                 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
 911                 OPT_STRING('b', NULL, &opts.new_branch, "branch",
 912                            "create and checkout a new branch"),
 913                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 914                            "create/reset and checkout a branch"),
 915                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
 916                 OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
 917                 OPT_SET_INT('t', "track",  &opts.track, "set upstream info for new branch",
 918                         BRANCH_TRACK_EXPLICIT),
 919                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 920                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
 921                             2),
 922                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
 923                             3),
 924                 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
 925                 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
 926                 OPT_STRING(0, "conflict", &conflict_style, "style",
 927                            "conflict style (merge or diff3)"),
 928                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 929                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 930                   "second guess 'git checkout no-such-branch'",
 931                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 932                 OPT_END(),
 933         };
 934
 935         memset(&opts, 0, sizeof(opts));
 936         memset(&new, 0, sizeof(new));
 937
 938         gitmodules_config();
 939         git_config(git_checkout_config, &opts);
 940
 941         opts.track = BRANCH_TRACK_UNSPECIFIED;
 942
 943         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 944                              PARSE_OPT_KEEP_DASHDASH);
 945
 946         /* we can assume from now on new_branch = !new_branch_force */
 947         if (opts.new_branch && opts.new_branch_force)
 948                 die("-B cannot be used with -b");
 949
 950         /* copy -B over to -b, so that we can just check the latter */
 951         if (opts.new_branch_force)
 952                 opts.new_branch = opts.new_branch_force;
 953
 954         if (patch_mode && (opts.track > 0 || opts.new_branch
 955                            || opts.new_branch_log || opts.merge || opts.force
 956                            || opts.force_detach))
 957                 die ("--patch is incompatible with all other options");
 958
 959         if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
 960                 die("--detach cannot be used with -b/-B/--orphan");
 961         if (opts.force_detach && 0 < opts.track)
 962                 die("--detach cannot be used with -t");
 963
 964         /* --track without -b should DWIM */
 965         if (0 < opts.track && !opts.new_branch) {
 966                 const char *argv0 = argv[0];
 967                 if (!argc || !strcmp(argv0, "--"))
 968                         die ("--track needs a branch name");
 969                 if (!prefixcmp(argv0, "refs/"))
 970                         argv0 += 5;
 971                 if (!prefixcmp(argv0, "remotes/"))
 972                         argv0 += 8;
 973                 argv0 = strchr(argv0, '/');
 974                 if (!argv0 || !argv0[1])
 975                         die ("Missing branch name; try -b");
 976                 opts.new_branch = argv0 + 1;
 977         }
 978
 979         if (opts.new_orphan_branch) {
 980                 if (opts.new_branch)
 981                         die("--orphan and -b|-B are mutually exclusive");
 982                 if (opts.track > 0)
 983                         die("--orphan cannot be used with -t");
 984                 opts.new_branch = opts.new_orphan_branch;
 985         }
 986
 987         if (conflict_style) {
 988                 opts.merge = 1; /* implied */
 989                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 990         }
 991
 992         if (opts.force && opts.merge)
 993                 die("git checkout: -f and -m are incompatible");
 994
 995         /*
 996          * Extract branch name from command line arguments, so
 997          * all that is left is pathspecs.
 998          *
 999          * Handle
1000          *
1001          *  1) git checkout <tree> -- [<paths>]
1002          *  2) git checkout -- [<paths>]
1003          *  3) git checkout <something> [<paths>]
1004          *
1005          * including "last branch" syntax and DWIM-ery for names of
1006          * remote branches, erroring out for invalid or ambiguous cases.
1007          */
1008         if (argc) {
1009                 int dwim_ok =
1010                         !patch_mode &&
1011                         dwim_new_local_branch &&
1012                         opts.track == BRANCH_TRACK_UNSPECIFIED &&
1013                         !opts.new_branch;
1014                 int n = parse_branchname_arg(argc, argv, dwim_ok,
1015                                 &new, &source_tree, rev, &opts.new_branch);
1016                 argv += n;
1017                 argc -= n;
1018         }
1019
1020         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
1021                 opts.track = git_branch_track;
1022
1023         if (argc) {
1024                 const char **pathspec = get_pathspec(prefix, argv);
1025
1026                 if (!pathspec)
1027                         die("invalid path specification");
1028
1029                 if (patch_mode)
1030                         return interactive_checkout(new.name, pathspec, &opts);
1031
1032                 /* Checkout paths */
1033                 if (opts.new_branch) {
1034                         if (argc == 1) {
1035                                 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]);
1036                         } else {
1037                                 die("git checkout: updating paths is incompatible with switching branches.");
1038                         }
1039                 }
1040
1041                 if (opts.force_detach)
1042                         die("git checkout: --detach does not take a path argument");
1043
1044                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
1045                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
1046
1047                 return checkout_paths(source_tree, pathspec, &opts);
1048         }
1049
1050         if (patch_mode)
1051                 return interactive_checkout(new.name, NULL, &opts);
1052
1053         if (opts.new_branch) {
1054                 struct strbuf buf = STRBUF_INIT;
1055                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
1056                         die("git checkout: we do not like '%s' as a branch name.",
1057                             opts.new_branch);
1058                 if (!get_sha1(buf.buf, rev)) {
1059                         opts.branch_exists = 1;
1060                         if (!opts.new_branch_force)
1061                                 die("git checkout: branch %s already exists",
1062                                     opts.new_branch);
1063                 }
1064                 strbuf_release(&buf);
1065         }
1066
1067         if (new.name && !new.commit) {
1068                 die("Cannot switch branch to a non-commit.");
1069         }
1070         if (opts.writeout_stage)
1071                 die("--ours/--theirs is incompatible with switching branches.");
1072
1073         return switch_branches(&opts, &new);
1074 }