merge-recursive: Create function for merging with branchname:file markers
[gitweb.git] / builtin / checkout.c
index e98576f22ee3aeb9caef3b18b3775b5aabb7da4b..38632fc39805085e3b134e0574f3846931c150c6 100644 (file)
@@ -30,6 +30,7 @@ struct checkout_opts {
        int quiet;
        int merge;
        int force;
+       int force_detach;
        int writeout_stage;
        int writeout_error;
 
@@ -103,9 +104,10 @@ static int check_stage(int stage, struct cache_entry *ce, int pos)
                        return 0;
                pos++;
        }
-       return error("path '%s' does not have %s version",
-                    ce->name,
-                    (stage == 2) ? "our" : "their");
+       if (stage == 2)
+               return error(_("path '%s' does not have our version"), ce->name);
+       else
+               return error(_("path '%s' does not have their version"), ce->name);
 }
 
 static int check_all_stages(struct cache_entry *ce, int pos)
@@ -116,7 +118,7 @@ static int check_all_stages(struct cache_entry *ce, int pos)
            ce_stage(active_cache[pos+1]) != 2 ||
            strcmp(active_cache[pos+2]->name, ce->name) ||
            ce_stage(active_cache[pos+2]) != 3)
-               return error("path '%s' does not have all three versions",
+               return error(_("path '%s' does not have all three versions"),
                             ce->name);
        return 0;
 }
@@ -130,9 +132,10 @@ static int checkout_stage(int stage, struct cache_entry *ce, int pos,
                        return checkout_entry(active_cache[pos], state, NULL);
                pos++;
        }
-       return error("path '%s' does not have %s version",
-                    ce->name,
-                    (stage == 2) ? "our" : "their");
+       if (stage == 2)
+               return error(_("path '%s' does not have our version"), ce->name);
+       else
+               return error(_("path '%s' does not have their version"), ce->name);
 }
 
 static int checkout_merged(int pos, struct checkout *state)
@@ -150,7 +153,7 @@ static int checkout_merged(int pos, struct checkout *state)
            ce_stage(active_cache[pos+1]) != 2 ||
            strcmp(active_cache[pos+2]->name, path) ||
            ce_stage(active_cache[pos+2]) != 3)
-               return error("path '%s' does not have all 3 versions", path);
+               return error(_("path '%s' does not have all 3 versions"), path);
 
        read_mmblob(&ancestor, active_cache[pos]->sha1);
        read_mmblob(&ours, active_cache[pos+1]->sha1);
@@ -167,7 +170,7 @@ static int checkout_merged(int pos, struct checkout *state)
        free(theirs.ptr);
        if (status < 0 || !result_buf.ptr) {
                free(result_buf.ptr);
-               return error("path '%s': cannot merge", path);
+               return error(_("path '%s': cannot merge"), path);
        }
 
        /*
@@ -184,12 +187,12 @@ static int checkout_merged(int pos, struct checkout *state)
         */
        if (write_sha1_file(result_buf.ptr, result_buf.size,
                            blob_type, sha1))
-               die("Unable to add merge result for '%s'", path);
+               die(_("Unable to add merge result for '%s'"), path);
        ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
                              sha1,
                              path, 2, 0);
        if (!ce)
-               die("make_cache_entry failed for path '%s'", path);
+               die(_("make_cache_entry failed for path '%s'"), path);
        status = checkout_entry(ce, state, NULL);
        return status;
 }
@@ -211,7 +214,7 @@ static int checkout_paths(struct tree *source_tree, const char **pathspec,
 
        newfd = hold_locked_index(lock_file, 1);
        if (read_cache_preload(pathspec) < 0)
-               return error("corrupt index file");
+               return error(_("corrupt index file"));
 
        if (source_tree)
                read_tree_some(source_tree, pathspec);
@@ -239,14 +242,14 @@ static int checkout_paths(struct tree *source_tree, const char **pathspec,
                        if (!ce_stage(ce))
                                continue;
                        if (opts->force) {
-                               warning("path '%s' is unmerged", ce->name);
+                               warning(_("path '%s' is unmerged"), ce->name);
                        } else if (stage) {
                                errs |= check_stage(stage, ce, pos);
                        } else if (opts->merge) {
                                errs |= check_all_stages(ce, pos);
                        } else {
                                errs = 1;
-                               error("path '%s' is unmerged", ce->name);
+                               error(_("path '%s' is unmerged"), ce->name);
                        }
                        pos = skip_same_name(ce, pos) - 1;
                }
@@ -275,7 +278,7 @@ static int checkout_paths(struct tree *source_tree, const char **pathspec,
 
        if (write_cache(newfd, active_cache, active_nr) ||
            commit_locked_index(lock_file))
-               die("unable to write new index file");
+               die(_("unable to write new index file"));
 
        resolve_ref("HEAD", rev, 0, &flag);
        head = lookup_commit_reference_gently(rev, 1);
@@ -292,12 +295,12 @@ static void show_local_changes(struct object *head, struct diff_options *opts)
        rev.diffopt.flags = opts->flags;
        rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
        if (diff_setup_done(&rev.diffopt) < 0)
-               die("diff_setup_done failed");
+               die(_("diff_setup_done failed"));
        add_pending_object(&rev, head, NULL);
        run_diff_index(&rev, 0);
 }
 
-static void describe_detached_head(char *msg, struct commit *commit)
+static void describe_detached_head(const char *msg, struct commit *commit)
 {
        struct strbuf sb = STRBUF_INIT;
        struct pretty_print_context ctx = {0};
@@ -366,7 +369,7 @@ static int merge_working_tree(struct checkout_opts *opts,
        int newfd = hold_locked_index(lock_file, 1);
 
        if (read_cache_preload(NULL) < 0)
-               return error("corrupt index file");
+               return error(_("corrupt index file"));
 
        resolve_undo_clear();
        if (opts->force) {
@@ -388,7 +391,7 @@ static int merge_working_tree(struct checkout_opts *opts,
                refresh_cache(REFRESH_QUIET);
 
                if (unmerged_cache()) {
-                       error("you need to resolve your current index first");
+                       error(_("you need to resolve your current index first"));
                        return 1;
                }
 
@@ -470,7 +473,7 @@ static int merge_working_tree(struct checkout_opts *opts,
 
        if (write_cache(newfd, active_cache, active_nr) ||
            commit_locked_index(lock_file))
-               die("unable to write new index file");
+               die(_("unable to write new index file"));
 
        if (!opts->force && !opts->quiet)
                show_local_changes(&new->commit->object, &opts->diff_options);
@@ -519,7 +522,7 @@ static void update_refs_for_switch(struct checkout_opts *opts,
                                temp = log_all_ref_updates;
                                log_all_ref_updates = 1;
                                if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
-                                       fprintf(stderr, "Can not do reflog for '%s'\n",
+                                       fprintf(stderr, _("Can not do reflog for '%s'\n"),
                                            opts->new_orphan_branch);
                                        log_all_ref_updates = temp;
                                        return;
@@ -541,19 +544,31 @@ static void update_refs_for_switch(struct checkout_opts *opts,
        strbuf_addf(&msg, "checkout: moving from %s to %s",
                    old_desc ? old_desc : "(invalid)", new->name);
 
-       if (new->path) {
+       if (!strcmp(new->name, "HEAD") && !new->path && !opts->force_detach) {
+               /* Nothing to do. */
+       } else if (opts->force_detach || !new->path) {  /* No longer on any branch. */
+               update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
+                          REF_NODEREF, DIE_ON_ERR);
+               if (!opts->quiet) {
+                       if (old->path && advice_detached_head)
+                               detach_advice(old->path, new->name);
+                       describe_detached_head(_("HEAD is now at"), new->commit);
+               }
+       } else if (new->path) { /* Switch branches. */
                create_symref("HEAD", new->path, msg.buf);
                if (!opts->quiet) {
-                       if (old->path && !strcmp(new->path, old->path))
-                               fprintf(stderr, "Already on '%s'\n",
-                                       new->name);
-                       else if (opts->new_branch)
-                               fprintf(stderr, "Switched to%s branch '%s'\n",
-                                       opts->branch_exists ? " and reset" : " a new",
+                       if (old->path && !strcmp(new->path, old->path)) {
+                               fprintf(stderr, _("Already on '%s'\n"),
                                        new->name);
-                       else
-                               fprintf(stderr, "Switched to branch '%s'\n",
+                       } else if (opts->new_branch) {
+                               if (opts->branch_exists)
+                                       fprintf(stderr, _("Switched to and reset branch '%s'\n"), new->name);
+                               else
+                                       fprintf(stderr, _("Switched to a new branch '%s'\n"), new->name);
+                       } else {
+                               fprintf(stderr, _("Switched to branch '%s'\n"),
                                        new->name);
+                       }
                }
                if (old->path && old->name) {
                        char log_file[PATH_MAX], ref_file[PATH_MAX];
@@ -563,21 +578,136 @@ static void update_refs_for_switch(struct checkout_opts *opts,
                        if (!file_exists(ref_file) && file_exists(log_file))
                                remove_path(log_file);
                }
-       } else if (strcmp(new->name, "HEAD")) {
-               update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
-                          REF_NODEREF, DIE_ON_ERR);
-               if (!opts->quiet) {
-                       if (old->path && advice_detached_head)
-                               detach_advice(old->path, new->name);
-                       describe_detached_head("HEAD is now at", new->commit);
-               }
        }
        remove_branch_state();
        strbuf_release(&msg);
-       if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
+       if (!opts->quiet &&
+           (new->path || (!opts->force_detach && !strcmp(new->name, "HEAD"))))
                report_tracking(new);
 }
 
+struct rev_list_args {
+       int argc;
+       int alloc;
+       const char **argv;
+};
+
+static void add_one_rev_list_arg(struct rev_list_args *args, const char *s)
+{
+       ALLOC_GROW(args->argv, args->argc + 1, args->alloc);
+       args->argv[args->argc++] = s;
+}
+
+static int add_one_ref_to_rev_list_arg(const char *refname,
+                                      const unsigned char *sha1,
+                                      int flags,
+                                      void *cb_data)
+{
+       add_one_rev_list_arg(cb_data, refname);
+       return 0;
+}
+
+static int clear_commit_marks_from_one_ref(const char *refname,
+                                     const unsigned char *sha1,
+                                     int flags,
+                                     void *cb_data)
+{
+       struct commit *commit = lookup_commit_reference_gently(sha1, 1);
+       if (commit)
+               clear_commit_marks(commit, -1);
+       return 0;
+}
+
+static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
+{
+       struct pretty_print_context ctx = { 0 };
+
+       parse_commit(commit);
+       strbuf_addstr(sb, "  ");
+       strbuf_addstr(sb,
+               find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
+       strbuf_addch(sb, ' ');
+       pretty_print_commit(CMIT_FMT_ONELINE, commit, sb, &ctx);
+       strbuf_addch(sb, '\n');
+}
+
+#define ORPHAN_CUTOFF 4
+static void suggest_reattach(struct commit *commit, struct rev_info *revs)
+{
+       struct commit *c, *last = NULL;
+       struct strbuf sb = STRBUF_INIT;
+       int lost = 0;
+       while ((c = get_revision(revs)) != NULL) {
+               if (lost < ORPHAN_CUTOFF)
+                       describe_one_orphan(&sb, c);
+               last = c;
+               lost++;
+       }
+       if (ORPHAN_CUTOFF < lost) {
+               int more = lost - ORPHAN_CUTOFF;
+               if (more == 1)
+                       describe_one_orphan(&sb, last);
+               else
+                       strbuf_addf(&sb, _(" ... and %d more.\n"), more);
+       }
+
+       fprintf(stderr,
+               Q_(
+               /* The singular version */
+               "Warning: you are leaving %d commit behind, "
+               "not connected to\n"
+               "any of your branches:\n\n"
+               "%s\n"
+               "If you want to keep it by creating a new branch, "
+               "this may be a good time\nto do so with:\n\n"
+               " git branch new_branch_name %s\n\n",
+               /* The plural version */
+               "Warning: you are leaving %d commits behind, "
+               "not connected to\n"
+               "any of your branches:\n\n"
+               "%s\n"
+               "If you want to keep them by creating a new branch, "
+               "this may be a good time\nto do so with:\n\n"
+               " git branch new_branch_name %s\n\n",
+               /* Give ngettext() the count */
+               lost),
+               lost,
+               sb.buf,
+               sha1_to_hex(commit->object.sha1));
+       strbuf_release(&sb);
+}
+
+/*
+ * We are about to leave commit that was at the tip of a detached
+ * HEAD.  If it is not reachable from any ref, this is the last chance
+ * for the user to do so without resorting to reflog.
+ */
+static void orphaned_commit_warning(struct commit *commit)
+{
+       struct rev_list_args args = { 0, 0, NULL };
+       struct rev_info revs;
+
+       add_one_rev_list_arg(&args, "(internal)");
+       add_one_rev_list_arg(&args, sha1_to_hex(commit->object.sha1));
+       add_one_rev_list_arg(&args, "--not");
+       for_each_ref(add_one_ref_to_rev_list_arg, &args);
+       add_one_rev_list_arg(&args, "--");
+       add_one_rev_list_arg(&args, NULL);
+
+       init_revisions(&revs, NULL);
+       if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
+               die(_("internal error: only -- alone should have been left"));
+       if (prepare_revision_walk(&revs))
+               die(_("internal error in revision walk"));
+       if (!(commit->object.flags & UNINTERESTING))
+               suggest_reattach(commit, &revs);
+       else
+               describe_detached_head(_("Previous HEAD position was"), commit);
+
+       clear_commit_marks(commit, -1);
+       for_each_ref(clear_commit_marks_from_one_ref, NULL);
+}
+
 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 {
        int ret = 0;
@@ -597,7 +727,7 @@ static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
                new->name = "HEAD";
                new->commit = old.commit;
                if (!new->commit)
-                       die("You are on a branch yet to be born");
+                       die(_("You are on a branch yet to be born"));
                parse_commit(new->commit);
        }
 
@@ -605,13 +735,8 @@ static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
        if (ret)
                return ret;
 
-       /*
-        * If we were on a detached HEAD, but have now moved to
-        * a new commit, we want to mention the old commit once more
-        * to remind the user that it might be lost.
-        */
        if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
-               describe_detached_head("Previous HEAD position was", old.commit);
+               orphaned_commit_warning(old.commit);
 
        update_refs_for_switch(opts, &old, new);
 
@@ -675,11 +800,123 @@ static const char *unique_tracking_name(const char *name)
        return NULL;
 }
 
+static int parse_branchname_arg(int argc, const char **argv,
+                               int dwim_new_local_branch_ok,
+                               struct branch_info *new,
+                               struct tree **source_tree,
+                               unsigned char rev[20],
+                               const char **new_branch)
+{
+       int argcount = 0;
+       unsigned char branch_rev[20];
+       const char *arg;
+       int has_dash_dash;
+
+       /*
+        * case 1: git checkout <ref> -- [<paths>]
+        *
+        *   <ref> must be a valid tree, everything after the '--' must be
+        *   a path.
+        *
+        * case 2: git checkout -- [<paths>]
+        *
+        *   everything after the '--' must be paths.
+        *
+        * case 3: git checkout <something> [<paths>]
+        *
+        *   With no paths, if <something> is a commit, that is to
+        *   switch to the branch or detach HEAD at it.  As a special case,
+        *   if <something> is A...B (missing A or B means HEAD but you can
+        *   omit at most one side), and if there is a unique merge base
+        *   between A and B, A...B names that merge base.
+        *
+        *   With no paths, if <something> is _not_ a commit, no -t nor -b
+        *   was given, and there is a tracking branch whose name is
+        *   <something> in one and only one remote, then this is a short-hand
+        *   to fork local <something> from that remote-tracking branch.
+        *
+        *   Otherwise <something> shall not be ambiguous.
+        *   - If it's *only* a reference, treat it like case (1).
+        *   - If it's only a path, treat it like case (2).
+        *   - else: fail.
+        *
+        */
+       if (!argc)
+               return 0;
+
+       if (!strcmp(argv[0], "--"))     /* case (2) */
+               return 1;
+
+       arg = argv[0];
+       has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
+
+       if (!strcmp(arg, "-"))
+               arg = "@{-1}";
+
+       if (get_sha1_mb(arg, rev)) {
+               if (has_dash_dash)          /* case (1) */
+                       die(_("invalid reference: %s"), arg);
+               if (dwim_new_local_branch_ok &&
+                   !check_filename(NULL, arg) &&
+                   argc == 1) {
+                       const char *remote = unique_tracking_name(arg);
+                       if (!remote || get_sha1(remote, rev))
+                               return argcount;
+                       *new_branch = arg;
+                       arg = remote;
+                       /* DWIMmed to create local branch */
+               } else {
+                       return argcount;
+               }
+       }
+
+       /* we can't end up being in (2) anymore, eat the argument */
+       argcount++;
+       argv++;
+       argc--;
+
+       new->name = arg;
+       setup_branch_path(new);
+
+       if (check_ref_format(new->path) == CHECK_REF_FORMAT_OK &&
+           resolve_ref(new->path, branch_rev, 1, NULL))
+               hashcpy(rev, branch_rev);
+       else
+               new->path = NULL; /* not an existing branch */
+
+       new->commit = lookup_commit_reference_gently(rev, 1);
+       if (!new->commit) {
+               /* not a commit */
+               *source_tree = parse_tree_indirect(rev);
+       } else {
+               parse_commit(new->commit);
+               *source_tree = new->commit->tree;
+       }
+
+       if (!*source_tree)                   /* case (1): want a tree */
+               die(_("reference is not a tree: %s"), arg);
+       if (!has_dash_dash) {/* case (3 -> 1) */
+               /*
+                * Do not complain the most common case
+                *      git checkout branch
+                * even if there happen to be a file called 'branch';
+                * it would be extremely annoying.
+                */
+               if (argc)
+                       verify_non_filename(NULL, arg);
+       } else {
+               argcount++;
+               argv++;
+               argc--;
+       }
+
+       return argcount;
+}
+
 int cmd_checkout(int argc, const char **argv, const char *prefix)
 {
        struct checkout_opts opts;
-       unsigned char rev[20], branch_rev[20];
-       const char *arg;
+       unsigned char rev[20];
        struct branch_info new;
        struct tree *source_tree = NULL;
        char *conflict_style = NULL;
@@ -692,6 +929,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)
                OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
                           "create/reset and checkout a branch"),
                OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
+               OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
                OPT_SET_INT('t', "track",  &opts.track, "set upstream info for new branch",
                        BRANCH_TRACK_EXPLICIT),
                OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
@@ -709,7 +947,6 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)
                  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
                OPT_END(),
        };
-       int has_dash_dash;
 
        memset(&opts, 0, sizeof(opts));
        memset(&new, 0, sizeof(new));
@@ -724,36 +961,42 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)
 
        /* we can assume from now on new_branch = !new_branch_force */
        if (opts.new_branch && opts.new_branch_force)
-               die("-B cannot be used with -b");
+               die(_("-B cannot be used with -b"));
 
        /* copy -B over to -b, so that we can just check the latter */
        if (opts.new_branch_force)
                opts.new_branch = opts.new_branch_force;
 
        if (patch_mode && (opts.track > 0 || opts.new_branch
-                          || opts.new_branch_log || opts.merge || opts.force))
-               die ("--patch is incompatible with all other options");
+                          || opts.new_branch_log || opts.merge || opts.force
+                          || opts.force_detach))
+               die (_("--patch is incompatible with all other options"));
+
+       if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
+               die(_("--detach cannot be used with -b/-B/--orphan"));
+       if (opts.force_detach && 0 < opts.track)
+               die(_("--detach cannot be used with -t"));
 
        /* --track without -b should DWIM */
        if (0 < opts.track && !opts.new_branch) {
                const char *argv0 = argv[0];
                if (!argc || !strcmp(argv0, "--"))
-                       die ("--track needs a branch name");
+                       die (_("--track needs a branch name"));
                if (!prefixcmp(argv0, "refs/"))
                        argv0 += 5;
                if (!prefixcmp(argv0, "remotes/"))
                        argv0 += 8;
                argv0 = strchr(argv0, '/');
                if (!argv0 || !argv0[1])
-                       die ("Missing branch name; try -b");
+                       die (_("Missing branch name; try -b"));
                opts.new_branch = argv0 + 1;
        }
 
        if (opts.new_orphan_branch) {
                if (opts.new_branch)
-                       die("--orphan and -b|-B are mutually exclusive");
+                       die(_("--orphan and -b|-B are mutually exclusive"));
                if (opts.track > 0)
-                       die("--orphan cannot be used with -t");
+                       die(_("--orphan cannot be used with -t"));
                opts.new_branch = opts.new_orphan_branch;
        }
 
@@ -763,111 +1006,33 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)
        }
 
        if (opts.force && opts.merge)
-               die("git checkout: -f and -m are incompatible");
+               die(_("git checkout: -f and -m are incompatible"));
 
        /*
-        * case 1: git checkout <ref> -- [<paths>]
+        * Extract branch name from command line arguments, so
+        * all that is left is pathspecs.
         *
-        *   <ref> must be a valid tree, everything after the '--' must be
-        *   a path.
-        *
-        * case 2: git checkout -- [<paths>]
+        * Handle
         *
-        *   everything after the '--' must be paths.
-        *
-        * case 3: git checkout <something> [<paths>]
-        *
-        *   With no paths, if <something> is a commit, that is to
-        *   switch to the branch or detach HEAD at it.  As a special case,
-        *   if <something> is A...B (missing A or B means HEAD but you can
-        *   omit at most one side), and if there is a unique merge base
-        *   between A and B, A...B names that merge base.
-        *
-        *   With no paths, if <something> is _not_ a commit, no -t nor -b
-        *   was given, and there is a remote-tracking branch whose name is
-        *   <something> in one and only one remote, then this is a short-hand
-        *   to fork local <something> from that remote-tracking branch.
-        *
-        *   Otherwise <something> shall not be ambiguous.
-        *   - If it's *only* a reference, treat it like case (1).
-        *   - If it's only a path, treat it like case (2).
-        *   - else: fail.
+        *  1) git checkout <tree> -- [<paths>]
+        *  2) git checkout -- [<paths>]
+        *  3) git checkout <something> [<paths>]
         *
+        * including "last branch" syntax and DWIM-ery for names of
+        * remote branches, erroring out for invalid or ambiguous cases.
         */
        if (argc) {
-               if (!strcmp(argv[0], "--")) {       /* case (2) */
-                       argv++;
-                       argc--;
-                       goto no_reference;
-               }
-
-               arg = argv[0];
-               has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
-
-               if (!strcmp(arg, "-"))
-                       arg = "@{-1}";
-
-               if (get_sha1_mb(arg, rev)) {
-                       if (has_dash_dash)          /* case (1) */
-                               die("invalid reference: %s", arg);
-                       if (!patch_mode &&
-                           dwim_new_local_branch &&
-                           opts.track == BRANCH_TRACK_UNSPECIFIED &&
-                           !opts.new_branch &&
-                           !check_filename(NULL, arg) &&
-                           argc == 1) {
-                               const char *remote = unique_tracking_name(arg);
-                               if (!remote || get_sha1(remote, rev))
-                                       goto no_reference;
-                               opts.new_branch = arg;
-                               arg = remote;
-                               /* DWIMmed to create local branch */
-                       }
-                       else
-                               goto no_reference;
-               }
-
-               /* we can't end up being in (2) anymore, eat the argument */
-               argv++;
-               argc--;
-
-               new.name = arg;
-               setup_branch_path(&new);
-
-               if (check_ref_format(new.path) == CHECK_REF_FORMAT_OK &&
-                   resolve_ref(new.path, branch_rev, 1, NULL))
-                       hashcpy(rev, branch_rev);
-               else
-                       new.path = NULL; /* not an existing branch */
-
-               if (!(new.commit = lookup_commit_reference_gently(rev, 1))) {
-                       /* not a commit */
-                       source_tree = parse_tree_indirect(rev);
-               } else {
-                       parse_commit(new.commit);
-                       source_tree = new.commit->tree;
-               }
-
-               if (!source_tree)                   /* case (1): want a tree */
-                       die("reference is not a tree: %s", arg);
-               if (!has_dash_dash) {/* case (3 -> 1) */
-                       /*
-                        * Do not complain the most common case
-                        *      git checkout branch
-                        * even if there happen to be a file called 'branch';
-                        * it would be extremely annoying.
-                        */
-                       if (argc)
-                               verify_non_filename(NULL, arg);
-               }
-               else {
-                       argv++;
-                       argc--;
-               }
+               int dwim_ok =
+                       !patch_mode &&
+                       dwim_new_local_branch &&
+                       opts.track == BRANCH_TRACK_UNSPECIFIED &&
+                       !opts.new_branch;
+               int n = parse_branchname_arg(argc, argv, dwim_ok,
+                               &new, &source_tree, rev, &opts.new_branch);
+               argv += n;
+               argc -= n;
        }
 
-no_reference:
-
        if (opts.track == BRANCH_TRACK_UNSPECIFIED)
                opts.track = git_branch_track;
 
@@ -875,7 +1040,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)
                const char **pathspec = get_pathspec(prefix, argv);
 
                if (!pathspec)
-                       die("invalid path specification");
+                       die(_("invalid path specification"));
 
                if (patch_mode)
                        return interactive_checkout(new.name, pathspec, &opts);
@@ -883,14 +1048,17 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)
                /* Checkout paths */
                if (opts.new_branch) {
                        if (argc == 1) {
-                               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]);
+                               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]);
                        } else {
-                               die("git checkout: updating paths is incompatible with switching branches.");
+                               die(_("git checkout: updating paths is incompatible with switching branches."));
                        }
                }
 
+               if (opts.force_detach)
+                       die(_("git checkout: --detach does not take a path argument"));
+
                if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
-                       die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
+                       die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
 
                return checkout_paths(source_tree, pathspec, &opts);
        }
@@ -901,22 +1069,22 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)
        if (opts.new_branch) {
                struct strbuf buf = STRBUF_INIT;
                if (strbuf_check_branch_ref(&buf, opts.new_branch))
-                       die("git checkout: we do not like '%s' as a branch name.",
+                       die(_("git checkout: we do not like '%s' as a branch name."),
                            opts.new_branch);
                if (!get_sha1(buf.buf, rev)) {
                        opts.branch_exists = 1;
                        if (!opts.new_branch_force)
-                               die("git checkout: branch %s already exists",
+                               die(_("git checkout: branch %s already exists"),
                                    opts.new_branch);
                }
                strbuf_release(&buf);
        }
 
        if (new.name && !new.commit) {
-               die("Cannot switch branch to a non-commit.");
+               die(_("Cannot switch branch to a non-commit."));
        }
        if (opts.writeout_stage)
-               die("--ours/--theirs is incompatible with switching branches.");
+               die(_("--ours/--theirs is incompatible with switching branches."));
 
        return switch_branches(&opts, &new);
 }