builtin / checkout.con commit Merge branch 'cb/xdiff-no-system-includes-in-dot-c' (d163b6a)
   1#define USE_THE_INDEX_COMPATIBILITY_MACROS
   2#include "builtin.h"
   3#include "advice.h"
   4#include "blob.h"
   5#include "branch.h"
   6#include "cache-tree.h"
   7#include "checkout.h"
   8#include "commit.h"
   9#include "config.h"
  10#include "diff.h"
  11#include "dir.h"
  12#include "ll-merge.h"
  13#include "lockfile.h"
  14#include "merge-recursive.h"
  15#include "object-store.h"
  16#include "parse-options.h"
  17#include "refs.h"
  18#include "remote.h"
  19#include "resolve-undo.h"
  20#include "revision.h"
  21#include "run-command.h"
  22#include "submodule.h"
  23#include "submodule-config.h"
  24#include "tree.h"
  25#include "tree-walk.h"
  26#include "unpack-trees.h"
  27#include "wt-status.h"
  28#include "xdiff-interface.h"
  29
  30static const char * const checkout_usage[] = {
  31        N_("git checkout [<options>] <branch>"),
  32        N_("git checkout [<options>] [<branch>] -- <file>..."),
  33        NULL,
  34};
  35
  36static const char * const switch_branch_usage[] = {
  37        N_("git switch [<options>] [<branch>]"),
  38        NULL,
  39};
  40
  41static const char * const restore_usage[] = {
  42        N_("git restore [<options>] [--source=<branch>] <file>..."),
  43        NULL,
  44};
  45
  46struct checkout_opts {
  47        int patch_mode;
  48        int quiet;
  49        int merge;
  50        int force;
  51        int force_detach;
  52        int implicit_detach;
  53        int writeout_stage;
  54        int overwrite_ignore;
  55        int ignore_skipworktree;
  56        int ignore_other_worktrees;
  57        int show_progress;
  58        int count_checkout_paths;
  59        int overlay_mode;
  60        int dwim_new_local_branch;
  61        int discard_changes;
  62        int accept_ref;
  63        int accept_pathspec;
  64        int switch_branch_doing_nothing_is_ok;
  65        int only_merge_on_switching_branches;
  66        int can_switch_when_in_progress;
  67        int orphan_from_empty_tree;
  68        int empty_pathspec_ok;
  69        int checkout_index;
  70        int checkout_worktree;
  71        const char *ignore_unmerged_opt;
  72        int ignore_unmerged;
  73
  74        const char *new_branch;
  75        const char *new_branch_force;
  76        const char *new_orphan_branch;
  77        int new_branch_log;
  78        enum branch_track track;
  79        struct diff_options diff_options;
  80        char *conflict_style;
  81
  82        int branch_exists;
  83        const char *prefix;
  84        struct pathspec pathspec;
  85        const char *from_treeish;
  86        struct tree *source_tree;
  87};
  88
  89static int post_checkout_hook(struct commit *old_commit, struct commit *new_commit,
  90                              int changed)
  91{
  92        return run_hook_le(NULL, "post-checkout",
  93                           oid_to_hex(old_commit ? &old_commit->object.oid : &null_oid),
  94                           oid_to_hex(new_commit ? &new_commit->object.oid : &null_oid),
  95                           changed ? "1" : "0", NULL);
  96        /* "new_commit" can be NULL when checking out from the index before
  97           a commit exists. */
  98
  99}
 100
 101static int update_some(const struct object_id *oid, struct strbuf *base,
 102                const char *pathname, unsigned mode, int stage, void *context)
 103{
 104        int len;
 105        struct cache_entry *ce;
 106        int pos;
 107
 108        if (S_ISDIR(mode))
 109                return READ_TREE_RECURSIVE;
 110
 111        len = base->len + strlen(pathname);
 112        ce = make_empty_cache_entry(&the_index, len);
 113        oidcpy(&ce->oid, oid);
 114        memcpy(ce->name, base->buf, base->len);
 115        memcpy(ce->name + base->len, pathname, len - base->len);
 116        ce->ce_flags = create_ce_flags(0) | CE_UPDATE;
 117        ce->ce_namelen = len;
 118        ce->ce_mode = create_ce_mode(mode);
 119
 120        /*
 121         * If the entry is the same as the current index, we can leave the old
 122         * entry in place. Whether it is UPTODATE or not, checkout_entry will
 123         * do the right thing.
 124         */
 125        pos = cache_name_pos(ce->name, ce->ce_namelen);
 126        if (pos >= 0) {
 127                struct cache_entry *old = active_cache[pos];
 128                if (ce->ce_mode == old->ce_mode &&
 129                    oideq(&ce->oid, &old->oid)) {
 130                        old->ce_flags |= CE_UPDATE;
 131                        discard_cache_entry(ce);
 132                        return 0;
 133                }
 134        }
 135
 136        add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
 137        return 0;
 138}
 139
 140static int read_tree_some(struct tree *tree, const struct pathspec *pathspec)
 141{
 142        read_tree_recursive(the_repository, tree, "", 0, 0,
 143                            pathspec, update_some, NULL);
 144
 145        /* update the index with the given tree's info
 146         * for all args, expanding wildcards, and exit
 147         * with any non-zero return code.
 148         */
 149        return 0;
 150}
 151
 152static int skip_same_name(const struct cache_entry *ce, int pos)
 153{
 154        while (++pos < active_nr &&
 155               !strcmp(active_cache[pos]->name, ce->name))
 156                ; /* skip */
 157        return pos;
 158}
 159
 160static int check_stage(int stage, const struct cache_entry *ce, int pos,
 161                       int overlay_mode)
 162{
 163        while (pos < active_nr &&
 164               !strcmp(active_cache[pos]->name, ce->name)) {
 165                if (ce_stage(active_cache[pos]) == stage)
 166                        return 0;
 167                pos++;
 168        }
 169        if (!overlay_mode)
 170                return 0;
 171        if (stage == 2)
 172                return error(_("path '%s' does not have our version"), ce->name);
 173        else
 174                return error(_("path '%s' does not have their version"), ce->name);
 175}
 176
 177static int check_stages(unsigned stages, const struct cache_entry *ce, int pos)
 178{
 179        unsigned seen = 0;
 180        const char *name = ce->name;
 181
 182        while (pos < active_nr) {
 183                ce = active_cache[pos];
 184                if (strcmp(name, ce->name))
 185                        break;
 186                seen |= (1 << ce_stage(ce));
 187                pos++;
 188        }
 189        if ((stages & seen) != stages)
 190                return error(_("path '%s' does not have all necessary versions"),
 191                             name);
 192        return 0;
 193}
 194
 195static int checkout_stage(int stage, const struct cache_entry *ce, int pos,
 196                          const struct checkout *state, int *nr_checkouts,
 197                          int overlay_mode)
 198{
 199        while (pos < active_nr &&
 200               !strcmp(active_cache[pos]->name, ce->name)) {
 201                if (ce_stage(active_cache[pos]) == stage)
 202                        return checkout_entry(active_cache[pos], state,
 203                                              NULL, nr_checkouts);
 204                pos++;
 205        }
 206        if (!overlay_mode) {
 207                unlink_entry(ce);
 208                return 0;
 209        }
 210        if (stage == 2)
 211                return error(_("path '%s' does not have our version"), ce->name);
 212        else
 213                return error(_("path '%s' does not have their version"), ce->name);
 214}
 215
 216static int checkout_merged(int pos, const struct checkout *state, int *nr_checkouts)
 217{
 218        struct cache_entry *ce = active_cache[pos];
 219        const char *path = ce->name;
 220        mmfile_t ancestor, ours, theirs;
 221        int status;
 222        struct object_id oid;
 223        mmbuffer_t result_buf;
 224        struct object_id threeway[3];
 225        unsigned mode = 0;
 226
 227        memset(threeway, 0, sizeof(threeway));
 228        while (pos < active_nr) {
 229                int stage;
 230                stage = ce_stage(ce);
 231                if (!stage || strcmp(path, ce->name))
 232                        break;
 233                oidcpy(&threeway[stage - 1], &ce->oid);
 234                if (stage == 2)
 235                        mode = create_ce_mode(ce->ce_mode);
 236                pos++;
 237                ce = active_cache[pos];
 238        }
 239        if (is_null_oid(&threeway[1]) || is_null_oid(&threeway[2]))
 240                return error(_("path '%s' does not have necessary versions"), path);
 241
 242        read_mmblob(&ancestor, &threeway[0]);
 243        read_mmblob(&ours, &threeway[1]);
 244        read_mmblob(&theirs, &threeway[2]);
 245
 246        /*
 247         * NEEDSWORK: re-create conflicts from merges with
 248         * merge.renormalize set, too
 249         */
 250        status = ll_merge(&result_buf, path, &ancestor, "base",
 251                          &ours, "ours", &theirs, "theirs",
 252                          state->istate, NULL);
 253        free(ancestor.ptr);
 254        free(ours.ptr);
 255        free(theirs.ptr);
 256        if (status < 0 || !result_buf.ptr) {
 257                free(result_buf.ptr);
 258                return error(_("path '%s': cannot merge"), path);
 259        }
 260
 261        /*
 262         * NEEDSWORK:
 263         * There is absolutely no reason to write this as a blob object
 264         * and create a phony cache entry.  This hack is primarily to get
 265         * to the write_entry() machinery that massages the contents to
 266         * work-tree format and writes out which only allows it for a
 267         * cache entry.  The code in write_entry() needs to be refactored
 268         * to allow us to feed a <buffer, size, mode> instead of a cache
 269         * entry.  Such a refactoring would help merge_recursive as well
 270         * (it also writes the merge result to the object database even
 271         * when it may contain conflicts).
 272         */
 273        if (write_object_file(result_buf.ptr, result_buf.size, blob_type, &oid))
 274                die(_("Unable to add merge result for '%s'"), path);
 275        free(result_buf.ptr);
 276        ce = make_transient_cache_entry(mode, &oid, path, 2);
 277        if (!ce)
 278                die(_("make_cache_entry failed for path '%s'"), path);
 279        status = checkout_entry(ce, state, NULL, nr_checkouts);
 280        discard_cache_entry(ce);
 281        return status;
 282}
 283
 284static void mark_ce_for_checkout_overlay(struct cache_entry *ce,
 285                                         char *ps_matched,
 286                                         const struct checkout_opts *opts)
 287{
 288        ce->ce_flags &= ~CE_MATCHED;
 289        if (!opts->ignore_skipworktree && ce_skip_worktree(ce))
 290                return;
 291        if (opts->source_tree && !(ce->ce_flags & CE_UPDATE))
 292                /*
 293                 * "git checkout tree-ish -- path", but this entry
 294                 * is in the original index but is not in tree-ish
 295                 * or does not match the pathspec; it will not be
 296                 * checked out to the working tree.  We will not do
 297                 * anything to this entry at all.
 298                 */
 299                return;
 300        /*
 301         * Either this entry came from the tree-ish we are
 302         * checking the paths out of, or we are checking out
 303         * of the index.
 304         *
 305         * If it comes from the tree-ish, we already know it
 306         * matches the pathspec and could just stamp
 307         * CE_MATCHED to it from update_some(). But we still
 308         * need ps_matched and read_tree_recursive (and
 309         * eventually tree_entry_interesting) cannot fill
 310         * ps_matched yet. Once it can, we can avoid calling
 311         * match_pathspec() for _all_ entries when
 312         * opts->source_tree != NULL.
 313         */
 314        if (ce_path_match(&the_index, ce, &opts->pathspec, ps_matched))
 315                ce->ce_flags |= CE_MATCHED;
 316}
 317
 318static void mark_ce_for_checkout_no_overlay(struct cache_entry *ce,
 319                                            char *ps_matched,
 320                                            const struct checkout_opts *opts)
 321{
 322        ce->ce_flags &= ~CE_MATCHED;
 323        if (!opts->ignore_skipworktree && ce_skip_worktree(ce))
 324                return;
 325        if (ce_path_match(&the_index, ce, &opts->pathspec, ps_matched)) {
 326                ce->ce_flags |= CE_MATCHED;
 327                if (opts->source_tree && !(ce->ce_flags & CE_UPDATE))
 328                        /*
 329                         * In overlay mode, but the path is not in
 330                         * tree-ish, which means we should remove it
 331                         * from the index and the working tree.
 332                         */
 333                        ce->ce_flags |= CE_REMOVE | CE_WT_REMOVE;
 334        }
 335}
 336
 337static int checkout_worktree(const struct checkout_opts *opts)
 338{
 339        struct checkout state = CHECKOUT_INIT;
 340        int nr_checkouts = 0, nr_unmerged = 0;
 341        int errs = 0;
 342        int pos;
 343
 344        state.force = 1;
 345        state.refresh_cache = 1;
 346        state.istate = &the_index;
 347
 348        enable_delayed_checkout(&state);
 349        for (pos = 0; pos < active_nr; pos++) {
 350                struct cache_entry *ce = active_cache[pos];
 351                if (ce->ce_flags & CE_MATCHED) {
 352                        if (!ce_stage(ce)) {
 353                                errs |= checkout_entry(ce, &state,
 354                                                       NULL, &nr_checkouts);
 355                                continue;
 356                        }
 357                        if (opts->writeout_stage)
 358                                errs |= checkout_stage(opts->writeout_stage,
 359                                                       ce, pos,
 360                                                       &state,
 361                                                       &nr_checkouts, opts->overlay_mode);
 362                        else if (opts->merge)
 363                                errs |= checkout_merged(pos, &state,
 364                                                        &nr_unmerged);
 365                        pos = skip_same_name(ce, pos) - 1;
 366                }
 367        }
 368        remove_marked_cache_entries(&the_index, 1);
 369        remove_scheduled_dirs();
 370        errs |= finish_delayed_checkout(&state, &nr_checkouts);
 371
 372        if (opts->count_checkout_paths) {
 373                if (nr_unmerged)
 374                        fprintf_ln(stderr, Q_("Recreated %d merge conflict",
 375                                              "Recreated %d merge conflicts",
 376                                              nr_unmerged),
 377                                   nr_unmerged);
 378                if (opts->source_tree)
 379                        fprintf_ln(stderr, Q_("Updated %d path from %s",
 380                                              "Updated %d paths from %s",
 381                                              nr_checkouts),
 382                                   nr_checkouts,
 383                                   find_unique_abbrev(&opts->source_tree->object.oid,
 384                                                      DEFAULT_ABBREV));
 385                else if (!nr_unmerged || nr_checkouts)
 386                        fprintf_ln(stderr, Q_("Updated %d path from the index",
 387                                              "Updated %d paths from the index",
 388                                              nr_checkouts),
 389                                   nr_checkouts);
 390        }
 391
 392        return errs;
 393}
 394
 395static int checkout_paths(const struct checkout_opts *opts,
 396                          const char *revision)
 397{
 398        int pos;
 399        static char *ps_matched;
 400        struct object_id rev;
 401        struct commit *head;
 402        int errs = 0;
 403        struct lock_file lock_file = LOCK_INIT;
 404        int checkout_index;
 405
 406        trace2_cmd_mode(opts->patch_mode ? "patch" : "path");
 407
 408        if (opts->track != BRANCH_TRACK_UNSPECIFIED)
 409                die(_("'%s' cannot be used with updating paths"), "--track");
 410
 411        if (opts->new_branch_log)
 412                die(_("'%s' cannot be used with updating paths"), "-l");
 413
 414        if (opts->ignore_unmerged && opts->patch_mode)
 415                die(_("'%s' cannot be used with updating paths"),
 416                    opts->ignore_unmerged_opt);
 417
 418        if (opts->force_detach)
 419                die(_("'%s' cannot be used with updating paths"), "--detach");
 420
 421        if (opts->merge && opts->patch_mode)
 422                die(_("'%s' cannot be used with %s"), "--merge", "--patch");
 423
 424        if (opts->ignore_unmerged && opts->merge)
 425                die(_("'%s' cannot be used with %s"),
 426                    opts->ignore_unmerged_opt, "-m");
 427
 428        if (opts->new_branch)
 429                die(_("Cannot update paths and switch to branch '%s' at the same time."),
 430                    opts->new_branch);
 431
 432        if (!opts->checkout_worktree && !opts->checkout_index)
 433                die(_("neither '%s' or '%s' is specified"),
 434                    "--staged", "--worktree");
 435
 436        if (!opts->checkout_worktree && !opts->from_treeish)
 437                die(_("'%s' must be used when '%s' is not specified"),
 438                    "--worktree", "--source");
 439
 440        if (opts->checkout_index && !opts->checkout_worktree &&
 441            opts->writeout_stage)
 442                die(_("'%s' or '%s' cannot be used with %s"),
 443                    "--ours", "--theirs", "--staged");
 444
 445        if (opts->checkout_index && !opts->checkout_worktree &&
 446            opts->merge)
 447                die(_("'%s' or '%s' cannot be used with %s"),
 448                    "--merge", "--conflict", "--staged");
 449
 450        if (opts->patch_mode) {
 451                const char *patch_mode;
 452
 453                if (opts->checkout_index && opts->checkout_worktree)
 454                        patch_mode = "--patch=checkout";
 455                else if (opts->checkout_index && !opts->checkout_worktree)
 456                        patch_mode = "--patch=reset";
 457                else if (!opts->checkout_index && opts->checkout_worktree)
 458                        patch_mode = "--patch=worktree";
 459                else
 460                        BUG("either flag must have been set, worktree=%d, index=%d",
 461                            opts->checkout_worktree, opts->checkout_index);
 462                return run_add_interactive(revision, patch_mode, &opts->pathspec);
 463        }
 464
 465        repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
 466        if (read_cache_preload(&opts->pathspec) < 0)
 467                return error(_("index file corrupt"));
 468
 469        if (opts->source_tree)
 470                read_tree_some(opts->source_tree, &opts->pathspec);
 471
 472        ps_matched = xcalloc(opts->pathspec.nr, 1);
 473
 474        /*
 475         * Make sure all pathspecs participated in locating the paths
 476         * to be checked out.
 477         */
 478        for (pos = 0; pos < active_nr; pos++)
 479                if (opts->overlay_mode)
 480                        mark_ce_for_checkout_overlay(active_cache[pos],
 481                                                     ps_matched,
 482                                                     opts);
 483                else
 484                        mark_ce_for_checkout_no_overlay(active_cache[pos],
 485                                                        ps_matched,
 486                                                        opts);
 487
 488        if (report_path_error(ps_matched, &opts->pathspec)) {
 489                free(ps_matched);
 490                return 1;
 491        }
 492        free(ps_matched);
 493
 494        /* "checkout -m path" to recreate conflicted state */
 495        if (opts->merge)
 496                unmerge_marked_index(&the_index);
 497
 498        /* Any unmerged paths? */
 499        for (pos = 0; pos < active_nr; pos++) {
 500                const struct cache_entry *ce = active_cache[pos];
 501                if (ce->ce_flags & CE_MATCHED) {
 502                        if (!ce_stage(ce))
 503                                continue;
 504                        if (opts->ignore_unmerged) {
 505                                if (!opts->quiet)
 506                                        warning(_("path '%s' is unmerged"), ce->name);
 507                        } else if (opts->writeout_stage) {
 508                                errs |= check_stage(opts->writeout_stage, ce, pos, opts->overlay_mode);
 509                        } else if (opts->merge) {
 510                                errs |= check_stages((1<<2) | (1<<3), ce, pos);
 511                        } else {
 512                                errs = 1;
 513                                error(_("path '%s' is unmerged"), ce->name);
 514                        }
 515                        pos = skip_same_name(ce, pos) - 1;
 516                }
 517        }
 518        if (errs)
 519                return 1;
 520
 521        /* Now we are committed to check them out */
 522        if (opts->checkout_worktree)
 523                errs |= checkout_worktree(opts);
 524
 525        /*
 526         * Allow updating the index when checking out from the index.
 527         * This is to save new stat info.
 528         */
 529        if (opts->checkout_worktree && !opts->checkout_index && !opts->source_tree)
 530                checkout_index = 1;
 531        else
 532                checkout_index = opts->checkout_index;
 533
 534        if (checkout_index) {
 535                if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
 536                        die(_("unable to write new index file"));
 537        } else {
 538                /*
 539                 * NEEDSWORK: if --worktree is not specified, we
 540                 * should save stat info of checked out files in the
 541                 * index to avoid the next (potentially costly)
 542                 * refresh. But it's a bit tricker to do...
 543                 */
 544                rollback_lock_file(&lock_file);
 545        }
 546
 547        read_ref_full("HEAD", 0, &rev, NULL);
 548        head = lookup_commit_reference_gently(the_repository, &rev, 1);
 549
 550        errs |= post_checkout_hook(head, head, 0);
 551        return errs;
 552}
 553
 554static void show_local_changes(struct object *head,
 555                               const struct diff_options *opts)
 556{
 557        struct rev_info rev;
 558        /* I think we want full paths, even if we're in a subdirectory. */
 559        repo_init_revisions(the_repository, &rev, NULL);
 560        rev.diffopt.flags = opts->flags;
 561        rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 562        diff_setup_done(&rev.diffopt);
 563        add_pending_object(&rev, head, NULL);
 564        run_diff_index(&rev, 0);
 565}
 566
 567static void describe_detached_head(const char *msg, struct commit *commit)
 568{
 569        struct strbuf sb = STRBUF_INIT;
 570
 571        if (!parse_commit(commit))
 572                pp_commit_easy(CMIT_FMT_ONELINE, commit, &sb);
 573        if (print_sha1_ellipsis()) {
 574                fprintf(stderr, "%s %s... %s\n", msg,
 575                        find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV), sb.buf);
 576        } else {
 577                fprintf(stderr, "%s %s %s\n", msg,
 578                        find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV), sb.buf);
 579        }
 580        strbuf_release(&sb);
 581}
 582
 583static int reset_tree(struct tree *tree, const struct checkout_opts *o,
 584                      int worktree, int *writeout_error)
 585{
 586        struct unpack_trees_options opts;
 587        struct tree_desc tree_desc;
 588
 589        memset(&opts, 0, sizeof(opts));
 590        opts.head_idx = -1;
 591        opts.update = worktree;
 592        opts.skip_unmerged = !worktree;
 593        opts.reset = 1;
 594        opts.merge = 1;
 595        opts.fn = oneway_merge;
 596        opts.verbose_update = o->show_progress;
 597        opts.src_index = &the_index;
 598        opts.dst_index = &the_index;
 599        parse_tree(tree);
 600        init_tree_desc(&tree_desc, tree->buffer, tree->size);
 601        switch (unpack_trees(1, &tree_desc, &opts)) {
 602        case -2:
 603                *writeout_error = 1;
 604                /*
 605                 * We return 0 nevertheless, as the index is all right
 606                 * and more importantly we have made best efforts to
 607                 * update paths in the work tree, and we cannot revert
 608                 * them.
 609                 */
 610                /* fallthrough */
 611        case 0:
 612                return 0;
 613        default:
 614                return 128;
 615        }
 616}
 617
 618struct branch_info {
 619        const char *name; /* The short name used */
 620        const char *path; /* The full name of a real branch */
 621        struct commit *commit; /* The named commit */
 622        /*
 623         * if not null the branch is detached because it's already
 624         * checked out in this checkout
 625         */
 626        char *checkout;
 627};
 628
 629static void setup_branch_path(struct branch_info *branch)
 630{
 631        struct strbuf buf = STRBUF_INIT;
 632
 633        strbuf_branchname(&buf, branch->name, INTERPRET_BRANCH_LOCAL);
 634        if (strcmp(buf.buf, branch->name))
 635                branch->name = xstrdup(buf.buf);
 636        strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 637        branch->path = strbuf_detach(&buf, NULL);
 638}
 639
 640static int merge_working_tree(const struct checkout_opts *opts,
 641                              struct branch_info *old_branch_info,
 642                              struct branch_info *new_branch_info,
 643                              int *writeout_error)
 644{
 645        int ret;
 646        struct lock_file lock_file = LOCK_INIT;
 647        struct tree *new_tree;
 648
 649        hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
 650        if (read_cache_preload(NULL) < 0)
 651                return error(_("index file corrupt"));
 652
 653        resolve_undo_clear();
 654        if (opts->new_orphan_branch && opts->orphan_from_empty_tree) {
 655                if (new_branch_info->commit)
 656                        BUG("'switch --orphan' should never accept a commit as starting point");
 657                new_tree = parse_tree_indirect(the_hash_algo->empty_tree);
 658        } else
 659                new_tree = get_commit_tree(new_branch_info->commit);
 660        if (opts->discard_changes) {
 661                ret = reset_tree(new_tree, opts, 1, writeout_error);
 662                if (ret)
 663                        return ret;
 664        } else {
 665                struct tree_desc trees[2];
 666                struct tree *tree;
 667                struct unpack_trees_options topts;
 668
 669                memset(&topts, 0, sizeof(topts));
 670                topts.head_idx = -1;
 671                topts.src_index = &the_index;
 672                topts.dst_index = &the_index;
 673
 674                setup_unpack_trees_porcelain(&topts, "checkout");
 675
 676                refresh_cache(REFRESH_QUIET);
 677
 678                if (unmerged_cache()) {
 679                        error(_("you need to resolve your current index first"));
 680                        return 1;
 681                }
 682
 683                /* 2-way merge to the new branch */
 684                topts.initial_checkout = is_cache_unborn();
 685                topts.update = 1;
 686                topts.merge = 1;
 687                topts.quiet = opts->merge && old_branch_info->commit;
 688                topts.verbose_update = opts->show_progress;
 689                topts.fn = twoway_merge;
 690                if (opts->overwrite_ignore) {
 691                        topts.dir = xcalloc(1, sizeof(*topts.dir));
 692                        topts.dir->flags |= DIR_SHOW_IGNORED;
 693                        setup_standard_excludes(topts.dir);
 694                }
 695                tree = parse_tree_indirect(old_branch_info->commit ?
 696                                           &old_branch_info->commit->object.oid :
 697                                           the_hash_algo->empty_tree);
 698                init_tree_desc(&trees[0], tree->buffer, tree->size);
 699                parse_tree(new_tree);
 700                tree = new_tree;
 701                init_tree_desc(&trees[1], tree->buffer, tree->size);
 702
 703                ret = unpack_trees(2, trees, &topts);
 704                clear_unpack_trees_porcelain(&topts);
 705                if (ret == -1) {
 706                        /*
 707                         * Unpack couldn't do a trivial merge; either
 708                         * give up or do a real merge, depending on
 709                         * whether the merge flag was used.
 710                         */
 711                        struct tree *result;
 712                        struct tree *work;
 713                        struct tree *old_tree;
 714                        struct merge_options o;
 715                        struct strbuf sb = STRBUF_INIT;
 716
 717                        if (!opts->merge)
 718                                return 1;
 719
 720                        /*
 721                         * Without old_branch_info->commit, the below is the same as
 722                         * the two-tree unpack we already tried and failed.
 723                         */
 724                        if (!old_branch_info->commit)
 725                                return 1;
 726                        old_tree = get_commit_tree(old_branch_info->commit);
 727
 728                        if (repo_index_has_changes(the_repository, old_tree, &sb))
 729                                die(_("cannot continue with staged changes in "
 730                                      "the following files:\n%s"), sb.buf);
 731                        strbuf_release(&sb);
 732
 733                        if (repo_index_has_changes(the_repository,
 734                                                   get_commit_tree(old_branch_info->commit),
 735                                                   &sb))
 736                                warning(_("staged changes in the following files may be lost: %s"),
 737                                        sb.buf);
 738                        strbuf_release(&sb);
 739
 740                        /* Do more real merge */
 741
 742                        /*
 743                         * We update the index fully, then write the
 744                         * tree from the index, then merge the new
 745                         * branch with the current tree, with the old
 746                         * branch as the base. Then we reset the index
 747                         * (but not the working tree) to the new
 748                         * branch, leaving the working tree as the
 749                         * merged version, but skipping unmerged
 750                         * entries in the index.
 751                         */
 752
 753                        add_files_to_cache(NULL, NULL, 0);
 754                        /*
 755                         * NEEDSWORK: carrying over local changes
 756                         * when branches have different end-of-line
 757                         * normalization (or clean+smudge rules) is
 758                         * a pain; plumb in an option to set
 759                         * o.renormalize?
 760                         */
 761                        init_merge_options(&o, the_repository);
 762                        o.verbosity = 0;
 763                        work = write_tree_from_memory(&o);
 764
 765                        ret = reset_tree(new_tree,
 766                                         opts, 1,
 767                                         writeout_error);
 768                        if (ret)
 769                                return ret;
 770                        o.ancestor = old_branch_info->name;
 771                        o.branch1 = new_branch_info->name;
 772                        o.branch2 = "local";
 773                        ret = merge_trees(&o,
 774                                          new_tree,
 775                                          work,
 776                                          old_tree,
 777                                          &result);
 778                        if (ret < 0)
 779                                exit(128);
 780                        ret = reset_tree(new_tree,
 781                                         opts, 0,
 782                                         writeout_error);
 783                        strbuf_release(&o.obuf);
 784                        if (ret)
 785                                return ret;
 786                }
 787        }
 788
 789        if (!active_cache_tree)
 790                active_cache_tree = cache_tree();
 791
 792        if (!cache_tree_fully_valid(active_cache_tree))
 793                cache_tree_update(&the_index, WRITE_TREE_SILENT | WRITE_TREE_REPAIR);
 794
 795        if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
 796                die(_("unable to write new index file"));
 797
 798        if (!opts->discard_changes && !opts->quiet && new_branch_info->commit)
 799                show_local_changes(&new_branch_info->commit->object, &opts->diff_options);
 800
 801        return 0;
 802}
 803
 804static void report_tracking(struct branch_info *new_branch_info)
 805{
 806        struct strbuf sb = STRBUF_INIT;
 807        struct branch *branch = branch_get(new_branch_info->name);
 808
 809        if (!format_tracking_info(branch, &sb, AHEAD_BEHIND_FULL))
 810                return;
 811        fputs(sb.buf, stdout);
 812        strbuf_release(&sb);
 813}
 814
 815static void update_refs_for_switch(const struct checkout_opts *opts,
 816                                   struct branch_info *old_branch_info,
 817                                   struct branch_info *new_branch_info)
 818{
 819        struct strbuf msg = STRBUF_INIT;
 820        const char *old_desc, *reflog_msg;
 821        if (opts->new_branch) {
 822                if (opts->new_orphan_branch) {
 823                        char *refname;
 824
 825                        refname = mkpathdup("refs/heads/%s", opts->new_orphan_branch);
 826                        if (opts->new_branch_log &&
 827                            !should_autocreate_reflog(refname)) {
 828                                int ret;
 829                                struct strbuf err = STRBUF_INIT;
 830
 831                                ret = safe_create_reflog(refname, 1, &err);
 832                                if (ret) {
 833                                        fprintf(stderr, _("Can not do reflog for '%s': %s\n"),
 834                                                opts->new_orphan_branch, err.buf);
 835                                        strbuf_release(&err);
 836                                        free(refname);
 837                                        return;
 838                                }
 839                                strbuf_release(&err);
 840                        }
 841                        free(refname);
 842                }
 843                else
 844                        create_branch(the_repository,
 845                                      opts->new_branch, new_branch_info->name,
 846                                      opts->new_branch_force ? 1 : 0,
 847                                      opts->new_branch_force ? 1 : 0,
 848                                      opts->new_branch_log,
 849                                      opts->quiet,
 850                                      opts->track);
 851                new_branch_info->name = opts->new_branch;
 852                setup_branch_path(new_branch_info);
 853        }
 854
 855        old_desc = old_branch_info->name;
 856        if (!old_desc && old_branch_info->commit)
 857                old_desc = oid_to_hex(&old_branch_info->commit->object.oid);
 858
 859        reflog_msg = getenv("GIT_REFLOG_ACTION");
 860        if (!reflog_msg)
 861                strbuf_addf(&msg, "checkout: moving from %s to %s",
 862                        old_desc ? old_desc : "(invalid)", new_branch_info->name);
 863        else
 864                strbuf_insert(&msg, 0, reflog_msg, strlen(reflog_msg));
 865
 866        if (!strcmp(new_branch_info->name, "HEAD") && !new_branch_info->path && !opts->force_detach) {
 867                /* Nothing to do. */
 868        } else if (opts->force_detach || !new_branch_info->path) {      /* No longer on any branch. */
 869                update_ref(msg.buf, "HEAD", &new_branch_info->commit->object.oid, NULL,
 870                           REF_NO_DEREF, UPDATE_REFS_DIE_ON_ERR);
 871                if (!opts->quiet) {
 872                        if (old_branch_info->path &&
 873                            advice_detached_head && !opts->force_detach)
 874                                detach_advice(new_branch_info->name);
 875                        describe_detached_head(_("HEAD is now at"), new_branch_info->commit);
 876                }
 877        } else if (new_branch_info->path) {     /* Switch branches. */
 878                if (create_symref("HEAD", new_branch_info->path, msg.buf) < 0)
 879                        die(_("unable to update HEAD"));
 880                if (!opts->quiet) {
 881                        if (old_branch_info->path && !strcmp(new_branch_info->path, old_branch_info->path)) {
 882                                if (opts->new_branch_force)
 883                                        fprintf(stderr, _("Reset branch '%s'\n"),
 884                                                new_branch_info->name);
 885                                else
 886                                        fprintf(stderr, _("Already on '%s'\n"),
 887                                                new_branch_info->name);
 888                        } else if (opts->new_branch) {
 889                                if (opts->branch_exists)
 890                                        fprintf(stderr, _("Switched to and reset branch '%s'\n"), new_branch_info->name);
 891                                else
 892                                        fprintf(stderr, _("Switched to a new branch '%s'\n"), new_branch_info->name);
 893                        } else {
 894                                fprintf(stderr, _("Switched to branch '%s'\n"),
 895                                        new_branch_info->name);
 896                        }
 897                }
 898                if (old_branch_info->path && old_branch_info->name) {
 899                        if (!ref_exists(old_branch_info->path) && reflog_exists(old_branch_info->path))
 900                                delete_reflog(old_branch_info->path);
 901                }
 902        }
 903        remove_branch_state(the_repository, !opts->quiet);
 904        strbuf_release(&msg);
 905        if (!opts->quiet &&
 906            (new_branch_info->path || (!opts->force_detach && !strcmp(new_branch_info->name, "HEAD"))))
 907                report_tracking(new_branch_info);
 908}
 909
 910static int add_pending_uninteresting_ref(const char *refname,
 911                                         const struct object_id *oid,
 912                                         int flags, void *cb_data)
 913{
 914        add_pending_oid(cb_data, refname, oid, UNINTERESTING);
 915        return 0;
 916}
 917
 918static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
 919{
 920        strbuf_addstr(sb, "  ");
 921        strbuf_add_unique_abbrev(sb, &commit->object.oid, DEFAULT_ABBREV);
 922        strbuf_addch(sb, ' ');
 923        if (!parse_commit(commit))
 924                pp_commit_easy(CMIT_FMT_ONELINE, commit, sb);
 925        strbuf_addch(sb, '\n');
 926}
 927
 928#define ORPHAN_CUTOFF 4
 929static void suggest_reattach(struct commit *commit, struct rev_info *revs)
 930{
 931        struct commit *c, *last = NULL;
 932        struct strbuf sb = STRBUF_INIT;
 933        int lost = 0;
 934        while ((c = get_revision(revs)) != NULL) {
 935                if (lost < ORPHAN_CUTOFF)
 936                        describe_one_orphan(&sb, c);
 937                last = c;
 938                lost++;
 939        }
 940        if (ORPHAN_CUTOFF < lost) {
 941                int more = lost - ORPHAN_CUTOFF;
 942                if (more == 1)
 943                        describe_one_orphan(&sb, last);
 944                else
 945                        strbuf_addf(&sb, _(" ... and %d more.\n"), more);
 946        }
 947
 948        fprintf(stderr,
 949                Q_(
 950                /* The singular version */
 951                "Warning: you are leaving %d commit behind, "
 952                "not connected to\n"
 953                "any of your branches:\n\n"
 954                "%s\n",
 955                /* The plural version */
 956                "Warning: you are leaving %d commits behind, "
 957                "not connected to\n"
 958                "any of your branches:\n\n"
 959                "%s\n",
 960                /* Give ngettext() the count */
 961                lost),
 962                lost,
 963                sb.buf);
 964        strbuf_release(&sb);
 965
 966        if (advice_detached_head)
 967                fprintf(stderr,
 968                        Q_(
 969                        /* The singular version */
 970                        "If you want to keep it by creating a new branch, "
 971                        "this may be a good time\nto do so with:\n\n"
 972                        " git branch <new-branch-name> %s\n\n",
 973                        /* The plural version */
 974                        "If you want to keep them by creating a new branch, "
 975                        "this may be a good time\nto do so with:\n\n"
 976                        " git branch <new-branch-name> %s\n\n",
 977                        /* Give ngettext() the count */
 978                        lost),
 979                        find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV));
 980}
 981
 982/*
 983 * We are about to leave commit that was at the tip of a detached
 984 * HEAD.  If it is not reachable from any ref, this is the last chance
 985 * for the user to do so without resorting to reflog.
 986 */
 987static void orphaned_commit_warning(struct commit *old_commit, struct commit *new_commit)
 988{
 989        struct rev_info revs;
 990        struct object *object = &old_commit->object;
 991
 992        repo_init_revisions(the_repository, &revs, NULL);
 993        setup_revisions(0, NULL, &revs, NULL);
 994
 995        object->flags &= ~UNINTERESTING;
 996        add_pending_object(&revs, object, oid_to_hex(&object->oid));
 997
 998        for_each_ref(add_pending_uninteresting_ref, &revs);
 999        if (new_commit)
1000                add_pending_oid(&revs, "HEAD",
1001                                &new_commit->object.oid,
1002                                UNINTERESTING);
1003
1004        if (prepare_revision_walk(&revs))
1005                die(_("internal error in revision walk"));
1006        if (!(old_commit->object.flags & UNINTERESTING))
1007                suggest_reattach(old_commit, &revs);
1008        else
1009                describe_detached_head(_("Previous HEAD position was"), old_commit);
1010
1011        /* Clean up objects used, as they will be reused. */
1012        clear_commit_marks_all(ALL_REV_FLAGS);
1013}
1014
1015static int switch_branches(const struct checkout_opts *opts,
1016                           struct branch_info *new_branch_info)
1017{
1018        int ret = 0;
1019        struct branch_info old_branch_info;
1020        void *path_to_free;
1021        struct object_id rev;
1022        int flag, writeout_error = 0;
1023        int do_merge = 1;
1024
1025        trace2_cmd_mode("branch");
1026
1027        memset(&old_branch_info, 0, sizeof(old_branch_info));
1028        old_branch_info.path = path_to_free = resolve_refdup("HEAD", 0, &rev, &flag);
1029        if (old_branch_info.path)
1030                old_branch_info.commit = lookup_commit_reference_gently(the_repository, &rev, 1);
1031        if (!(flag & REF_ISSYMREF))
1032                old_branch_info.path = NULL;
1033
1034        if (old_branch_info.path)
1035                skip_prefix(old_branch_info.path, "refs/heads/", &old_branch_info.name);
1036
1037        if (opts->new_orphan_branch && opts->orphan_from_empty_tree) {
1038                if (new_branch_info->name)
1039                        BUG("'switch --orphan' should never accept a commit as starting point");
1040                new_branch_info->commit = NULL;
1041                new_branch_info->name = "(empty)";
1042                do_merge = 1;
1043        }
1044
1045        if (!new_branch_info->name) {
1046                new_branch_info->name = "HEAD";
1047                new_branch_info->commit = old_branch_info.commit;
1048                if (!new_branch_info->commit)
1049                        die(_("You are on a branch yet to be born"));
1050                parse_commit_or_die(new_branch_info->commit);
1051
1052                if (opts->only_merge_on_switching_branches)
1053                        do_merge = 0;
1054        }
1055
1056        if (do_merge) {
1057                ret = merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);
1058                if (ret) {
1059                        free(path_to_free);
1060                        return ret;
1061                }
1062        }
1063
1064        if (!opts->quiet && !old_branch_info.path && old_branch_info.commit && new_branch_info->commit != old_branch_info.commit)
1065                orphaned_commit_warning(old_branch_info.commit, new_branch_info->commit);
1066
1067        update_refs_for_switch(opts, &old_branch_info, new_branch_info);
1068
1069        ret = post_checkout_hook(old_branch_info.commit, new_branch_info->commit, 1);
1070        free(path_to_free);
1071        return ret || writeout_error;
1072}
1073
1074static int git_checkout_config(const char *var, const char *value, void *cb)
1075{
1076        if (!strcmp(var, "diff.ignoresubmodules")) {
1077                struct checkout_opts *opts = cb;
1078                handle_ignore_submodules_arg(&opts->diff_options, value);
1079                return 0;
1080        }
1081
1082        if (starts_with(var, "submodule."))
1083                return git_default_submodule_config(var, value, NULL);
1084
1085        return git_xmerge_config(var, value, NULL);
1086}
1087
1088static void setup_new_branch_info_and_source_tree(
1089        struct branch_info *new_branch_info,
1090        struct checkout_opts *opts,
1091        struct object_id *rev,
1092        const char *arg)
1093{
1094        struct tree **source_tree = &opts->source_tree;
1095        struct object_id branch_rev;
1096
1097        new_branch_info->name = arg;
1098        setup_branch_path(new_branch_info);
1099
1100        if (!check_refname_format(new_branch_info->path, 0) &&
1101            !read_ref(new_branch_info->path, &branch_rev))
1102                oidcpy(rev, &branch_rev);
1103        else
1104                new_branch_info->path = NULL; /* not an existing branch */
1105
1106        new_branch_info->commit = lookup_commit_reference_gently(the_repository, rev, 1);
1107        if (!new_branch_info->commit) {
1108                /* not a commit */
1109                *source_tree = parse_tree_indirect(rev);
1110        } else {
1111                parse_commit_or_die(new_branch_info->commit);
1112                *source_tree = get_commit_tree(new_branch_info->commit);
1113        }
1114}
1115
1116static int parse_branchname_arg(int argc, const char **argv,
1117                                int dwim_new_local_branch_ok,
1118                                struct branch_info *new_branch_info,
1119                                struct checkout_opts *opts,
1120                                struct object_id *rev,
1121                                int *dwim_remotes_matched)
1122{
1123        const char **new_branch = &opts->new_branch;
1124        int argcount = 0;
1125        const char *arg;
1126        int dash_dash_pos;
1127        int has_dash_dash = 0;
1128        int i;
1129
1130        /*
1131         * case 1: git checkout <ref> -- [<paths>]
1132         *
1133         *   <ref> must be a valid tree, everything after the '--' must be
1134         *   a path.
1135         *
1136         * case 2: git checkout -- [<paths>]
1137         *
1138         *   everything after the '--' must be paths.
1139         *
1140         * case 3: git checkout <something> [--]
1141         *
1142         *   (a) If <something> is a commit, that is to
1143         *       switch to the branch or detach HEAD at it.  As a special case,
1144         *       if <something> is A...B (missing A or B means HEAD but you can
1145         *       omit at most one side), and if there is a unique merge base
1146         *       between A and B, A...B names that merge base.
1147         *
1148         *   (b) If <something> is _not_ a commit, either "--" is present
1149         *       or <something> is not a path, no -t or -b was given, and
1150         *       and there is a tracking branch whose name is <something>
1151         *       in one and only one remote (or if the branch exists on the
1152         *       remote named in checkout.defaultRemote), then this is a
1153         *       short-hand to fork local <something> from that
1154         *       remote-tracking branch.
1155         *
1156         *   (c) Otherwise, if "--" is present, treat it like case (1).
1157         *
1158         *   (d) Otherwise :
1159         *       - if it's a reference, treat it like case (1)
1160         *       - else if it's a path, treat it like case (2)
1161         *       - else: fail.
1162         *
1163         * case 4: git checkout <something> <paths>
1164         *
1165         *   The first argument must not be ambiguous.
1166         *   - If it's *only* a reference, treat it like case (1).
1167         *   - If it's only a path, treat it like case (2).
1168         *   - else: fail.
1169         *
1170         */
1171        if (!argc)
1172                return 0;
1173
1174        if (!opts->accept_pathspec) {
1175                if (argc > 1)
1176                        die(_("only one reference expected"));
1177                has_dash_dash = 1; /* helps disambiguate */
1178        }
1179
1180        arg = argv[0];
1181        dash_dash_pos = -1;
1182        for (i = 0; i < argc; i++) {
1183                if (opts->accept_pathspec && !strcmp(argv[i], "--")) {
1184                        dash_dash_pos = i;
1185                        break;
1186                }
1187        }
1188        if (dash_dash_pos == 0)
1189                return 1; /* case (2) */
1190        else if (dash_dash_pos == 1)
1191                has_dash_dash = 1; /* case (3) or (1) */
1192        else if (dash_dash_pos >= 2)
1193                die(_("only one reference expected, %d given."), dash_dash_pos);
1194        opts->count_checkout_paths = !opts->quiet && !has_dash_dash;
1195
1196        if (!strcmp(arg, "-"))
1197                arg = "@{-1}";
1198
1199        if (get_oid_mb(arg, rev)) {
1200                /*
1201                 * Either case (3) or (4), with <something> not being
1202                 * a commit, or an attempt to use case (1) with an
1203                 * invalid ref.
1204                 *
1205                 * It's likely an error, but we need to find out if
1206                 * we should auto-create the branch, case (3).(b).
1207                 */
1208                int recover_with_dwim = dwim_new_local_branch_ok;
1209
1210                int could_be_checkout_paths = !has_dash_dash &&
1211                        check_filename(opts->prefix, arg);
1212
1213                if (!has_dash_dash && !no_wildcard(arg))
1214                        recover_with_dwim = 0;
1215
1216                /*
1217                 * Accept "git checkout foo", "git checkout foo --"
1218                 * and "git switch foo" as candidates for dwim.
1219                 */
1220                if (!(argc == 1 && !has_dash_dash) &&
1221                    !(argc == 2 && has_dash_dash) &&
1222                    opts->accept_pathspec)
1223                        recover_with_dwim = 0;
1224
1225                if (recover_with_dwim) {
1226                        const char *remote = unique_tracking_name(arg, rev,
1227                                                                  dwim_remotes_matched);
1228                        if (remote) {
1229                                if (could_be_checkout_paths)
1230                                        die(_("'%s' could be both a local file and a tracking branch.\n"
1231                                              "Please use -- (and optionally --no-guess) to disambiguate"),
1232                                            arg);
1233                                *new_branch = arg;
1234                                arg = remote;
1235                                /* DWIMmed to create local branch, case (3).(b) */
1236                        } else {
1237                                recover_with_dwim = 0;
1238                        }
1239                }
1240
1241                if (!recover_with_dwim) {
1242                        if (has_dash_dash)
1243                                die(_("invalid reference: %s"), arg);
1244                        return argcount;
1245                }
1246        }
1247
1248        /* we can't end up being in (2) anymore, eat the argument */
1249        argcount++;
1250        argv++;
1251        argc--;
1252
1253        setup_new_branch_info_and_source_tree(new_branch_info, opts, rev, arg);
1254
1255        if (!opts->source_tree)                   /* case (1): want a tree */
1256                die(_("reference is not a tree: %s"), arg);
1257
1258        if (!has_dash_dash) {   /* case (3).(d) -> (1) */
1259                /*
1260                 * Do not complain the most common case
1261                 *      git checkout branch
1262                 * even if there happen to be a file called 'branch';
1263                 * it would be extremely annoying.
1264                 */
1265                if (argc)
1266                        verify_non_filename(opts->prefix, arg);
1267        } else if (opts->accept_pathspec) {
1268                argcount++;
1269                argv++;
1270                argc--;
1271        }
1272
1273        return argcount;
1274}
1275
1276static int switch_unborn_to_new_branch(const struct checkout_opts *opts)
1277{
1278        int status;
1279        struct strbuf branch_ref = STRBUF_INIT;
1280
1281        trace2_cmd_mode("unborn");
1282
1283        if (!opts->new_branch)
1284                die(_("You are on a branch yet to be born"));
1285        strbuf_addf(&branch_ref, "refs/heads/%s", opts->new_branch);
1286        status = create_symref("HEAD", branch_ref.buf, "checkout -b");
1287        strbuf_release(&branch_ref);
1288        if (!opts->quiet)
1289                fprintf(stderr, _("Switched to a new branch '%s'\n"),
1290                        opts->new_branch);
1291        return status;
1292}
1293
1294static void die_expecting_a_branch(const struct branch_info *branch_info)
1295{
1296        struct object_id oid;
1297        char *to_free;
1298
1299        if (dwim_ref(branch_info->name, strlen(branch_info->name), &oid, &to_free) == 1) {
1300                const char *ref = to_free;
1301
1302                if (skip_prefix(ref, "refs/tags/", &ref))
1303                        die(_("a branch is expected, got tag '%s'"), ref);
1304                if (skip_prefix(ref, "refs/remotes/", &ref))
1305                        die(_("a branch is expected, got remote branch '%s'"), ref);
1306                die(_("a branch is expected, got '%s'"), ref);
1307        }
1308        if (branch_info->commit)
1309                die(_("a branch is expected, got commit '%s'"), branch_info->name);
1310        /*
1311         * This case should never happen because we already die() on
1312         * non-commit, but just in case.
1313         */
1314        die(_("a branch is expected, got '%s'"), branch_info->name);
1315}
1316
1317static void die_if_some_operation_in_progress(void)
1318{
1319        struct wt_status_state state;
1320
1321        memset(&state, 0, sizeof(state));
1322        wt_status_get_state(the_repository, &state, 0);
1323
1324        if (state.merge_in_progress)
1325                die(_("cannot switch branch while merging\n"
1326                      "Consider \"git merge --quit\" "
1327                      "or \"git worktree add\"."));
1328        if (state.am_in_progress)
1329                die(_("cannot switch branch in the middle of an am session\n"
1330                      "Consider \"git am --quit\" "
1331                      "or \"git worktree add\"."));
1332        if (state.rebase_interactive_in_progress || state.rebase_in_progress)
1333                die(_("cannot switch branch while rebasing\n"
1334                      "Consider \"git rebase --quit\" "
1335                      "or \"git worktree add\"."));
1336        if (state.cherry_pick_in_progress)
1337                die(_("cannot switch branch while cherry-picking\n"
1338                      "Consider \"git cherry-pick --quit\" "
1339                      "or \"git worktree add\"."));
1340        if (state.revert_in_progress)
1341                die(_("cannot switch branch while reverting\n"
1342                      "Consider \"git revert --quit\" "
1343                      "or \"git worktree add\"."));
1344        if (state.bisect_in_progress)
1345                warning(_("you are switching branch while bisecting"));
1346}
1347
1348static int checkout_branch(struct checkout_opts *opts,
1349                           struct branch_info *new_branch_info)
1350{
1351        if (opts->pathspec.nr)
1352                die(_("paths cannot be used with switching branches"));
1353
1354        if (opts->patch_mode)
1355                die(_("'%s' cannot be used with switching branches"),
1356                    "--patch");
1357
1358        if (opts->overlay_mode != -1)
1359                die(_("'%s' cannot be used with switching branches"),
1360                    "--[no]-overlay");
1361
1362        if (opts->writeout_stage)
1363                die(_("'%s' cannot be used with switching branches"),
1364                    "--ours/--theirs");
1365
1366        if (opts->force && opts->merge)
1367                die(_("'%s' cannot be used with '%s'"), "-f", "-m");
1368
1369        if (opts->discard_changes && opts->merge)
1370                die(_("'%s' cannot be used with '%s'"), "--discard-changes", "--merge");
1371
1372        if (opts->force_detach && opts->new_branch)
1373                die(_("'%s' cannot be used with '%s'"),
1374                    "--detach", "-b/-B/--orphan");
1375
1376        if (opts->new_orphan_branch) {
1377                if (opts->track != BRANCH_TRACK_UNSPECIFIED)
1378                        die(_("'%s' cannot be used with '%s'"), "--orphan", "-t");
1379                if (opts->orphan_from_empty_tree && new_branch_info->name)
1380                        die(_("'%s' cannot take <start-point>"), "--orphan");
1381        } else if (opts->force_detach) {
1382                if (opts->track != BRANCH_TRACK_UNSPECIFIED)
1383                        die(_("'%s' cannot be used with '%s'"), "--detach", "-t");
1384        } else if (opts->track == BRANCH_TRACK_UNSPECIFIED)
1385                opts->track = git_branch_track;
1386
1387        if (new_branch_info->name && !new_branch_info->commit)
1388                die(_("Cannot switch branch to a non-commit '%s'"),
1389                    new_branch_info->name);
1390
1391        if (!opts->switch_branch_doing_nothing_is_ok &&
1392            !new_branch_info->name &&
1393            !opts->new_branch &&
1394            !opts->force_detach)
1395                die(_("missing branch or commit argument"));
1396
1397        if (!opts->implicit_detach &&
1398            !opts->force_detach &&
1399            !opts->new_branch &&
1400            !opts->new_branch_force &&
1401            new_branch_info->name &&
1402            !new_branch_info->path)
1403                die_expecting_a_branch(new_branch_info);
1404
1405        if (!opts->can_switch_when_in_progress)
1406                die_if_some_operation_in_progress();
1407
1408        if (new_branch_info->path && !opts->force_detach && !opts->new_branch &&
1409            !opts->ignore_other_worktrees) {
1410                int flag;
1411                char *head_ref = resolve_refdup("HEAD", 0, NULL, &flag);
1412                if (head_ref &&
1413                    (!(flag & REF_ISSYMREF) || strcmp(head_ref, new_branch_info->path)))
1414                        die_if_checked_out(new_branch_info->path, 1);
1415                free(head_ref);
1416        }
1417
1418        if (!new_branch_info->commit && opts->new_branch) {
1419                struct object_id rev;
1420                int flag;
1421
1422                if (!read_ref_full("HEAD", 0, &rev, &flag) &&
1423                    (flag & REF_ISSYMREF) && is_null_oid(&rev))
1424                        return switch_unborn_to_new_branch(opts);
1425        }
1426        return switch_branches(opts, new_branch_info);
1427}
1428
1429static struct option *add_common_options(struct checkout_opts *opts,
1430                                         struct option *prevopts)
1431{
1432        struct option options[] = {
1433                OPT__QUIET(&opts->quiet, N_("suppress progress reporting")),
1434                { OPTION_CALLBACK, 0, "recurse-submodules", NULL,
1435                            "checkout", "control recursive updating of submodules",
1436                            PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater },
1437                OPT_BOOL(0, "progress", &opts->show_progress, N_("force progress reporting")),
1438                OPT_BOOL('m', "merge", &opts->merge, N_("perform a 3-way merge with the new branch")),
1439                OPT_STRING(0, "conflict", &opts->conflict_style, N_("style"),
1440                           N_("conflict style (merge or diff3)")),
1441                OPT_END()
1442        };
1443        struct option *newopts = parse_options_concat(prevopts, options);
1444        free(prevopts);
1445        return newopts;
1446}
1447
1448static struct option *add_common_switch_branch_options(
1449        struct checkout_opts *opts, struct option *prevopts)
1450{
1451        struct option options[] = {
1452                OPT_BOOL('d', "detach", &opts->force_detach, N_("detach HEAD at named commit")),
1453                OPT_SET_INT('t', "track",  &opts->track, N_("set upstream info for new branch"),
1454                        BRANCH_TRACK_EXPLICIT),
1455                OPT__FORCE(&opts->force, N_("force checkout (throw away local modifications)"),
1456                           PARSE_OPT_NOCOMPLETE),
1457                OPT_STRING(0, "orphan", &opts->new_orphan_branch, N_("new-branch"), N_("new unparented branch")),
1458                OPT_BOOL_F(0, "overwrite-ignore", &opts->overwrite_ignore,
1459                           N_("update ignored files (default)"),
1460                           PARSE_OPT_NOCOMPLETE),
1461                OPT_BOOL(0, "ignore-other-worktrees", &opts->ignore_other_worktrees,
1462                         N_("do not check if another worktree is holding the given ref")),
1463                OPT_END()
1464        };
1465        struct option *newopts = parse_options_concat(prevopts, options);
1466        free(prevopts);
1467        return newopts;
1468}
1469
1470static struct option *add_checkout_path_options(struct checkout_opts *opts,
1471                                                struct option *prevopts)
1472{
1473        struct option options[] = {
1474                OPT_SET_INT_F('2', "ours", &opts->writeout_stage,
1475                              N_("checkout our version for unmerged files"),
1476                              2, PARSE_OPT_NONEG),
1477                OPT_SET_INT_F('3', "theirs", &opts->writeout_stage,
1478                              N_("checkout their version for unmerged files"),
1479                              3, PARSE_OPT_NONEG),
1480                OPT_BOOL('p', "patch", &opts->patch_mode, N_("select hunks interactively")),
1481                OPT_BOOL(0, "ignore-skip-worktree-bits", &opts->ignore_skipworktree,
1482                         N_("do not limit pathspecs to sparse entries only")),
1483                OPT_END()
1484        };
1485        struct option *newopts = parse_options_concat(prevopts, options);
1486        free(prevopts);
1487        return newopts;
1488}
1489
1490static int checkout_main(int argc, const char **argv, const char *prefix,
1491                         struct checkout_opts *opts, struct option *options,
1492                         const char * const usagestr[])
1493{
1494        struct branch_info new_branch_info;
1495        int dwim_remotes_matched = 0;
1496        int parseopt_flags = 0;
1497
1498        memset(&new_branch_info, 0, sizeof(new_branch_info));
1499        opts->overwrite_ignore = 1;
1500        opts->prefix = prefix;
1501        opts->show_progress = -1;
1502
1503        git_config(git_checkout_config, opts);
1504
1505        opts->track = BRANCH_TRACK_UNSPECIFIED;
1506
1507        if (!opts->accept_pathspec && !opts->accept_ref)
1508                BUG("make up your mind, you need to take _something_");
1509        if (opts->accept_pathspec && opts->accept_ref)
1510                parseopt_flags = PARSE_OPT_KEEP_DASHDASH;
1511
1512        argc = parse_options(argc, argv, prefix, options,
1513                             usagestr, parseopt_flags);
1514
1515        if (opts->show_progress < 0) {
1516                if (opts->quiet)
1517                        opts->show_progress = 0;
1518                else
1519                        opts->show_progress = isatty(2);
1520        }
1521
1522        if (opts->conflict_style) {
1523                opts->merge = 1; /* implied */
1524                git_xmerge_config("merge.conflictstyle", opts->conflict_style, NULL);
1525        }
1526        if (opts->force) {
1527                opts->discard_changes = 1;
1528                opts->ignore_unmerged_opt = "--force";
1529                opts->ignore_unmerged = 1;
1530        }
1531
1532        if ((!!opts->new_branch + !!opts->new_branch_force + !!opts->new_orphan_branch) > 1)
1533                die(_("-b, -B and --orphan are mutually exclusive"));
1534
1535        if (opts->overlay_mode == 1 && opts->patch_mode)
1536                die(_("-p and --overlay are mutually exclusive"));
1537
1538        if (opts->checkout_index >= 0 || opts->checkout_worktree >= 0) {
1539                if (opts->checkout_index < 0)
1540                        opts->checkout_index = 0;
1541                if (opts->checkout_worktree < 0)
1542                        opts->checkout_worktree = 0;
1543        } else {
1544                if (opts->checkout_index < 0)
1545                        opts->checkout_index = -opts->checkout_index - 1;
1546                if (opts->checkout_worktree < 0)
1547                        opts->checkout_worktree = -opts->checkout_worktree - 1;
1548        }
1549        if (opts->checkout_index < 0 || opts->checkout_worktree < 0)
1550                BUG("these flags should be non-negative by now");
1551        /*
1552         * convenient shortcut: "git restore --staged" equals
1553         * "git restore --staged --source HEAD"
1554         */
1555        if (!opts->from_treeish && opts->checkout_index && !opts->checkout_worktree)
1556                opts->from_treeish = "HEAD";
1557
1558        /*
1559         * From here on, new_branch will contain the branch to be checked out,
1560         * and new_branch_force and new_orphan_branch will tell us which one of
1561         * -b/-B/--orphan is being used.
1562         */
1563        if (opts->new_branch_force)
1564                opts->new_branch = opts->new_branch_force;
1565
1566        if (opts->new_orphan_branch)
1567                opts->new_branch = opts->new_orphan_branch;
1568
1569        /* --track without -b/-B/--orphan should DWIM */
1570        if (opts->track != BRANCH_TRACK_UNSPECIFIED && !opts->new_branch) {
1571                const char *argv0 = argv[0];
1572                if (!argc || !strcmp(argv0, "--"))
1573                        die(_("--track needs a branch name"));
1574                skip_prefix(argv0, "refs/", &argv0);
1575                skip_prefix(argv0, "remotes/", &argv0);
1576                argv0 = strchr(argv0, '/');
1577                if (!argv0 || !argv0[1])
1578                        die(_("missing branch name; try -b"));
1579                opts->new_branch = argv0 + 1;
1580        }
1581
1582        /*
1583         * Extract branch name from command line arguments, so
1584         * all that is left is pathspecs.
1585         *
1586         * Handle
1587         *
1588         *  1) git checkout <tree> -- [<paths>]
1589         *  2) git checkout -- [<paths>]
1590         *  3) git checkout <something> [<paths>]
1591         *
1592         * including "last branch" syntax and DWIM-ery for names of
1593         * remote branches, erroring out for invalid or ambiguous cases.
1594         */
1595        if (argc && opts->accept_ref) {
1596                struct object_id rev;
1597                int dwim_ok =
1598                        !opts->patch_mode &&
1599                        opts->dwim_new_local_branch &&
1600                        opts->track == BRANCH_TRACK_UNSPECIFIED &&
1601                        !opts->new_branch;
1602                int n = parse_branchname_arg(argc, argv, dwim_ok,
1603                                             &new_branch_info, opts, &rev,
1604                                             &dwim_remotes_matched);
1605                argv += n;
1606                argc -= n;
1607        } else if (!opts->accept_ref && opts->from_treeish) {
1608                struct object_id rev;
1609
1610                if (get_oid_mb(opts->from_treeish, &rev))
1611                        die(_("could not resolve %s"), opts->from_treeish);
1612
1613                setup_new_branch_info_and_source_tree(&new_branch_info,
1614                                                      opts, &rev,
1615                                                      opts->from_treeish);
1616
1617                if (!opts->source_tree)
1618                        die(_("reference is not a tree: %s"), opts->from_treeish);
1619        }
1620
1621        if (opts->accept_pathspec && !opts->empty_pathspec_ok && !argc &&
1622            !opts->patch_mode)  /* patch mode is special */
1623                die(_("you must specify path(s) to restore"));
1624
1625        if (argc) {
1626                parse_pathspec(&opts->pathspec, 0,
1627                               opts->patch_mode ? PATHSPEC_PREFIX_ORIGIN : 0,
1628                               prefix, argv);
1629
1630                if (!opts->pathspec.nr)
1631                        die(_("invalid path specification"));
1632
1633                /*
1634                 * Try to give more helpful suggestion.
1635                 * new_branch && argc > 1 will be caught later.
1636                 */
1637                if (opts->new_branch && argc == 1)
1638                        die(_("'%s' is not a commit and a branch '%s' cannot be created from it"),
1639                                argv[0], opts->new_branch);
1640
1641                if (opts->force_detach)
1642                        die(_("git checkout: --detach does not take a path argument '%s'"),
1643                            argv[0]);
1644
1645                if (1 < !!opts->writeout_stage + !!opts->force + !!opts->merge)
1646                        die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\n"
1647                              "checking out of the index."));
1648        }
1649
1650        if (opts->new_branch) {
1651                struct strbuf buf = STRBUF_INIT;
1652
1653                if (opts->new_branch_force)
1654                        opts->branch_exists = validate_branchname(opts->new_branch, &buf);
1655                else
1656                        opts->branch_exists =
1657                                validate_new_branchname(opts->new_branch, &buf, 0);
1658                strbuf_release(&buf);
1659        }
1660
1661        UNLEAK(opts);
1662        if (opts->patch_mode || opts->pathspec.nr) {
1663                int ret = checkout_paths(opts, new_branch_info.name);
1664                if (ret && dwim_remotes_matched > 1 &&
1665                    advice_checkout_ambiguous_remote_branch_name)
1666                        advise(_("'%s' matched more than one remote tracking branch.\n"
1667                                 "We found %d remotes with a reference that matched. So we fell back\n"
1668                                 "on trying to resolve the argument as a path, but failed there too!\n"
1669                                 "\n"
1670                                 "If you meant to check out a remote tracking branch on, e.g. 'origin',\n"
1671                                 "you can do so by fully qualifying the name with the --track option:\n"
1672                                 "\n"
1673                                 "    git checkout --track origin/<name>\n"
1674                                 "\n"
1675                                 "If you'd like to always have checkouts of an ambiguous <name> prefer\n"
1676                                 "one remote, e.g. the 'origin' remote, consider setting\n"
1677                                 "checkout.defaultRemote=origin in your config."),
1678                               argv[0],
1679                               dwim_remotes_matched);
1680                return ret;
1681        } else {
1682                return checkout_branch(opts, &new_branch_info);
1683        }
1684}
1685
1686int cmd_checkout(int argc, const char **argv, const char *prefix)
1687{
1688        struct checkout_opts opts;
1689        struct option *options;
1690        struct option checkout_options[] = {
1691                OPT_STRING('b', NULL, &opts.new_branch, N_("branch"),
1692                           N_("create and checkout a new branch")),
1693                OPT_STRING('B', NULL, &opts.new_branch_force, N_("branch"),
1694                           N_("create/reset and checkout a branch")),
1695                OPT_BOOL('l', NULL, &opts.new_branch_log, N_("create reflog for new branch")),
1696                OPT_BOOL(0, "guess", &opts.dwim_new_local_branch,
1697                         N_("second guess 'git checkout <no-such-branch>' (default)")),
1698                OPT_BOOL(0, "overlay", &opts.overlay_mode, N_("use overlay mode (default)")),
1699                OPT_END()
1700        };
1701        int ret;
1702
1703        memset(&opts, 0, sizeof(opts));
1704        opts.dwim_new_local_branch = 1;
1705        opts.switch_branch_doing_nothing_is_ok = 1;
1706        opts.only_merge_on_switching_branches = 0;
1707        opts.accept_ref = 1;
1708        opts.accept_pathspec = 1;
1709        opts.implicit_detach = 1;
1710        opts.can_switch_when_in_progress = 1;
1711        opts.orphan_from_empty_tree = 0;
1712        opts.empty_pathspec_ok = 1;
1713        opts.overlay_mode = -1;
1714        opts.checkout_index = -2;    /* default on */
1715        opts.checkout_worktree = -2; /* default on */
1716
1717        options = parse_options_dup(checkout_options);
1718        options = add_common_options(&opts, options);
1719        options = add_common_switch_branch_options(&opts, options);
1720        options = add_checkout_path_options(&opts, options);
1721
1722        ret = checkout_main(argc, argv, prefix, &opts,
1723                            options, checkout_usage);
1724        FREE_AND_NULL(options);
1725        return ret;
1726}
1727
1728int cmd_switch(int argc, const char **argv, const char *prefix)
1729{
1730        struct checkout_opts opts;
1731        struct option *options = NULL;
1732        struct option switch_options[] = {
1733                OPT_STRING('c', "create", &opts.new_branch, N_("branch"),
1734                           N_("create and switch to a new branch")),
1735                OPT_STRING('C', "force-create", &opts.new_branch_force, N_("branch"),
1736                           N_("create/reset and switch to a branch")),
1737                OPT_BOOL(0, "guess", &opts.dwim_new_local_branch,
1738                         N_("second guess 'git switch <no-such-branch>'")),
1739                OPT_BOOL(0, "discard-changes", &opts.discard_changes,
1740                         N_("throw away local modifications")),
1741                OPT_END()
1742        };
1743        int ret;
1744
1745        memset(&opts, 0, sizeof(opts));
1746        opts.dwim_new_local_branch = 1;
1747        opts.accept_ref = 1;
1748        opts.accept_pathspec = 0;
1749        opts.switch_branch_doing_nothing_is_ok = 0;
1750        opts.only_merge_on_switching_branches = 1;
1751        opts.implicit_detach = 0;
1752        opts.can_switch_when_in_progress = 0;
1753        opts.orphan_from_empty_tree = 1;
1754        opts.overlay_mode = -1;
1755
1756        options = parse_options_dup(switch_options);
1757        options = add_common_options(&opts, options);
1758        options = add_common_switch_branch_options(&opts, options);
1759
1760        ret = checkout_main(argc, argv, prefix, &opts,
1761                            options, switch_branch_usage);
1762        FREE_AND_NULL(options);
1763        return ret;
1764}
1765
1766int cmd_restore(int argc, const char **argv, const char *prefix)
1767{
1768        struct checkout_opts opts;
1769        struct option *options;
1770        struct option restore_options[] = {
1771                OPT_STRING('s', "source", &opts.from_treeish, "<tree-ish>",
1772                           N_("where the checkout from")),
1773                OPT_BOOL('S', "staged", &opts.checkout_index,
1774                           N_("restore the index")),
1775                OPT_BOOL('W', "worktree", &opts.checkout_worktree,
1776                           N_("restore the working tree (default)")),
1777                OPT_BOOL(0, "ignore-unmerged", &opts.ignore_unmerged,
1778                         N_("ignore unmerged entries")),
1779                OPT_BOOL(0, "overlay", &opts.overlay_mode, N_("use overlay mode")),
1780                OPT_END()
1781        };
1782        int ret;
1783
1784        memset(&opts, 0, sizeof(opts));
1785        opts.accept_ref = 0;
1786        opts.accept_pathspec = 1;
1787        opts.empty_pathspec_ok = 0;
1788        opts.overlay_mode = 0;
1789        opts.checkout_index = -1;    /* default off */
1790        opts.checkout_worktree = -2; /* default on */
1791        opts.ignore_unmerged_opt = "--ignore-unmerged";
1792
1793        options = parse_options_dup(restore_options);
1794        options = add_common_options(&opts, options);
1795        options = add_checkout_path_options(&opts, options);
1796
1797        ret = checkout_main(argc, argv, prefix, &opts,
1798                            options, restore_usage);
1799        FREE_AND_NULL(options);
1800        return ret;
1801}