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