merge-ort: implement handle_path_level_conflicts()
[git] / diff-lib.c
1 /*
2  * Copyright (C) 2005 Junio C Hamano
3  */
4 #include "cache.h"
5 #include "quote.h"
6 #include "commit.h"
7 #include "diff.h"
8 #include "diffcore.h"
9 #include "revision.h"
10 #include "cache-tree.h"
11 #include "unpack-trees.h"
12 #include "refs.h"
13 #include "submodule.h"
14 #include "dir.h"
15 #include "fsmonitor.h"
16 #include "commit-reach.h"
17
18 /*
19  * diff-files
20  */
21
22 /*
23  * Has the work tree entity been removed?
24  *
25  * Return 1 if it was removed from the work tree, 0 if an entity to be
26  * compared with the cache entry ce still exists (the latter includes
27  * the case where a directory that is not a submodule repository
28  * exists for ce that is a submodule -- it is a submodule that is not
29  * checked out).  Return negative for an error.
30  */
31 static int check_removed(const struct cache_entry *ce, struct stat *st)
32 {
33         if (lstat(ce->name, st) < 0) {
34                 if (!is_missing_file_error(errno))
35                         return -1;
36                 return 1;
37         }
38         if (has_symlink_leading_path(ce->name, ce_namelen(ce)))
39                 return 1;
40         if (S_ISDIR(st->st_mode)) {
41                 struct object_id sub;
42
43                 /*
44                  * If ce is already a gitlink, we can have a plain
45                  * directory (i.e. the submodule is not checked out),
46                  * or a checked out submodule.  Either case this is not
47                  * a case where something was removed from the work tree,
48                  * so we will return 0.
49                  *
50                  * Otherwise, if the directory is not a submodule
51                  * repository, that means ce which was a blob turned into
52                  * a directory --- the blob was removed!
53                  */
54                 if (!S_ISGITLINK(ce->ce_mode) &&
55                     resolve_gitlink_ref(ce->name, "HEAD", &sub))
56                         return 1;
57         }
58         return 0;
59 }
60
61 /*
62  * Has a file changed or has a submodule new commits or a dirty work tree?
63  *
64  * Return 1 when changes are detected, 0 otherwise. If the DIRTY_SUBMODULES
65  * option is set, the caller does not only want to know if a submodule is
66  * modified at all but wants to know all the conditions that are met (new
67  * commits, untracked content and/or modified content).
68  */
69 static int match_stat_with_submodule(struct diff_options *diffopt,
70                                      const struct cache_entry *ce,
71                                      struct stat *st, unsigned ce_option,
72                                      unsigned *dirty_submodule)
73 {
74         int changed = ie_match_stat(diffopt->repo->index, ce, st, ce_option);
75         if (S_ISGITLINK(ce->ce_mode)) {
76                 struct diff_flags orig_flags = diffopt->flags;
77                 if (!diffopt->flags.override_submodule_config)
78                         set_diffopt_flags_from_submodule_config(diffopt, ce->name);
79                 if (diffopt->flags.ignore_submodules)
80                         changed = 0;
81                 else if (!diffopt->flags.ignore_dirty_submodules &&
82                          (!changed || diffopt->flags.dirty_submodules))
83                         *dirty_submodule = is_submodule_modified(ce->name,
84                                                                  diffopt->flags.ignore_untracked_in_submodules);
85                 diffopt->flags = orig_flags;
86         }
87         return changed;
88 }
89
90 int run_diff_files(struct rev_info *revs, unsigned int option)
91 {
92         int entries, i;
93         int diff_unmerged_stage = revs->max_count;
94         unsigned ce_option = ((option & DIFF_RACY_IS_MODIFIED)
95                               ? CE_MATCH_RACY_IS_DIRTY : 0);
96         uint64_t start = getnanotime();
97         struct index_state *istate = revs->diffopt.repo->index;
98
99         diff_set_mnemonic_prefix(&revs->diffopt, "i/", "w/");
100
101         refresh_fsmonitor(istate);
102
103         if (diff_unmerged_stage < 0)
104                 diff_unmerged_stage = 2;
105         entries = istate->cache_nr;
106         for (i = 0; i < entries; i++) {
107                 unsigned int oldmode, newmode;
108                 struct cache_entry *ce = istate->cache[i];
109                 int changed;
110                 unsigned dirty_submodule = 0;
111                 const struct object_id *old_oid, *new_oid;
112
113                 if (diff_can_quit_early(&revs->diffopt))
114                         break;
115
116                 if (!ce_path_match(istate, ce, &revs->prune_data, NULL))
117                         continue;
118
119                 if (ce_stage(ce)) {
120                         struct combine_diff_path *dpath;
121                         struct diff_filepair *pair;
122                         unsigned int wt_mode = 0;
123                         int num_compare_stages = 0;
124                         size_t path_len;
125                         struct stat st;
126
127                         path_len = ce_namelen(ce);
128
129                         dpath = xmalloc(combine_diff_path_size(5, path_len));
130                         dpath->path = (char *) &(dpath->parent[5]);
131
132                         dpath->next = NULL;
133                         memcpy(dpath->path, ce->name, path_len);
134                         dpath->path[path_len] = '\0';
135                         oidclr(&dpath->oid);
136                         memset(&(dpath->parent[0]), 0,
137                                sizeof(struct combine_diff_parent)*5);
138
139                         changed = check_removed(ce, &st);
140                         if (!changed)
141                                 wt_mode = ce_mode_from_stat(ce, st.st_mode);
142                         else {
143                                 if (changed < 0) {
144                                         perror(ce->name);
145                                         continue;
146                                 }
147                                 wt_mode = 0;
148                         }
149                         dpath->mode = wt_mode;
150
151                         while (i < entries) {
152                                 struct cache_entry *nce = istate->cache[i];
153                                 int stage;
154
155                                 if (strcmp(ce->name, nce->name))
156                                         break;
157
158                                 /* Stage #2 (ours) is the first parent,
159                                  * stage #3 (theirs) is the second.
160                                  */
161                                 stage = ce_stage(nce);
162                                 if (2 <= stage) {
163                                         int mode = nce->ce_mode;
164                                         num_compare_stages++;
165                                         oidcpy(&dpath->parent[stage - 2].oid,
166                                                &nce->oid);
167                                         dpath->parent[stage-2].mode = ce_mode_from_stat(nce, mode);
168                                         dpath->parent[stage-2].status =
169                                                 DIFF_STATUS_MODIFIED;
170                                 }
171
172                                 /* diff against the proper unmerged stage */
173                                 if (stage == diff_unmerged_stage)
174                                         ce = nce;
175                                 i++;
176                         }
177                         /*
178                          * Compensate for loop update
179                          */
180                         i--;
181
182                         if (revs->combine_merges && num_compare_stages == 2) {
183                                 show_combined_diff(dpath, 2, revs);
184                                 free(dpath);
185                                 continue;
186                         }
187                         FREE_AND_NULL(dpath);
188
189                         /*
190                          * Show the diff for the 'ce' if we found the one
191                          * from the desired stage.
192                          */
193                         pair = diff_unmerge(&revs->diffopt, ce->name);
194                         if (wt_mode)
195                                 pair->two->mode = wt_mode;
196                         if (ce_stage(ce) != diff_unmerged_stage)
197                                 continue;
198                 }
199
200                 if (ce_uptodate(ce) || ce_skip_worktree(ce))
201                         continue;
202
203                 /*
204                  * When CE_VALID is set (via "update-index --assume-unchanged"
205                  * or via adding paths while core.ignorestat is set to true),
206                  * the user has promised that the working tree file for that
207                  * path will not be modified.  When CE_FSMONITOR_VALID is true,
208                  * the fsmonitor knows that the path hasn't been modified since
209                  * we refreshed the cached stat information.  In either case,
210                  * we do not have to stat to see if the path has been removed
211                  * or modified.
212                  */
213                 if (ce->ce_flags & (CE_VALID | CE_FSMONITOR_VALID)) {
214                         changed = 0;
215                         newmode = ce->ce_mode;
216                 } else {
217                         struct stat st;
218
219                         changed = check_removed(ce, &st);
220                         if (changed) {
221                                 if (changed < 0) {
222                                         perror(ce->name);
223                                         continue;
224                                 }
225                                 diff_addremove(&revs->diffopt, '-', ce->ce_mode,
226                                                &ce->oid,
227                                                !is_null_oid(&ce->oid),
228                                                ce->name, 0);
229                                 continue;
230                         } else if (revs->diffopt.ita_invisible_in_index &&
231                                    ce_intent_to_add(ce)) {
232                                 newmode = ce_mode_from_stat(ce, st.st_mode);
233                                 diff_addremove(&revs->diffopt, '+', newmode,
234                                                &null_oid, 0, ce->name, 0);
235                                 continue;
236                         }
237
238                         changed = match_stat_with_submodule(&revs->diffopt, ce, &st,
239                                                             ce_option, &dirty_submodule);
240                         newmode = ce_mode_from_stat(ce, st.st_mode);
241                 }
242
243                 if (!changed && !dirty_submodule) {
244                         ce_mark_uptodate(ce);
245                         mark_fsmonitor_valid(istate, ce);
246                         if (!revs->diffopt.flags.find_copies_harder)
247                                 continue;
248                 }
249                 oldmode = ce->ce_mode;
250                 old_oid = &ce->oid;
251                 new_oid = changed ? &null_oid : &ce->oid;
252                 diff_change(&revs->diffopt, oldmode, newmode,
253                             old_oid, new_oid,
254                             !is_null_oid(old_oid),
255                             !is_null_oid(new_oid),
256                             ce->name, 0, dirty_submodule);
257
258         }
259         diffcore_std(&revs->diffopt);
260         diff_flush(&revs->diffopt);
261         trace_performance_since(start, "diff-files");
262         return 0;
263 }
264
265 /*
266  * diff-index
267  */
268
269 /* A file entry went away or appeared */
270 static void diff_index_show_file(struct rev_info *revs,
271                                  const char *prefix,
272                                  const struct cache_entry *ce,
273                                  const struct object_id *oid, int oid_valid,
274                                  unsigned int mode,
275                                  unsigned dirty_submodule)
276 {
277         diff_addremove(&revs->diffopt, prefix[0], mode,
278                        oid, oid_valid, ce->name, dirty_submodule);
279 }
280
281 static int get_stat_data(const struct cache_entry *ce,
282                          const struct object_id **oidp,
283                          unsigned int *modep,
284                          int cached, int match_missing,
285                          unsigned *dirty_submodule, struct diff_options *diffopt)
286 {
287         const struct object_id *oid = &ce->oid;
288         unsigned int mode = ce->ce_mode;
289
290         if (!cached && !ce_uptodate(ce)) {
291                 int changed;
292                 struct stat st;
293                 changed = check_removed(ce, &st);
294                 if (changed < 0)
295                         return -1;
296                 else if (changed) {
297                         if (match_missing) {
298                                 *oidp = oid;
299                                 *modep = mode;
300                                 return 0;
301                         }
302                         return -1;
303                 }
304                 changed = match_stat_with_submodule(diffopt, ce, &st,
305                                                     0, dirty_submodule);
306                 if (changed) {
307                         mode = ce_mode_from_stat(ce, st.st_mode);
308                         oid = &null_oid;
309                 }
310         }
311
312         *oidp = oid;
313         *modep = mode;
314         return 0;
315 }
316
317 static void show_new_file(struct rev_info *revs,
318                           const struct cache_entry *new_file,
319                           int cached, int match_missing)
320 {
321         const struct object_id *oid;
322         unsigned int mode;
323         unsigned dirty_submodule = 0;
324
325         /*
326          * New file in the index: it might actually be different in
327          * the working tree.
328          */
329         if (get_stat_data(new_file, &oid, &mode, cached, match_missing,
330             &dirty_submodule, &revs->diffopt) < 0)
331                 return;
332
333         diff_index_show_file(revs, "+", new_file, oid, !is_null_oid(oid), mode, dirty_submodule);
334 }
335
336 static int show_modified(struct rev_info *revs,
337                          const struct cache_entry *old_entry,
338                          const struct cache_entry *new_entry,
339                          int report_missing,
340                          int cached, int match_missing)
341 {
342         unsigned int mode, oldmode;
343         const struct object_id *oid;
344         unsigned dirty_submodule = 0;
345
346         if (get_stat_data(new_entry, &oid, &mode, cached, match_missing,
347                           &dirty_submodule, &revs->diffopt) < 0) {
348                 if (report_missing)
349                         diff_index_show_file(revs, "-", old_entry,
350                                              &old_entry->oid, 1, old_entry->ce_mode,
351                                              0);
352                 return -1;
353         }
354
355         if (revs->combine_merges && !cached &&
356             (!oideq(oid, &old_entry->oid) || !oideq(&old_entry->oid, &new_entry->oid))) {
357                 struct combine_diff_path *p;
358                 int pathlen = ce_namelen(new_entry);
359
360                 p = xmalloc(combine_diff_path_size(2, pathlen));
361                 p->path = (char *) &p->parent[2];
362                 p->next = NULL;
363                 memcpy(p->path, new_entry->name, pathlen);
364                 p->path[pathlen] = 0;
365                 p->mode = mode;
366                 oidclr(&p->oid);
367                 memset(p->parent, 0, 2 * sizeof(struct combine_diff_parent));
368                 p->parent[0].status = DIFF_STATUS_MODIFIED;
369                 p->parent[0].mode = new_entry->ce_mode;
370                 oidcpy(&p->parent[0].oid, &new_entry->oid);
371                 p->parent[1].status = DIFF_STATUS_MODIFIED;
372                 p->parent[1].mode = old_entry->ce_mode;
373                 oidcpy(&p->parent[1].oid, &old_entry->oid);
374                 show_combined_diff(p, 2, revs);
375                 free(p);
376                 return 0;
377         }
378
379         oldmode = old_entry->ce_mode;
380         if (mode == oldmode && oideq(oid, &old_entry->oid) && !dirty_submodule &&
381             !revs->diffopt.flags.find_copies_harder)
382                 return 0;
383
384         diff_change(&revs->diffopt, oldmode, mode,
385                     &old_entry->oid, oid, 1, !is_null_oid(oid),
386                     old_entry->name, 0, dirty_submodule);
387         return 0;
388 }
389
390 /*
391  * This gets a mix of an existing index and a tree, one pathname entry
392  * at a time. The index entry may be a single stage-0 one, but it could
393  * also be multiple unmerged entries (in which case idx_pos/idx_nr will
394  * give you the position and number of entries in the index).
395  */
396 static void do_oneway_diff(struct unpack_trees_options *o,
397                            const struct cache_entry *idx,
398                            const struct cache_entry *tree)
399 {
400         struct rev_info *revs = o->unpack_data;
401         int match_missing, cached;
402
403         /*
404          * i-t-a entries do not actually exist in the index (if we're
405          * looking at its content)
406          */
407         if (o->index_only &&
408             revs->diffopt.ita_invisible_in_index &&
409             idx && ce_intent_to_add(idx)) {
410                 idx = NULL;
411                 if (!tree)
412                         return; /* nothing to diff.. */
413         }
414
415         /* if the entry is not checked out, don't examine work tree */
416         cached = o->index_only ||
417                 (idx && ((idx->ce_flags & CE_VALID) || ce_skip_worktree(idx)));
418
419         match_missing = revs->match_missing;
420
421         if (cached && idx && ce_stage(idx)) {
422                 struct diff_filepair *pair;
423                 pair = diff_unmerge(&revs->diffopt, idx->name);
424                 if (tree)
425                         fill_filespec(pair->one, &tree->oid, 1,
426                                       tree->ce_mode);
427                 return;
428         }
429
430         /*
431          * Something added to the tree?
432          */
433         if (!tree) {
434                 show_new_file(revs, idx, cached, match_missing);
435                 return;
436         }
437
438         /*
439          * Something removed from the tree?
440          */
441         if (!idx) {
442                 diff_index_show_file(revs, "-", tree, &tree->oid, 1,
443                                      tree->ce_mode, 0);
444                 return;
445         }
446
447         /* Show difference between old and new */
448         show_modified(revs, tree, idx, 1, cached, match_missing);
449 }
450
451 /*
452  * The unpack_trees() interface is designed for merging, so
453  * the different source entries are designed primarily for
454  * the source trees, with the old index being really mainly
455  * used for being replaced by the result.
456  *
457  * For diffing, the index is more important, and we only have a
458  * single tree.
459  *
460  * We're supposed to advance o->pos to skip what we have already processed.
461  *
462  * This wrapper makes it all more readable, and takes care of all
463  * the fairly complex unpack_trees() semantic requirements, including
464  * the skipping, the path matching, the type conflict cases etc.
465  */
466 static int oneway_diff(const struct cache_entry * const *src,
467                        struct unpack_trees_options *o)
468 {
469         const struct cache_entry *idx = src[0];
470         const struct cache_entry *tree = src[1];
471         struct rev_info *revs = o->unpack_data;
472
473         /*
474          * Unpack-trees generates a DF/conflict entry if
475          * there was a directory in the index and a tree
476          * in the tree. From a diff standpoint, that's a
477          * delete of the tree and a create of the file.
478          */
479         if (tree == o->df_conflict_entry)
480                 tree = NULL;
481
482         if (ce_path_match(revs->diffopt.repo->index,
483                           idx ? idx : tree,
484                           &revs->prune_data, NULL)) {
485                 do_oneway_diff(o, idx, tree);
486                 if (diff_can_quit_early(&revs->diffopt)) {
487                         o->exiting_early = 1;
488                         return -1;
489                 }
490         }
491
492         return 0;
493 }
494
495 static int diff_cache(struct rev_info *revs,
496                       const struct object_id *tree_oid,
497                       const char *tree_name,
498                       int cached)
499 {
500         struct tree *tree;
501         struct tree_desc t;
502         struct unpack_trees_options opts;
503
504         tree = parse_tree_indirect(tree_oid);
505         if (!tree)
506                 return error("bad tree object %s",
507                              tree_name ? tree_name : oid_to_hex(tree_oid));
508         memset(&opts, 0, sizeof(opts));
509         opts.head_idx = 1;
510         opts.index_only = cached;
511         opts.diff_index_cached = (cached &&
512                                   !revs->diffopt.flags.find_copies_harder);
513         opts.merge = 1;
514         opts.fn = oneway_diff;
515         opts.unpack_data = revs;
516         opts.src_index = revs->diffopt.repo->index;
517         opts.dst_index = NULL;
518         opts.pathspec = &revs->diffopt.pathspec;
519         opts.pathspec->recursive = 1;
520
521         init_tree_desc(&t, tree->buffer, tree->size);
522         return unpack_trees(1, &t, &opts);
523 }
524
525 void diff_get_merge_base(const struct rev_info *revs, struct object_id *mb)
526 {
527         int i;
528         struct commit *mb_child[2] = {0};
529         struct commit_list *merge_bases;
530
531         for (i = 0; i < revs->pending.nr; i++) {
532                 struct object *obj = revs->pending.objects[i].item;
533                 if (obj->flags)
534                         die(_("--merge-base does not work with ranges"));
535                 if (obj->type != OBJ_COMMIT)
536                         die(_("--merge-base only works with commits"));
537         }
538
539         /*
540          * This check must go after the for loop above because A...B
541          * ranges produce three pending commits, resulting in a
542          * misleading error message.
543          */
544         if (revs->pending.nr < 1 || revs->pending.nr > 2)
545                 BUG("unexpected revs->pending.nr: %d", revs->pending.nr);
546
547         for (i = 0; i < revs->pending.nr; i++)
548                 mb_child[i] = lookup_commit_reference(the_repository, &revs->pending.objects[i].item->oid);
549         if (revs->pending.nr == 1) {
550                 struct object_id oid;
551
552                 if (get_oid("HEAD", &oid))
553                         die(_("unable to get HEAD"));
554
555                 mb_child[1] = lookup_commit_reference(the_repository, &oid);
556         }
557
558         merge_bases = repo_get_merge_bases(the_repository, mb_child[0], mb_child[1]);
559         if (!merge_bases)
560                 die(_("no merge base found"));
561         if (merge_bases->next)
562                 die(_("multiple merge bases found"));
563
564         oidcpy(mb, &merge_bases->item->object.oid);
565
566         free_commit_list(merge_bases);
567 }
568
569 int run_diff_index(struct rev_info *revs, unsigned int option)
570 {
571         struct object_array_entry *ent;
572         int cached = !!(option & DIFF_INDEX_CACHED);
573         int merge_base = !!(option & DIFF_INDEX_MERGE_BASE);
574         struct object_id oid;
575         const char *name;
576         char merge_base_hex[GIT_MAX_HEXSZ + 1];
577
578         if (revs->pending.nr != 1)
579                 BUG("run_diff_index must be passed exactly one tree");
580
581         trace_performance_enter();
582         ent = revs->pending.objects;
583
584         if (merge_base) {
585                 diff_get_merge_base(revs, &oid);
586                 name = oid_to_hex_r(merge_base_hex, &oid);
587         } else {
588                 oidcpy(&oid, &ent->item->oid);
589                 name = ent->name;
590         }
591
592         if (diff_cache(revs, &oid, name, cached))
593                 exit(128);
594
595         diff_set_mnemonic_prefix(&revs->diffopt, "c/", cached ? "i/" : "w/");
596         diffcore_fix_diff_index();
597         diffcore_std(&revs->diffopt);
598         diff_flush(&revs->diffopt);
599         trace_performance_leave("diff-index");
600         return 0;
601 }
602
603 int do_diff_cache(const struct object_id *tree_oid, struct diff_options *opt)
604 {
605         struct rev_info revs;
606
607         repo_init_revisions(opt->repo, &revs, NULL);
608         copy_pathspec(&revs.prune_data, &opt->pathspec);
609         diff_setup_done(&revs.diffopt);
610         revs.diffopt = *opt;
611
612         if (diff_cache(&revs, tree_oid, NULL, 1))
613                 exit(128);
614         clear_pathspec(&revs.prune_data);
615         return 0;
616 }
617
618 int index_differs_from(struct repository *r,
619                        const char *def, const struct diff_flags *flags,
620                        int ita_invisible_in_index)
621 {
622         struct rev_info rev;
623         struct setup_revision_opt opt;
624
625         repo_init_revisions(r, &rev, NULL);
626         memset(&opt, 0, sizeof(opt));
627         opt.def = def;
628         setup_revisions(0, NULL, &rev, &opt);
629         rev.diffopt.flags.quick = 1;
630         rev.diffopt.flags.exit_with_status = 1;
631         if (flags)
632                 diff_flags_or(&rev.diffopt.flags, flags);
633         rev.diffopt.ita_invisible_in_index = ita_invisible_in_index;
634         run_diff_index(&rev, 1);
635         object_array_clear(&rev.pending);
636         return (rev.diffopt.flags.has_changes != 0);
637 }
638
639 static struct strbuf *idiff_prefix_cb(struct diff_options *opt, void *data)
640 {
641         return data;
642 }
643
644 void show_interdiff(const struct object_id *oid1, const struct object_id *oid2,
645                     int indent, struct diff_options *diffopt)
646 {
647         struct diff_options opts;
648         struct strbuf prefix = STRBUF_INIT;
649
650         memcpy(&opts, diffopt, sizeof(opts));
651         opts.output_format = DIFF_FORMAT_PATCH;
652         opts.output_prefix = idiff_prefix_cb;
653         strbuf_addchars(&prefix, ' ', indent);
654         opts.output_prefix_data = &prefix;
655         diff_setup_done(&opts);
656
657         diff_tree_oid(oid1, oid2, "", &opts);
658         diffcore_std(&opts);
659         diff_flush(&opts);
660
661         strbuf_release(&prefix);
662 }