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