blob: d146bb116f73cdbda69caee38413dc76807ae660 [file] [log] [blame]
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001/*
2 * Recursive Merge algorithm stolen from git-merge-recursive.py by
3 * Fredrik Kuivinen.
4 * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006
5 */
6#include "cache.h"
Elijah Newren4615a8c2019-08-17 11:41:44 -07007#include "merge-recursive.h"
8
David Aguilar1c4b6602014-09-14 00:40:45 -07009#include "advice.h"
Elijah Newren4615a8c2019-08-17 11:41:44 -070010#include "alloc.h"
11#include "attr.h"
Miklos Vajna9047ebb2008-08-12 18:45:14 +020012#include "blob.h"
13#include "builtin.h"
Elijah Newren4615a8c2019-08-17 11:41:44 -070014#include "cache-tree.h"
15#include "commit.h"
16#include "commit-reach.h"
17#include "config.h"
Miklos Vajna9047ebb2008-08-12 18:45:14 +020018#include "diff.h"
19#include "diffcore.h"
Shawn O. Pearce9800c0d2008-09-29 11:04:20 -070020#include "dir.h"
Elijah Newren4615a8c2019-08-17 11:41:44 -070021#include "ll-merge.h"
22#include "lockfile.h"
23#include "object-store.h"
24#include "repository.h"
Stefan Beller18cfc082018-05-15 13:00:28 -070025#include "revision.h"
Elijah Newren4615a8c2019-08-17 11:41:44 -070026#include "string-list.h"
27#include "submodule.h"
28#include "tag.h"
29#include "tree-walk.h"
30#include "unpack-trees.h"
31#include "xdiff-interface.h"
Miklos Vajna9047ebb2008-08-12 18:45:14 +020032
Elijah Newren5bf7e572019-08-17 11:41:41 -070033struct merge_options_internal {
34 int call_depth;
35 int needed_rename_limit;
36 struct hashmap current_file_dir_set;
37 struct string_list df_conflict_file_set;
38 struct unpack_trees_options unpack_opts;
39 struct index_state orig_index;
40};
Miklos Vajna9047ebb2008-08-12 18:45:14 +020041
Kevin Willfordfc65b002017-09-07 10:25:56 -060042struct path_hashmap_entry {
43 struct hashmap_entry e;
44 char path[FLEX_ARRAY];
45};
46
47static int path_hashmap_cmp(const void *cmp_data,
Eric Wong939af162019-10-06 23:30:37 +000048 const struct hashmap_entry *eptr,
49 const struct hashmap_entry *entry_or_key,
Kevin Willfordfc65b002017-09-07 10:25:56 -060050 const void *keydata)
51{
Eric Wong939af162019-10-06 23:30:37 +000052 const struct path_hashmap_entry *a, *b;
Kevin Willfordfc65b002017-09-07 10:25:56 -060053 const char *key = keydata;
54
Eric Wong939af162019-10-06 23:30:37 +000055 a = container_of(eptr, const struct path_hashmap_entry, e);
56 b = container_of(entry_or_key, const struct path_hashmap_entry, e);
57
Kevin Willfordfc65b002017-09-07 10:25:56 -060058 if (ignore_case)
59 return strcasecmp(a->path, key ? key : b->path);
60 else
61 return strcmp(a->path, key ? key : b->path);
62}
63
64static unsigned int path_hash(const char *path)
65{
66 return ignore_case ? strihash(path) : strhash(path);
67}
68
Elijah Newren7c0a6c82019-08-17 11:41:37 -070069/*
70 * For dir_rename_entry, directory names are stored as a full path from the
71 * toplevel of the repository and do not include a trailing '/'. Also:
72 *
73 * dir: original name of directory being renamed
74 * non_unique_new_dir: if true, could not determine new_dir
75 * new_dir: final name of directory being renamed
76 * possible_new_dirs: temporary used to help determine new_dir; see comments
77 * in get_directory_renames() for details
78 */
79struct dir_rename_entry {
Junio C Hamano5efabc72019-10-15 13:48:01 +090080 struct hashmap_entry ent;
Elijah Newren7c0a6c82019-08-17 11:41:37 -070081 char *dir;
82 unsigned non_unique_new_dir:1;
83 struct strbuf new_dir;
84 struct string_list possible_new_dirs;
85};
86
Elijah Newren7fe40b82018-04-19 10:58:05 -070087static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap,
88 char *dir)
89{
90 struct dir_rename_entry key;
91
92 if (dir == NULL)
93 return NULL;
Eric Wongd22245a2019-10-06 23:30:27 +000094 hashmap_entry_init(&key.ent, strhash(dir));
Elijah Newren7fe40b82018-04-19 10:58:05 -070095 key.dir = dir;
Eric Wong404ab782019-10-06 23:30:42 +000096 return hashmap_get_entry(hashmap, &key, ent, NULL);
Elijah Newren7fe40b82018-04-19 10:58:05 -070097}
98
99static int dir_rename_cmp(const void *unused_cmp_data,
Eric Wong939af162019-10-06 23:30:37 +0000100 const struct hashmap_entry *eptr,
101 const struct hashmap_entry *entry_or_key,
Elijah Newren7fe40b82018-04-19 10:58:05 -0700102 const void *unused_keydata)
103{
Eric Wong939af162019-10-06 23:30:37 +0000104 const struct dir_rename_entry *e1, *e2;
105
106 e1 = container_of(eptr, const struct dir_rename_entry, ent);
107 e2 = container_of(entry_or_key, const struct dir_rename_entry, ent);
Elijah Newren7fe40b82018-04-19 10:58:05 -0700108
109 return strcmp(e1->dir, e2->dir);
110}
111
112static void dir_rename_init(struct hashmap *map)
113{
114 hashmap_init(map, dir_rename_cmp, NULL, 0);
115}
116
117static void dir_rename_entry_init(struct dir_rename_entry *entry,
118 char *directory)
119{
Eric Wongd22245a2019-10-06 23:30:27 +0000120 hashmap_entry_init(&entry->ent, strhash(directory));
Elijah Newren7fe40b82018-04-19 10:58:05 -0700121 entry->dir = directory;
122 entry->non_unique_new_dir = 0;
123 strbuf_init(&entry->new_dir, 0);
124 string_list_init(&entry->possible_new_dirs, 0);
125}
126
Elijah Newren7c0a6c82019-08-17 11:41:37 -0700127struct collision_entry {
Junio C Hamano5efabc72019-10-15 13:48:01 +0900128 struct hashmap_entry ent;
Elijah Newren7c0a6c82019-08-17 11:41:37 -0700129 char *target_file;
130 struct string_list source_files;
131 unsigned reported_already:1;
132};
133
Elijah Newrene95ab702018-04-19 10:58:07 -0700134static struct collision_entry *collision_find_entry(struct hashmap *hashmap,
135 char *target_file)
136{
137 struct collision_entry key;
138
Eric Wongd22245a2019-10-06 23:30:27 +0000139 hashmap_entry_init(&key.ent, strhash(target_file));
Elijah Newrene95ab702018-04-19 10:58:07 -0700140 key.target_file = target_file;
Eric Wong404ab782019-10-06 23:30:42 +0000141 return hashmap_get_entry(hashmap, &key, ent, NULL);
Elijah Newrene95ab702018-04-19 10:58:07 -0700142}
143
Eric Wong939af162019-10-06 23:30:37 +0000144static int collision_cmp(const void *unused_cmp_data,
145 const struct hashmap_entry *eptr,
146 const struct hashmap_entry *entry_or_key,
Elijah Newrene95ab702018-04-19 10:58:07 -0700147 const void *unused_keydata)
148{
Eric Wong939af162019-10-06 23:30:37 +0000149 const struct collision_entry *e1, *e2;
150
151 e1 = container_of(eptr, const struct collision_entry, ent);
152 e2 = container_of(entry_or_key, const struct collision_entry, ent);
153
Elijah Newrene95ab702018-04-19 10:58:07 -0700154 return strcmp(e1->target_file, e2->target_file);
155}
156
157static void collision_init(struct hashmap *map)
158{
Eric Wong939af162019-10-06 23:30:37 +0000159 hashmap_init(map, collision_cmp, NULL, 0);
Elijah Newrene95ab702018-04-19 10:58:07 -0700160}
161
Elijah Newren259ccb62019-04-05 08:00:13 -0700162static void flush_output(struct merge_options *opt)
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200163{
Elijah Newren259ccb62019-04-05 08:00:13 -0700164 if (opt->buffer_output < 2 && opt->obuf.len) {
165 fputs(opt->obuf.buf, stdout);
166 strbuf_reset(&opt->obuf);
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200167 }
168}
169
Elijah Newren259ccb62019-04-05 08:00:13 -0700170static int err(struct merge_options *opt, const char *err, ...)
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200171{
172 va_list params;
173
Elijah Newren259ccb62019-04-05 08:00:13 -0700174 if (opt->buffer_output < 2)
175 flush_output(opt);
Johannes Schindelinf1e24262016-08-01 13:44:50 +0200176 else {
Elijah Newren259ccb62019-04-05 08:00:13 -0700177 strbuf_complete(&opt->obuf, '\n');
178 strbuf_addstr(&opt->obuf, "error: ");
Johannes Schindelinf1e24262016-08-01 13:44:50 +0200179 }
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200180 va_start(params, err);
Elijah Newren259ccb62019-04-05 08:00:13 -0700181 strbuf_vaddf(&opt->obuf, err, params);
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200182 va_end(params);
Elijah Newren259ccb62019-04-05 08:00:13 -0700183 if (opt->buffer_output > 1)
184 strbuf_addch(&opt->obuf, '\n');
Johannes Schindelinf1e24262016-08-01 13:44:50 +0200185 else {
Elijah Newren259ccb62019-04-05 08:00:13 -0700186 error("%s", opt->obuf.buf);
187 strbuf_reset(&opt->obuf);
Johannes Schindelinf1e24262016-08-01 13:44:50 +0200188 }
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200189
190 return -1;
191}
192
Nguyễn Thái Ngọc Duyd7cf3a92019-01-12 09:13:30 +0700193static struct tree *shift_tree_object(struct repository *repo,
194 struct tree *one, struct tree *two,
Junio C Hamano85e51b72008-06-30 22:18:57 -0700195 const char *subtree_shift)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200196{
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000197 struct object_id shifted;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200198
Junio C Hamano85e51b72008-06-30 22:18:57 -0700199 if (!*subtree_shift) {
Nguyễn Thái Ngọc Duy90d34052019-06-27 16:28:51 +0700200 shift_tree(repo, &one->object.oid, &two->object.oid, &shifted, 0);
Junio C Hamano85e51b72008-06-30 22:18:57 -0700201 } else {
Nguyễn Thái Ngọc Duy90d34052019-06-27 16:28:51 +0700202 shift_tree_by(repo, &one->object.oid, &two->object.oid, &shifted,
Junio C Hamano85e51b72008-06-30 22:18:57 -0700203 subtree_shift);
204 }
Jeff King4a7e27e2018-08-28 17:22:40 -0400205 if (oideq(&two->object.oid, &shifted))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200206 return two;
Nguyễn Thái Ngọc Duyd7cf3a92019-01-12 09:13:30 +0700207 return lookup_tree(repo, &shifted);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200208}
209
Nguyễn Thái Ngọc Duya133c402019-04-16 16:33:18 +0700210static inline void set_commit_tree(struct commit *c, struct tree *t)
211{
212 c->maybe_tree = t;
213}
214
Nguyễn Thái Ngọc Duyd7cf3a92019-01-12 09:13:30 +0700215static struct commit *make_virtual_commit(struct repository *repo,
216 struct tree *tree,
217 const char *comment)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200218{
Nguyễn Thái Ngọc Duyd7cf3a92019-01-12 09:13:30 +0700219 struct commit *commit = alloc_commit_node(repo);
Junio C Hamanoae8e4c92011-11-07 13:26:22 -0800220
René Scharfea2571652016-08-13 14:16:04 +0200221 set_merge_remote_desc(commit, comment, (struct object *)commit);
Nguyễn Thái Ngọc Duya133c402019-04-16 16:33:18 +0700222 set_commit_tree(commit, tree);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200223 commit->object.parsed = 1;
224 return commit;
225}
226
Elijah Newren25c39362010-09-20 02:28:53 -0600227enum rename_type {
228 RENAME_NORMAL = 0,
Elijah Newren5455c332018-06-09 21:16:14 -0700229 RENAME_VIA_DIR,
Elijah Newren7f867162018-11-07 20:40:26 -0800230 RENAME_ADD,
Elijah Newren25c39362010-09-20 02:28:53 -0600231 RENAME_DELETE,
Elijah Newren4f66dad2011-08-11 23:20:08 -0600232 RENAME_ONE_FILE_TO_ONE,
Elijah Newren461f5042011-08-11 23:20:15 -0600233 RENAME_ONE_FILE_TO_TWO,
234 RENAME_TWO_FILES_TO_ONE
Elijah Newren25c39362010-09-20 02:28:53 -0600235};
236
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200237/*
238 * Since we want to write the index eventually, we cannot reuse the index
239 * for these (temporary) data.
240 */
Jonathan Nieder9cba13c2011-03-16 02:08:34 -0500241struct stage_data {
Elijah Newren8daec1d2019-04-05 08:00:22 -0700242 struct diff_filespec stages[4]; /* mostly for oid & mode; maybe path */
Elijah Newren4f66dad2011-08-11 23:20:08 -0600243 struct rename_conflict_info *rename_conflict_info;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200244 unsigned processed:1;
245};
246
Elijah Newren967d6be2019-04-05 08:00:17 -0700247struct rename {
Elijah Newren6d169fd2019-04-05 08:00:24 -0700248 unsigned processed:1;
Elijah Newren967d6be2019-04-05 08:00:17 -0700249 struct diff_filepair *pair;
Elijah Newrenc336ab82019-04-05 08:00:20 -0700250 const char *branch; /* branch that the rename occurred on */
Elijah Newren967d6be2019-04-05 08:00:17 -0700251 /*
Elijah Newren6d169fd2019-04-05 08:00:24 -0700252 * If directory rename detection affected this rename, what was its
253 * original type ('A' or 'R') and it's original destination before
254 * the directory rename (otherwise, '\0' and NULL for these two vars).
255 */
256 char dir_rename_original_type;
257 char *dir_rename_original_dest;
258 /*
Elijah Newren967d6be2019-04-05 08:00:17 -0700259 * Purpose of src_entry and dst_entry:
260 *
261 * If 'before' is renamed to 'after' then src_entry will contain
262 * the versions of 'before' from the merge_base, HEAD, and MERGE in
263 * stages 1, 2, and 3; dst_entry will contain the respective
264 * versions of 'after' in corresponding locations. Thus, we have a
265 * total of six modes and oids, though some will be null. (Stage 0
266 * is ignored; we're interested in handling conflicts.)
267 *
268 * Since we don't turn on break-rewrites by default, neither
269 * src_entry nor dst_entry can have all three of their stages have
270 * non-null oids, meaning at most four of the six will be non-null.
271 * Also, since this is a rename, both src_entry and dst_entry will
272 * have at least one non-null oid, meaning at least two will be
273 * non-null. Of the six oids, a typical rename will have three be
274 * non-null. Only two implies a rename/delete, and four implies a
275 * rename/add.
276 */
277 struct stage_data *src_entry;
278 struct stage_data *dst_entry;
Elijah Newren967d6be2019-04-05 08:00:17 -0700279};
280
281struct rename_conflict_info {
282 enum rename_type rename_type;
Elijah Newrene9cd1b52019-04-05 08:00:18 -0700283 struct rename *ren1;
284 struct rename *ren2;
Elijah Newren967d6be2019-04-05 08:00:17 -0700285};
286
Elijah Newren4f66dad2011-08-11 23:20:08 -0600287static inline void setup_rename_conflict_info(enum rename_type rename_type,
Elijah Newrene9cd1b52019-04-05 08:00:18 -0700288 struct merge_options *opt,
289 struct rename *ren1,
Elijah Newrenc336ab82019-04-05 08:00:20 -0700290 struct rename *ren2)
Elijah Newren25c39362010-09-20 02:28:53 -0600291{
Elijah Newren4f445452018-10-16 13:19:48 -0700292 struct rename_conflict_info *ci;
293
294 /*
295 * When we have two renames involved, it's easiest to get the
296 * correct things into stage 2 and 3, and to make sure that the
297 * content merge puts HEAD before the other branch if we just
Elijah Newren259ccb62019-04-05 08:00:13 -0700298 * ensure that branch1 == opt->branch1. So, simply flip arguments
Elijah Newren4f445452018-10-16 13:19:48 -0700299 * around if we don't have that.
300 */
Elijah Newrenc336ab82019-04-05 08:00:20 -0700301 if (ren2 && ren1->branch != opt->branch1) {
302 setup_rename_conflict_info(rename_type, opt, ren2, ren1);
Elijah Newren4f445452018-10-16 13:19:48 -0700303 return;
304 }
305
René Scharfeca56dad2021-03-13 17:17:22 +0100306 CALLOC_ARRAY(ci, 1);
Elijah Newren25c39362010-09-20 02:28:53 -0600307 ci->rename_type = rename_type;
Elijah Newrene9cd1b52019-04-05 08:00:18 -0700308 ci->ren1 = ren1;
309 ci->ren2 = ren2;
Elijah Newren25c39362010-09-20 02:28:53 -0600310
Elijah Newrene9cd1b52019-04-05 08:00:18 -0700311 ci->ren1->dst_entry->processed = 0;
312 ci->ren1->dst_entry->rename_conflict_info = ci;
Elijah Newrene9cd1b52019-04-05 08:00:18 -0700313 if (ren2) {
314 ci->ren2->dst_entry->rename_conflict_info = ci;
Elijah Newren25c39362010-09-20 02:28:53 -0600315 }
316}
317
Elijah Newren259ccb62019-04-05 08:00:13 -0700318static int show(struct merge_options *opt, int v)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200319{
Elijah Newren5bf7e572019-08-17 11:41:41 -0700320 return (!opt->priv->call_depth && opt->verbosity >= v) ||
321 opt->verbosity >= 5;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200322}
323
Tarmigan Casebolt28bea9e2009-11-14 13:33:13 -0800324__attribute__((format (printf, 3, 4)))
Elijah Newren259ccb62019-04-05 08:00:13 -0700325static void output(struct merge_options *opt, int v, const char *fmt, ...)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200326{
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200327 va_list ap;
328
Elijah Newren259ccb62019-04-05 08:00:13 -0700329 if (!show(opt, v))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200330 return;
331
Elijah Newren5bf7e572019-08-17 11:41:41 -0700332 strbuf_addchars(&opt->obuf, ' ', opt->priv->call_depth * 2);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200333
334 va_start(ap, fmt);
Elijah Newren259ccb62019-04-05 08:00:13 -0700335 strbuf_vaddf(&opt->obuf, fmt, ap);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200336 va_end(ap);
337
Elijah Newren259ccb62019-04-05 08:00:13 -0700338 strbuf_addch(&opt->obuf, '\n');
339 if (!opt->buffer_output)
340 flush_output(opt);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200341}
342
Elijah Newren259ccb62019-04-05 08:00:13 -0700343static void output_commit_title(struct merge_options *opt, struct commit *commit)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200344{
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +0200345 struct merge_remote_desc *desc;
346
Elijah Newren5bf7e572019-08-17 11:41:41 -0700347 strbuf_addchars(&opt->obuf, ' ', opt->priv->call_depth * 2);
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +0200348 desc = merge_remote_util(commit);
349 if (desc)
Elijah Newren259ccb62019-04-05 08:00:13 -0700350 strbuf_addf(&opt->obuf, "virtual %s\n", desc->name);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200351 else {
Elijah Newren259ccb62019-04-05 08:00:13 -0700352 strbuf_add_unique_abbrev(&opt->obuf, &commit->object.oid,
René Scharfea94bb682016-10-08 17:38:47 +0200353 DEFAULT_ABBREV);
Elijah Newren259ccb62019-04-05 08:00:13 -0700354 strbuf_addch(&opt->obuf, ' ');
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200355 if (parse_commit(commit) != 0)
Elijah Newren259ccb62019-04-05 08:00:13 -0700356 strbuf_addstr(&opt->obuf, _("(bad commit)\n"));
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200357 else {
Christian Couder49b71202010-07-22 15:18:34 +0200358 const char *title;
Jeff King8597ea32014-06-10 17:44:13 -0400359 const char *msg = get_commit_buffer(commit, NULL);
Jeff Kingbc6b8fc2014-06-10 17:41:51 -0400360 int len = find_commit_subject(msg, &title);
Christian Couder49b71202010-07-22 15:18:34 +0200361 if (len)
Elijah Newren259ccb62019-04-05 08:00:13 -0700362 strbuf_addf(&opt->obuf, "%.*s\n", len, title);
Jeff Kingbc6b8fc2014-06-10 17:41:51 -0400363 unuse_commit_buffer(commit, msg);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200364 }
365 }
Elijah Newren259ccb62019-04-05 08:00:13 -0700366 flush_output(opt);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200367}
368
Elijah Newren259ccb62019-04-05 08:00:13 -0700369static int add_cacheinfo(struct merge_options *opt,
Elijah Newren8daec1d2019-04-05 08:00:22 -0700370 const struct diff_filespec *blob,
Elijah Newrend90e7592018-06-09 21:16:12 -0700371 const char *path, int stage, int refresh, int options)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200372{
Elijah Newren259ccb62019-04-05 08:00:13 -0700373 struct index_state *istate = opt->repo->index;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200374 struct cache_entry *ce;
Junio C Hamano1335d762016-07-08 10:59:15 -0700375 int ret;
376
Elijah Newren8daec1d2019-04-05 08:00:22 -0700377 ce = make_cache_entry(istate, blob->mode, &blob->oid, path, stage, 0);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200378 if (!ce)
Elijah Newren259ccb62019-04-05 08:00:13 -0700379 return err(opt, _("add_cacheinfo failed for path '%s'; merge aborting."), path);
Junio C Hamano1335d762016-07-08 10:59:15 -0700380
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700381 ret = add_index_entry(istate, ce, options);
Junio C Hamano1335d762016-07-08 10:59:15 -0700382 if (refresh) {
383 struct cache_entry *nce;
384
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700385 nce = refresh_cache_entry(istate, ce,
386 CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING);
Johannes Schindelin55e9f0e2016-11-26 13:48:06 +0100387 if (!nce)
Elijah Newren259ccb62019-04-05 08:00:13 -0700388 return err(opt, _("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path);
Junio C Hamano1335d762016-07-08 10:59:15 -0700389 if (nce != ce)
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700390 ret = add_index_entry(istate, nce, options);
Junio C Hamano1335d762016-07-08 10:59:15 -0700391 }
392 return ret;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200393}
394
Elijah Newren7c0a6c82019-08-17 11:41:37 -0700395static inline int merge_detect_rename(struct merge_options *opt)
396{
Elijah Newren8599ab42019-08-17 11:41:38 -0700397 return (opt->detect_renames >= 0) ? opt->detect_renames : 1;
Elijah Newren7c0a6c82019-08-17 11:41:37 -0700398}
399
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200400static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)
401{
402 parse_tree(tree);
403 init_tree_desc(desc, tree->buffer, tree->size);
404}
405
Elijah Newren259ccb62019-04-05 08:00:13 -0700406static int unpack_trees_start(struct merge_options *opt,
Elijah Newren3f1c1c32018-05-20 12:17:35 +0200407 struct tree *common,
408 struct tree *head,
409 struct tree *merge)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200410{
411 int rc;
412 struct tree_desc t[3];
Elijah Newrena35edc82018-04-19 10:58:20 -0700413 struct index_state tmp_index = { NULL };
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200414
Elijah Newren5bf7e572019-08-17 11:41:41 -0700415 memset(&opt->priv->unpack_opts, 0, sizeof(opt->priv->unpack_opts));
416 if (opt->priv->call_depth)
417 opt->priv->unpack_opts.index_only = 1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200418 else
Elijah Newren5bf7e572019-08-17 11:41:41 -0700419 opt->priv->unpack_opts.update = 1;
420 opt->priv->unpack_opts.merge = 1;
421 opt->priv->unpack_opts.head_idx = 2;
422 opt->priv->unpack_opts.fn = threeway_merge;
423 opt->priv->unpack_opts.src_index = opt->repo->index;
424 opt->priv->unpack_opts.dst_index = &tmp_index;
425 opt->priv->unpack_opts.aggressive = !merge_detect_rename(opt);
426 setup_unpack_trees_porcelain(&opt->priv->unpack_opts, "merge");
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200427
428 init_tree_desc_from_tree(t+0, common);
429 init_tree_desc_from_tree(t+1, head);
430 init_tree_desc_from_tree(t+2, merge);
431
Elijah Newren5bf7e572019-08-17 11:41:41 -0700432 rc = unpack_trees(3, t, &opt->priv->unpack_opts);
Elijah Newren259ccb62019-04-05 08:00:13 -0700433 cache_tree_free(&opt->repo->index->cache_tree);
Elijah Newrena35edc82018-04-19 10:58:20 -0700434
435 /*
Elijah Newren5bf7e572019-08-17 11:41:41 -0700436 * Update opt->repo->index to match the new results, AFTER saving a
437 * copy in opt->priv->orig_index. Update src_index to point to the
438 * saved copy. (verify_uptodate() checks src_index, and the original
439 * index is the one that had the necessary modification timestamps.)
Elijah Newrena35edc82018-04-19 10:58:20 -0700440 */
Elijah Newren5bf7e572019-08-17 11:41:41 -0700441 opt->priv->orig_index = *opt->repo->index;
Elijah Newren259ccb62019-04-05 08:00:13 -0700442 *opt->repo->index = tmp_index;
Elijah Newren5bf7e572019-08-17 11:41:41 -0700443 opt->priv->unpack_opts.src_index = &opt->priv->orig_index;
Elijah Newrena35edc82018-04-19 10:58:20 -0700444
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200445 return rc;
446}
447
Elijah Newren259ccb62019-04-05 08:00:13 -0700448static void unpack_trees_finish(struct merge_options *opt)
Elijah Newren3f1c1c32018-05-20 12:17:35 +0200449{
Elijah Newren5bf7e572019-08-17 11:41:41 -0700450 discard_index(&opt->priv->orig_index);
451 clear_unpack_trees_porcelain(&opt->priv->unpack_opts);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200452}
453
brian m. carlsondf46d772018-03-12 02:27:26 +0000454static int save_files_dirs(const struct object_id *oid,
Elijah Newrend90e7592018-06-09 21:16:12 -0700455 struct strbuf *base, const char *path,
Ævar Arnfjörð Bjarmason47957482021-03-20 23:37:51 +0100456 unsigned int mode, void *context)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200457{
Kevin Willfordfc65b002017-09-07 10:25:56 -0600458 struct path_hashmap_entry *entry;
Nguyễn Thái Ngọc Duy6a0b0b62014-11-30 16:05:00 +0700459 int baselen = base->len;
Elijah Newren259ccb62019-04-05 08:00:13 -0700460 struct merge_options *opt = context;
Miklos Vajna696ee232008-09-03 19:08:56 +0200461
Nguyễn Thái Ngọc Duy6a0b0b62014-11-30 16:05:00 +0700462 strbuf_addstr(base, path);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200463
Kevin Willfordfc65b002017-09-07 10:25:56 -0600464 FLEX_ALLOC_MEM(entry, path, base->buf, base->len);
Eric Wongd22245a2019-10-06 23:30:27 +0000465 hashmap_entry_init(&entry->e, path_hash(entry->path));
Junio C Hamano5efabc72019-10-15 13:48:01 +0900466 hashmap_add(&opt->priv->current_file_dir_set, &entry->e);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200467
Nguyễn Thái Ngọc Duy6a0b0b62014-11-30 16:05:00 +0700468 strbuf_setlen(base, baselen);
Lars Hjemlid3bee162009-01-25 01:52:05 +0100469 return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200470}
471
Elijah Newren259ccb62019-04-05 08:00:13 -0700472static void get_files_dirs(struct merge_options *opt, struct tree *tree)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200473{
Nguyễn Thái Ngọc Duyf0096c02011-03-25 16:34:19 +0700474 struct pathspec match_all;
Nguyễn Thái Ngọc Duy9a087272013-07-14 15:35:59 +0700475 memset(&match_all, 0, sizeof(match_all));
Ævar Arnfjörð Bjarmason47957482021-03-20 23:37:51 +0100476 read_tree(opt->repo, tree,
477 &match_all, save_files_dirs, opt);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200478}
479
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +0700480static int get_tree_entry_if_blob(struct repository *r,
481 const struct object_id *tree,
Elijah Newren5b047ac2018-04-19 10:58:09 -0700482 const char *path,
Elijah Newren8daec1d2019-04-05 08:00:22 -0700483 struct diff_filespec *dfs)
Elijah Newren5b047ac2018-04-19 10:58:09 -0700484{
485 int ret;
486
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +0700487 ret = get_tree_entry(r, tree, path, &dfs->oid, &dfs->mode);
Elijah Newren8daec1d2019-04-05 08:00:22 -0700488 if (S_ISDIR(dfs->mode)) {
brian m. carlson14228442021-04-26 01:02:56 +0000489 oidcpy(&dfs->oid, null_oid());
Elijah Newren8daec1d2019-04-05 08:00:22 -0700490 dfs->mode = 0;
Elijah Newren5b047ac2018-04-19 10:58:09 -0700491 }
492 return ret;
493}
494
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200495/*
496 * Returns an index_entry instance which doesn't have to correspond to
497 * a real cache entry in Git's index.
498 */
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +0700499static struct stage_data *insert_stage_data(struct repository *r,
500 const char *path,
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200501 struct tree *o, struct tree *a, struct tree *b,
502 struct string_list *entries)
503{
504 struct string_list_item *item;
505 struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +0700506 get_tree_entry_if_blob(r, &o->object.oid, path, &e->stages[1]);
507 get_tree_entry_if_blob(r, &a->object.oid, path, &e->stages[2]);
508 get_tree_entry_if_blob(r, &b->object.oid, path, &e->stages[3]);
Julian Phillips78a395d2010-06-26 00:41:35 +0100509 item = string_list_insert(entries, path);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200510 item->util = e;
511 return e;
512}
513
514/*
515 * Create a dictionary mapping file names to stage_data objects. The
516 * dictionary contains one entry for every path with a non-zero stage entry.
517 */
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700518static struct string_list *get_unmerged(struct index_state *istate)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200519{
520 struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));
521 int i;
522
523 unmerged->strdup_strings = 1;
524
Derrick Stoleef7ef64b2021-04-01 01:49:56 +0000525 /* TODO: audit for interaction with sparse-index. */
526 ensure_full_index(istate);
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700527 for (i = 0; i < istate->cache_nr; i++) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200528 struct string_list_item *item;
529 struct stage_data *e;
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700530 const struct cache_entry *ce = istate->cache[i];
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200531 if (!ce_stage(ce))
532 continue;
533
Julian Phillipse8c8b712010-06-26 00:41:37 +0100534 item = string_list_lookup(unmerged, ce->name);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200535 if (!item) {
Julian Phillips78a395d2010-06-26 00:41:35 +0100536 item = string_list_insert(unmerged, ce->name);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200537 item->util = xcalloc(1, sizeof(struct stage_data));
538 }
539 e = item->util;
540 e->stages[ce_stage(ce)].mode = ce->ce_mode;
brian m. carlson99d1a982016-09-05 20:07:52 +0000541 oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200542 }
543
544 return unmerged;
545}
546
Nguyễn Thái Ngọc Duyfa6ca112016-11-24 18:45:36 +0700547static int string_list_df_name_compare(const char *one, const char *two)
Elijah Newrenef02b312010-09-20 02:29:09 -0600548{
Nguyễn Thái Ngọc Duyfa6ca112016-11-24 18:45:36 +0700549 int onelen = strlen(one);
550 int twolen = strlen(two);
Elijah Newrenf0fd4d02011-08-11 23:19:56 -0600551 /*
552 * Here we only care that entries for D/F conflicts are
553 * adjacent, in particular with the file of the D/F conflict
554 * appearing before files below the corresponding directory.
555 * The order of the rest of the list is irrelevant for us.
Elijah Newrenef02b312010-09-20 02:29:09 -0600556 *
Elijah Newrenf0fd4d02011-08-11 23:19:56 -0600557 * To achieve this, we sort with df_name_compare and provide
558 * the mode S_IFDIR so that D/F conflicts will sort correctly.
559 * We use the mode S_IFDIR for everything else for simplicity,
560 * since in other cases any changes in their order due to
561 * sorting cause no problems for us.
Elijah Newrenef02b312010-09-20 02:29:09 -0600562 */
Nguyễn Thái Ngọc Duyfa6ca112016-11-24 18:45:36 +0700563 int cmp = df_name_compare(one, onelen, S_IFDIR,
564 two, twolen, S_IFDIR);
Elijah Newrenf0fd4d02011-08-11 23:19:56 -0600565 /*
566 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure
567 * that 'foo' comes before 'foo/bar'.
568 */
569 if (cmp)
570 return cmp;
571 return onelen - twolen;
572}
573
Elijah Newren259ccb62019-04-05 08:00:13 -0700574static void record_df_conflict_files(struct merge_options *opt,
Elijah Newren70cc3d32011-08-11 23:19:58 -0600575 struct string_list *entries)
Elijah Newrenef02b312010-09-20 02:29:09 -0600576{
Elijah Newren70cc3d32011-08-11 23:19:58 -0600577 /* If there is a D/F conflict and the file for such a conflict
Elijah Newren2d6bad92018-06-09 21:16:11 -0700578 * currently exists in the working tree, we want to allow it to be
Elijah Newrenedd2faf2011-08-11 23:20:07 -0600579 * removed to make room for the corresponding directory if needed.
580 * The files underneath the directories of such D/F conflicts will
581 * be processed before the corresponding file involved in the D/F
582 * conflict. If the D/F directory ends up being removed by the
583 * merge, then we won't have to touch the D/F file. If the D/F
584 * directory needs to be written to the working copy, then the D/F
585 * file will simply be removed (in make_room_for_path()) to make
586 * room for the necessary paths. Note that if both the directory
587 * and the file need to be present, then the D/F file will be
588 * reinstated with a new unique name at the time it is processed.
Elijah Newrenef02b312010-09-20 02:29:09 -0600589 */
René Scharfeaf4941d2016-08-05 22:42:12 +0200590 struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP;
Elijah Newrenef02b312010-09-20 02:29:09 -0600591 const char *last_file = NULL;
Junio C Hamanoc8516502010-10-21 07:34:33 -0700592 int last_len = 0;
Elijah Newrenef02b312010-09-20 02:29:09 -0600593 int i;
594
Elijah Newren0b30e812011-08-11 23:19:54 -0600595 /*
596 * If we're merging merge-bases, we don't want to bother with
597 * any working directory changes.
598 */
Elijah Newren5bf7e572019-08-17 11:41:41 -0700599 if (opt->priv->call_depth)
Elijah Newren0b30e812011-08-11 23:19:54 -0600600 return;
601
Elijah Newrenf0fd4d02011-08-11 23:19:56 -0600602 /* Ensure D/F conflicts are adjacent in the entries list. */
Elijah Newrenef02b312010-09-20 02:29:09 -0600603 for (i = 0; i < entries->nr; i++) {
Elijah Newrenf701aae2011-08-12 20:23:51 -0600604 struct string_list_item *next = &entries->items[i];
605 string_list_append(&df_sorted_entries, next->string)->util =
606 next->util;
607 }
Nguyễn Thái Ngọc Duyfa6ca112016-11-24 18:45:36 +0700608 df_sorted_entries.cmp = string_list_df_name_compare;
609 string_list_sort(&df_sorted_entries);
Elijah Newrenf0fd4d02011-08-11 23:19:56 -0600610
Elijah Newren5bf7e572019-08-17 11:41:41 -0700611 string_list_clear(&opt->priv->df_conflict_file_set, 1);
Elijah Newrenf701aae2011-08-12 20:23:51 -0600612 for (i = 0; i < df_sorted_entries.nr; i++) {
613 const char *path = df_sorted_entries.items[i].string;
Elijah Newrenef02b312010-09-20 02:29:09 -0600614 int len = strlen(path);
Elijah Newrenf701aae2011-08-12 20:23:51 -0600615 struct stage_data *e = df_sorted_entries.items[i].util;
Elijah Newrenef02b312010-09-20 02:29:09 -0600616
617 /*
618 * Check if last_file & path correspond to a D/F conflict;
619 * i.e. whether path is last_file+'/'+<something>.
Elijah Newren70cc3d32011-08-11 23:19:58 -0600620 * If so, record that it's okay to remove last_file to make
621 * room for path and friends if needed.
Elijah Newrenef02b312010-09-20 02:29:09 -0600622 */
623 if (last_file &&
624 len > last_len &&
625 memcmp(path, last_file, last_len) == 0 &&
626 path[last_len] == '/') {
Elijah Newren5bf7e572019-08-17 11:41:41 -0700627 string_list_insert(&opt->priv->df_conflict_file_set, last_file);
Elijah Newrenef02b312010-09-20 02:29:09 -0600628 }
629
630 /*
631 * Determine whether path could exist as a file in the
632 * working directory as a possible D/F conflict. This
633 * will only occur when it exists in stage 2 as a
634 * file.
635 */
636 if (S_ISREG(e->stages[2].mode) || S_ISLNK(e->stages[2].mode)) {
637 last_file = path;
638 last_len = len;
Elijah Newrenef02b312010-09-20 02:29:09 -0600639 } else {
640 last_file = NULL;
641 }
642 }
Elijah Newrenf701aae2011-08-12 20:23:51 -0600643 string_list_clear(&df_sorted_entries, 0);
Elijah Newrenef02b312010-09-20 02:29:09 -0600644}
645
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200646static int update_stages(struct merge_options *opt, const char *path,
647 const struct diff_filespec *o,
Elijah Newren650467c2011-08-11 23:19:52 -0600648 const struct diff_filespec *a,
649 const struct diff_filespec *b)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200650{
Elijah Newrenf53d3972011-08-11 23:20:25 -0600651
652 /*
653 * NOTE: It is usually a bad idea to call update_stages on a path
654 * before calling update_file on that same path, since it can
655 * sometimes lead to spurious "refusing to lose untracked file..."
656 * messages from update_file (via make_room_for path via
657 * would_lose_untracked). Instead, reverse the order of the calls
658 * (executing update_file first and then update_stages).
659 */
Elijah Newren650467c2011-08-11 23:19:52 -0600660 int clear = 1;
661 int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200662 if (clear)
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700663 if (remove_file_from_index(opt->repo->index, path))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200664 return -1;
665 if (o)
Elijah Newren8daec1d2019-04-05 08:00:22 -0700666 if (add_cacheinfo(opt, o, path, 1, 0, options))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200667 return -1;
668 if (a)
Elijah Newren8daec1d2019-04-05 08:00:22 -0700669 if (add_cacheinfo(opt, a, path, 2, 0, options))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200670 return -1;
671 if (b)
Elijah Newren8daec1d2019-04-05 08:00:22 -0700672 if (add_cacheinfo(opt, b, path, 3, 0, options))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200673 return -1;
674 return 0;
675}
676
Elijah Newrenb8ddf162011-08-11 23:20:02 -0600677static void update_entry(struct stage_data *entry,
678 struct diff_filespec *o,
679 struct diff_filespec *a,
680 struct diff_filespec *b)
Elijah Newren2ff739f2010-09-20 02:28:54 -0600681{
Elijah Newren2ff739f2010-09-20 02:28:54 -0600682 entry->processed = 0;
683 entry->stages[1].mode = o->mode;
684 entry->stages[2].mode = a->mode;
685 entry->stages[3].mode = b->mode;
brian m. carlsonfd429e92016-06-24 23:09:25 +0000686 oidcpy(&entry->stages[1].oid, &o->oid);
687 oidcpy(&entry->stages[2].oid, &a->oid);
688 oidcpy(&entry->stages[3].oid, &b->oid);
Elijah Newren2ff739f2010-09-20 02:28:54 -0600689}
690
Elijah Newren259ccb62019-04-05 08:00:13 -0700691static int remove_file(struct merge_options *opt, int clean,
Miklos Vajnab7fa51d2008-09-02 23:53:47 +0200692 const char *path, int no_wd)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200693{
Elijah Newren5bf7e572019-08-17 11:41:41 -0700694 int update_cache = opt->priv->call_depth || clean;
695 int update_working_directory = !opt->priv->call_depth && !no_wd;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200696
697 if (update_cache) {
Elijah Newren259ccb62019-04-05 08:00:13 -0700698 if (remove_file_from_index(opt->repo->index, path))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200699 return -1;
700 }
701 if (update_working_directory) {
David Turnerae352c72014-05-01 20:21:09 -0400702 if (ignore_case) {
703 struct cache_entry *ce;
Elijah Newren259ccb62019-04-05 08:00:13 -0700704 ce = index_file_exists(opt->repo->index, path, strlen(path),
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700705 ignore_case);
Elijah Newren4cba2b02017-11-24 11:59:01 -0800706 if (ce && ce_stage(ce) == 0 && strcmp(path, ce->name))
David Turnerae352c72014-05-01 20:21:09 -0400707 return 0;
708 }
Peter Collingbourne25755e82010-03-26 15:25:35 +0000709 if (remove_path(path))
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200710 return -1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200711 }
712 return 0;
713}
714
Jeff King45bc1312014-06-19 17:30:26 -0400715/* add a string to a strbuf, but converting "/" to "_" */
716static void add_flattened_path(struct strbuf *out, const char *s)
717{
718 size_t i = out->len;
719 strbuf_addstr(out, s);
720 for (; i < out->len; i++)
721 if (out->buf[i] == '/')
722 out->buf[i] = '_';
723}
724
Elijah Newren4d7101e2019-08-17 11:41:33 -0700725static char *unique_path(struct merge_options *opt,
726 const char *path,
727 const char *branch)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200728{
Kevin Willfordfc65b002017-09-07 10:25:56 -0600729 struct path_hashmap_entry *entry;
Jeff King45bc1312014-06-19 17:30:26 -0400730 struct strbuf newpath = STRBUF_INIT;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200731 int suffix = 0;
Jeff King45bc1312014-06-19 17:30:26 -0400732 size_t base_len;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200733
Jeff King45bc1312014-06-19 17:30:26 -0400734 strbuf_addf(&newpath, "%s~", path);
735 add_flattened_path(&newpath, branch);
736
737 base_len = newpath.len;
Elijah Newren5bf7e572019-08-17 11:41:41 -0700738 while (hashmap_get_from_hash(&opt->priv->current_file_dir_set,
Kevin Willfordfc65b002017-09-07 10:25:56 -0600739 path_hash(newpath.buf), newpath.buf) ||
Elijah Newren5bf7e572019-08-17 11:41:41 -0700740 (!opt->priv->call_depth && file_exists(newpath.buf))) {
Jeff King45bc1312014-06-19 17:30:26 -0400741 strbuf_setlen(&newpath, base_len);
742 strbuf_addf(&newpath, "_%d", suffix++);
743 }
744
Kevin Willfordfc65b002017-09-07 10:25:56 -0600745 FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len);
Eric Wongd22245a2019-10-06 23:30:27 +0000746 hashmap_entry_init(&entry->e, path_hash(entry->path));
Junio C Hamano5efabc72019-10-15 13:48:01 +0900747 hashmap_add(&opt->priv->current_file_dir_set, &entry->e);
Jeff King45bc1312014-06-19 17:30:26 -0400748 return strbuf_detach(&newpath, NULL);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200749}
750
David Turner5423d2e2016-11-07 13:31:31 -0500751/**
752 * Check whether a directory in the index is in the way of an incoming
753 * file. Return 1 if so. If check_working_copy is non-zero, also
754 * check the working directory. If empty_ok is non-zero, also return
755 * 0 in the case where the working-tree dir exists but is empty.
756 */
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700757static int dir_in_way(struct index_state *istate, const char *path,
758 int check_working_copy, int empty_ok)
Elijah Newrenf2507b42011-08-11 23:19:57 -0600759{
Jeff Kingb4600fb2015-09-24 17:07:43 -0400760 int pos;
761 struct strbuf dirpath = STRBUF_INIT;
Elijah Newrenf2507b42011-08-11 23:19:57 -0600762 struct stat st;
763
Jeff Kingb4600fb2015-09-24 17:07:43 -0400764 strbuf_addstr(&dirpath, path);
765 strbuf_addch(&dirpath, '/');
Elijah Newrenf2507b42011-08-11 23:19:57 -0600766
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700767 pos = index_name_pos(istate, dirpath.buf, dirpath.len);
Elijah Newrenf2507b42011-08-11 23:19:57 -0600768
769 if (pos < 0)
770 pos = -1 - pos;
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700771 if (pos < istate->cache_nr &&
772 !strncmp(dirpath.buf, istate->cache[pos]->name, dirpath.len)) {
Jeff Kingb4600fb2015-09-24 17:07:43 -0400773 strbuf_release(&dirpath);
Elijah Newrenf2507b42011-08-11 23:19:57 -0600774 return 1;
775 }
776
Jeff Kingb4600fb2015-09-24 17:07:43 -0400777 strbuf_release(&dirpath);
David Turner5423d2e2016-11-07 13:31:31 -0500778 return check_working_copy && !lstat(path, &st) && S_ISDIR(st.st_mode) &&
Jonathan Tan83e3ad32019-09-18 13:27:38 -0700779 !(empty_ok && is_empty_dir(path)) &&
780 !has_symlink_leading_path(path, strlen(path));
Elijah Newrenf2507b42011-08-11 23:19:57 -0600781}
782
Elijah Newrena35edc82018-04-19 10:58:20 -0700783/*
Elijah Newren1de70db2018-04-19 10:58:23 -0700784 * Returns whether path was tracked in the index before the merge started,
785 * and its oid and mode match the specified values
786 */
Elijah Newren259ccb62019-04-05 08:00:13 -0700787static int was_tracked_and_matches(struct merge_options *opt, const char *path,
Elijah Newren8daec1d2019-04-05 08:00:22 -0700788 const struct diff_filespec *blob)
Junio C Hamano60c91182008-12-15 02:41:24 -0800789{
Elijah Newren5bf7e572019-08-17 11:41:41 -0700790 int pos = index_name_pos(&opt->priv->orig_index, path, strlen(path));
Elijah Newren1de70db2018-04-19 10:58:23 -0700791 struct cache_entry *ce;
792
793 if (0 > pos)
794 /* we were not tracking this path before the merge */
795 return 0;
796
797 /* See if the file we were tracking before matches */
Elijah Newren5bf7e572019-08-17 11:41:41 -0700798 ce = opt->priv->orig_index.cache[pos];
Elijah Newren763a59e2020-01-01 05:20:57 +0000799 return (oideq(&ce->oid, &blob->oid) && ce->ce_mode == blob->mode);
Elijah Newren1de70db2018-04-19 10:58:23 -0700800}
801
802/*
Elijah Newrena35edc82018-04-19 10:58:20 -0700803 * Returns whether path was tracked in the index before the merge started
804 */
Elijah Newren259ccb62019-04-05 08:00:13 -0700805static int was_tracked(struct merge_options *opt, const char *path)
Junio C Hamano60c91182008-12-15 02:41:24 -0800806{
Elijah Newren5bf7e572019-08-17 11:41:41 -0700807 int pos = index_name_pos(&opt->priv->orig_index, path, strlen(path));
Junio C Hamano60c91182008-12-15 02:41:24 -0800808
Johannes Schindelinf8d83fb2016-07-26 18:05:57 +0200809 if (0 <= pos)
Elijah Newrena35edc82018-04-19 10:58:20 -0700810 /* we were tracking this path before the merge */
Johannes Schindelinf8d83fb2016-07-26 18:05:57 +0200811 return 1;
812
Elijah Newrenaacb82d2011-08-11 23:19:59 -0600813 return 0;
Junio C Hamano60c91182008-12-15 02:41:24 -0800814}
815
Elijah Newren259ccb62019-04-05 08:00:13 -0700816static int would_lose_untracked(struct merge_options *opt, const char *path)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200817{
Elijah Newren259ccb62019-04-05 08:00:13 -0700818 struct index_state *istate = opt->repo->index;
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700819
Elijah Newrena35edc82018-04-19 10:58:20 -0700820 /*
821 * This may look like it can be simplified to:
Elijah Newren259ccb62019-04-05 08:00:13 -0700822 * return !was_tracked(opt, path) && file_exists(path)
Elijah Newrena35edc82018-04-19 10:58:20 -0700823 * but it can't. This function needs to know whether path was in
824 * the working tree due to EITHER having been tracked in the index
825 * before the merge OR having been put into the working copy and
826 * index by unpack_trees(). Due to that either-or requirement, we
827 * check the current index instead of the original one.
828 *
829 * Note that we do not need to worry about merge-recursive itself
830 * updating the index after unpack_trees() and before calling this
831 * function, because we strictly require all code paths in
832 * merge-recursive to update the working tree first and the index
833 * second. Doing otherwise would break
834 * update_file()/would_lose_untracked(); see every comment in this
835 * file which mentions "update_stages".
836 */
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700837 int pos = index_name_pos(istate, path, strlen(path));
Elijah Newrena35edc82018-04-19 10:58:20 -0700838
839 if (pos < 0)
840 pos = -1 - pos;
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700841 while (pos < istate->cache_nr &&
842 !strcmp(path, istate->cache[pos]->name)) {
Elijah Newrena35edc82018-04-19 10:58:20 -0700843 /*
844 * If stage #0, it is definitely tracked.
845 * If it has stage #2 then it was tracked
846 * before this merge started. All other
847 * cases the path was not tracked.
848 */
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +0700849 switch (ce_stage(istate->cache[pos])) {
Elijah Newrena35edc82018-04-19 10:58:20 -0700850 case 0:
851 case 2:
852 return 0;
853 }
854 pos++;
855 }
856 return file_exists(path);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200857}
858
Elijah Newren259ccb62019-04-05 08:00:13 -0700859static int was_dirty(struct merge_options *opt, const char *path)
Elijah Newren64b1abe2018-04-19 10:58:12 -0700860{
861 struct cache_entry *ce;
862 int dirty = 1;
863
Elijah Newren5bf7e572019-08-17 11:41:41 -0700864 if (opt->priv->call_depth || !was_tracked(opt, path))
Elijah Newren64b1abe2018-04-19 10:58:12 -0700865 return !dirty;
866
Elijah Newren5bf7e572019-08-17 11:41:41 -0700867 ce = index_file_exists(opt->priv->unpack_opts.src_index,
Elijah Newren277292d2018-04-19 10:58:21 -0700868 path, strlen(path), ignore_case);
Elijah Newren5bf7e572019-08-17 11:41:41 -0700869 dirty = verify_uptodate(ce, &opt->priv->unpack_opts) != 0;
Elijah Newren64b1abe2018-04-19 10:58:12 -0700870 return dirty;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200871}
872
Elijah Newren259ccb62019-04-05 08:00:13 -0700873static int make_room_for_path(struct merge_options *opt, const char *path)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200874{
Elijah Newrened0148a2011-08-11 23:20:01 -0600875 int status, i;
Jiang Xin55653a62012-07-25 22:53:13 +0800876 const char *msg = _("failed to create path '%s'%s");
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200877
Elijah Newrened0148a2011-08-11 23:20:01 -0600878 /* Unlink any D/F conflict files that are in the way */
Elijah Newren5bf7e572019-08-17 11:41:41 -0700879 for (i = 0; i < opt->priv->df_conflict_file_set.nr; i++) {
880 const char *df_path = opt->priv->df_conflict_file_set.items[i].string;
Elijah Newrened0148a2011-08-11 23:20:01 -0600881 size_t pathlen = strlen(path);
882 size_t df_pathlen = strlen(df_path);
883 if (df_pathlen < pathlen &&
884 path[df_pathlen] == '/' &&
885 strncmp(path, df_path, df_pathlen) == 0) {
Elijah Newren259ccb62019-04-05 08:00:13 -0700886 output(opt, 3,
Jiang Xin55653a62012-07-25 22:53:13 +0800887 _("Removing %s to make room for subdirectory\n"),
Elijah Newrened0148a2011-08-11 23:20:01 -0600888 df_path);
889 unlink(df_path);
Elijah Newren5bf7e572019-08-17 11:41:41 -0700890 unsorted_string_list_delete_item(&opt->priv->df_conflict_file_set,
Elijah Newrened0148a2011-08-11 23:20:01 -0600891 i, 0);
892 break;
893 }
894 }
895
896 /* Make sure leading directories are created */
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200897 status = safe_create_leading_directories_const(path);
898 if (status) {
Johannes Schindelin60033032016-07-26 18:06:26 +0200899 if (status == SCLD_EXISTS)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200900 /* something else exists */
Elijah Newren259ccb62019-04-05 08:00:13 -0700901 return err(opt, msg, path, _(": perhaps a D/F conflict?"));
902 return err(opt, msg, path, "");
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200903 }
904
Junio C Hamano60c91182008-12-15 02:41:24 -0800905 /*
906 * Do not unlink a file in the work tree if we are not
907 * tracking it.
908 */
Elijah Newren259ccb62019-04-05 08:00:13 -0700909 if (would_lose_untracked(opt, path))
910 return err(opt, _("refusing to lose untracked file at '%s'"),
Elijah Newrend90e7592018-06-09 21:16:12 -0700911 path);
Junio C Hamano60c91182008-12-15 02:41:24 -0800912
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200913 /* Successful unlink is good.. */
914 if (!unlink(path))
915 return 0;
916 /* .. and so is no existing file */
917 if (errno == ENOENT)
918 return 0;
919 /* .. but not some other error (who really cares what?) */
Elijah Newren259ccb62019-04-05 08:00:13 -0700920 return err(opt, msg, path, _(": perhaps a D/F conflict?"));
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200921}
922
Elijah Newren259ccb62019-04-05 08:00:13 -0700923static int update_file_flags(struct merge_options *opt,
Elijah Newren8daec1d2019-04-05 08:00:22 -0700924 const struct diff_filespec *contents,
Johannes Schindelin75456f92016-07-26 18:06:21 +0200925 const char *path,
926 int update_cache,
927 int update_wd)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200928{
Johannes Schindelin60033032016-07-26 18:06:26 +0200929 int ret = 0;
930
Elijah Newren5bf7e572019-08-17 11:41:41 -0700931 if (opt->priv->call_depth)
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200932 update_wd = 0;
933
934 if (update_wd) {
935 enum object_type type;
936 void *buf;
937 unsigned long size;
938
Elijah Newren8daec1d2019-04-05 08:00:22 -0700939 if (S_ISGITLINK(contents->mode)) {
Junio C Hamano0c44c942009-04-29 11:08:18 -0700940 /*
941 * We may later decide to recursively descend into
942 * the submodule directory and update its index
943 * and/or work tree, but we do not do that now.
944 */
Heiko Voigt68d03e42010-07-07 15:39:13 +0200945 update_wd = 0;
Junio C Hamano0c44c942009-04-29 11:08:18 -0700946 goto update_index;
Heiko Voigt68d03e42010-07-07 15:39:13 +0200947 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200948
Elijah Newren8daec1d2019-04-05 08:00:22 -0700949 buf = read_object_file(&contents->oid, &type, &size);
Elijah Newrenf836bf32019-08-17 11:41:26 -0700950 if (!buf) {
951 ret = err(opt, _("cannot read object %s '%s'"),
952 oid_to_hex(&contents->oid), path);
953 goto free_buf;
954 }
Johannes Schindelin60033032016-07-26 18:06:26 +0200955 if (type != OBJ_BLOB) {
Elijah Newren8daec1d2019-04-05 08:00:22 -0700956 ret = err(opt, _("blob expected for %s '%s'"),
957 oid_to_hex(&contents->oid), path);
Johannes Schindelin60033032016-07-26 18:06:26 +0200958 goto free_buf;
959 }
Elijah Newren8daec1d2019-04-05 08:00:22 -0700960 if (S_ISREG(contents->mode)) {
Brandon Caseyf285a2d2008-10-09 14:12:12 -0500961 struct strbuf strbuf = STRBUF_INIT;
Elijah Newren4d7101e2019-08-17 11:41:33 -0700962 if (convert_to_working_tree(opt->repo->index,
brian m. carlsonab90eca2020-03-16 18:05:02 +0000963 path, buf, size, &strbuf, NULL)) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200964 free(buf);
965 size = strbuf.len;
966 buf = strbuf_detach(&strbuf, NULL);
967 }
968 }
969
Elijah Newren259ccb62019-04-05 08:00:13 -0700970 if (make_room_for_path(opt, path) < 0) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200971 update_wd = 0;
Johannes Schindelin75456f92016-07-26 18:06:21 +0200972 goto free_buf;
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200973 }
Elijah Newren8daec1d2019-04-05 08:00:22 -0700974 if (S_ISREG(contents->mode) ||
975 (!has_symlinks && S_ISLNK(contents->mode))) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200976 int fd;
Elijah Newren8daec1d2019-04-05 08:00:22 -0700977 int mode = (contents->mode & 0100 ? 0777 : 0666);
978
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200979 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
Johannes Schindelin60033032016-07-26 18:06:26 +0200980 if (fd < 0) {
Elijah Newren259ccb62019-04-05 08:00:13 -0700981 ret = err(opt, _("failed to open '%s': %s"),
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200982 path, strerror(errno));
Johannes Schindelin60033032016-07-26 18:06:26 +0200983 goto free_buf;
984 }
Thomas Rastf633ea22012-08-03 14:16:25 +0200985 write_in_full(fd, buf, size);
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200986 close(fd);
Elijah Newren8daec1d2019-04-05 08:00:22 -0700987 } else if (S_ISLNK(contents->mode)) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200988 char *lnk = xmemdupz(buf, size);
989 safe_create_leading_directories_const(path);
990 unlink(path);
Alex Riesen304dcf22008-12-05 01:39:14 +0100991 if (symlink(lnk, path))
Elijah Newren259ccb62019-04-05 08:00:13 -0700992 ret = err(opt, _("failed to symlink '%s': %s"),
Elijah Newrend90e7592018-06-09 21:16:12 -0700993 path, strerror(errno));
Miklos Vajna9047ebb2008-08-12 18:45:14 +0200994 free(lnk);
995 } else
Elijah Newren259ccb62019-04-05 08:00:13 -0700996 ret = err(opt,
Johannes Schindelinbc9204d2016-08-01 13:44:37 +0200997 _("do not know what to do with %06o %s '%s'"),
Elijah Newren8daec1d2019-04-05 08:00:22 -0700998 contents->mode, oid_to_hex(&contents->oid), path);
Elijah Newren93665362018-06-09 21:16:13 -0700999 free_buf:
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001000 free(buf);
1001 }
Elijah Newren93665362018-06-09 21:16:13 -07001002update_index:
Elijah Newrenfb1c18f2020-02-19 17:04:07 +00001003 if (!ret && update_cache) {
1004 int refresh = (!opt->priv->call_depth &&
1005 contents->mode != S_IFGITLINK);
1006 if (add_cacheinfo(opt, contents, path, 0, refresh,
Elijah Newrenfd53b7ff2018-04-19 10:58:16 -07001007 ADD_CACHE_OK_TO_ADD))
1008 return -1;
Elijah Newrenfb1c18f2020-02-19 17:04:07 +00001009 }
Johannes Schindelin60033032016-07-26 18:06:26 +02001010 return ret;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001011}
1012
Elijah Newren259ccb62019-04-05 08:00:13 -07001013static int update_file(struct merge_options *opt,
Johannes Schindelin75456f92016-07-26 18:06:21 +02001014 int clean,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001015 const struct diff_filespec *contents,
Johannes Schindelin75456f92016-07-26 18:06:21 +02001016 const char *path)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001017{
Elijah Newren8daec1d2019-04-05 08:00:22 -07001018 return update_file_flags(opt, contents, path,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001019 opt->priv->call_depth || clean, !opt->priv->call_depth);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001020}
1021
1022/* Low level file merging, update and removal */
1023
Jonathan Nieder9cba13c2011-03-16 02:08:34 -05001024struct merge_file_info {
Elijah Newren8daec1d2019-04-05 08:00:22 -07001025 struct diff_filespec blob; /* mostly use oid & mode; sometimes path */
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001026 unsigned clean:1,
1027 merge:1;
1028};
1029
Elijah Newren259ccb62019-04-05 08:00:13 -07001030static int merge_3way(struct merge_options *opt,
Miklos Vajnab7fa51d2008-09-02 23:53:47 +02001031 mmbuffer_t *result_buf,
Elijah Newrene3de8882019-04-05 08:00:14 -07001032 const struct diff_filespec *o,
Elijah Newren0c059422011-08-11 23:19:51 -06001033 const struct diff_filespec *a,
1034 const struct diff_filespec *b,
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001035 const char *branch1,
Elijah Newrenb2a79422018-11-07 20:40:24 -08001036 const char *branch2,
1037 const int extra_marker_size)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001038{
1039 mmfile_t orig, src1, src2;
Jonathan Nieder712516b2010-08-26 00:49:53 -05001040 struct ll_merge_options ll_opts = {0};
Elijah Newren139ef372019-08-15 14:40:32 -07001041 char *base, *name1, *name2;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001042 int merge_status;
Avery Pennarun8cc5b292009-11-25 21:23:55 -05001043
Elijah Newren259ccb62019-04-05 08:00:13 -07001044 ll_opts.renormalize = opt->renormalize;
Elijah Newrenb2a79422018-11-07 20:40:24 -08001045 ll_opts.extra_marker_size = extra_marker_size;
Elijah Newren259ccb62019-04-05 08:00:13 -07001046 ll_opts.xdl_opts = opt->xdl_opts;
Jonathan Nieder712516b2010-08-26 00:49:53 -05001047
Elijah Newren5bf7e572019-08-17 11:41:41 -07001048 if (opt->priv->call_depth) {
Jonathan Nieder712516b2010-08-26 00:49:53 -05001049 ll_opts.virtual_ancestor = 1;
1050 ll_opts.variant = 0;
1051 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07001052 switch (opt->recursive_variant) {
Elijah Newrenf3081da2019-08-17 11:41:42 -07001053 case MERGE_VARIANT_OURS:
Jonathan Nieder712516b2010-08-26 00:49:53 -05001054 ll_opts.variant = XDL_MERGE_FAVOR_OURS;
Avery Pennarun8cc5b292009-11-25 21:23:55 -05001055 break;
Elijah Newrenf3081da2019-08-17 11:41:42 -07001056 case MERGE_VARIANT_THEIRS:
Jonathan Nieder712516b2010-08-26 00:49:53 -05001057 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;
Avery Pennarun8cc5b292009-11-25 21:23:55 -05001058 break;
1059 default:
Jonathan Nieder712516b2010-08-26 00:49:53 -05001060 ll_opts.variant = 0;
Avery Pennarun8cc5b292009-11-25 21:23:55 -05001061 break;
1062 }
1063 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001064
Elijah Newren139ef372019-08-15 14:40:32 -07001065 assert(a->path && b->path && o->path && opt->ancestor);
1066 if (strcmp(a->path, b->path) || strcmp(a->path, o->path) != 0) {
1067 base = mkpathdup("%s:%s", opt->ancestor, o->path);
Ramsay Jones4e2d0942012-09-04 18:31:14 +01001068 name1 = mkpathdup("%s:%s", branch1, a->path);
1069 name2 = mkpathdup("%s:%s", branch2, b->path);
Martin Renold606475f2009-07-01 22:18:04 +02001070 } else {
Elijah Newren139ef372019-08-15 14:40:32 -07001071 base = mkpathdup("%s", opt->ancestor);
Ramsay Jones4e2d0942012-09-04 18:31:14 +01001072 name1 = mkpathdup("%s", branch1);
1073 name2 = mkpathdup("%s", branch2);
Martin Renold606475f2009-07-01 22:18:04 +02001074 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001075
Elijah Newrene3de8882019-04-05 08:00:14 -07001076 read_mmblob(&orig, &o->oid);
brian m. carlsond4493472016-09-05 20:08:02 +00001077 read_mmblob(&src1, &a->oid);
1078 read_mmblob(&src2, &b->oid);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001079
Elijah Newren816147e2021-03-20 00:03:53 +00001080 /*
1081 * FIXME: Using a->path for normalization rules in ll_merge could be
1082 * wrong if we renamed from a->path to b->path. We should use the
1083 * target path for where the file will be written.
1084 */
Elijah Newren139ef372019-08-15 14:40:32 -07001085 merge_status = ll_merge(result_buf, a->path, &orig, base,
Nguyễn Thái Ngọc Duy32eaa462018-09-21 17:57:27 +02001086 &src1, name1, &src2, name2,
Elijah Newren259ccb62019-04-05 08:00:13 -07001087 opt->repo->index, &ll_opts);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001088
Elijah Newren139ef372019-08-15 14:40:32 -07001089 free(base);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001090 free(name1);
1091 free(name2);
1092 free(orig.ptr);
1093 free(src1.ptr);
1094 free(src2.ptr);
1095 return merge_status;
1096}
1097
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +07001098static int find_first_merges(struct repository *repo,
1099 struct object_array *result, const char *path,
Elijah Newrend90e7592018-06-09 21:16:12 -07001100 struct commit *a, struct commit *b)
Stefan Beller18cfc082018-05-15 13:00:28 -07001101{
1102 int i, j;
1103 struct object_array merges = OBJECT_ARRAY_INIT;
1104 struct commit *commit;
1105 int contains_another;
1106
brian m. carlsondb1ba2a2019-02-19 00:04:59 +00001107 char merged_revision[GIT_MAX_HEXSZ + 2];
Stefan Beller18cfc082018-05-15 13:00:28 -07001108 const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
1109 "--all", merged_revision, NULL };
1110 struct rev_info revs;
1111 struct setup_revision_opt rev_opts;
1112
1113 memset(result, 0, sizeof(struct object_array));
1114 memset(&rev_opts, 0, sizeof(rev_opts));
1115
1116 /* get all revisions that merge commit a */
1117 xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
Elijah Newrend90e7592018-06-09 21:16:12 -07001118 oid_to_hex(&a->object.oid));
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +07001119 repo_init_revisions(repo, &revs, NULL);
Stefan Beller18cfc082018-05-15 13:00:28 -07001120 rev_opts.submodule = path;
1121 /* FIXME: can't handle linked worktrees in submodules yet */
1122 revs.single_worktree = path != NULL;
1123 setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
1124
1125 /* save all revisions from the above list that contain b */
1126 if (prepare_revision_walk(&revs))
1127 die("revision walk setup failed");
1128 while ((commit = get_revision(&revs)) != NULL) {
1129 struct object *o = &(commit->object);
1130 if (in_merge_bases(b, commit))
1131 add_object_array(o, NULL, &merges);
1132 }
1133 reset_revision_walk();
1134
1135 /* Now we've got all merges that contain a and b. Prune all
1136 * merges that contain another found merge and save them in
1137 * result.
1138 */
1139 for (i = 0; i < merges.nr; i++) {
1140 struct commit *m1 = (struct commit *) merges.objects[i].item;
1141
1142 contains_another = 0;
1143 for (j = 0; j < merges.nr; j++) {
1144 struct commit *m2 = (struct commit *) merges.objects[j].item;
1145 if (i != j && in_merge_bases(m2, m1)) {
1146 contains_another = 1;
1147 break;
1148 }
1149 }
1150
1151 if (!contains_another)
1152 add_object_array(merges.objects[i].item, NULL, result);
1153 }
1154
1155 object_array_clear(&merges);
1156 return result->nr;
1157}
1158
1159static void print_commit(struct commit *commit)
1160{
1161 struct strbuf sb = STRBUF_INIT;
1162 struct pretty_print_context ctx = {0};
1163 ctx.date_mode.type = DATE_NORMAL;
Elijah Newren816147e2021-03-20 00:03:53 +00001164 /* FIXME: Merge this with output_commit_title() */
1165 assert(!merge_remote_util(commit));
Stefan Beller18cfc082018-05-15 13:00:28 -07001166 format_commit_message(commit, " %h: %m %s", &sb, &ctx);
1167 fprintf(stderr, "%s\n", sb.buf);
1168 strbuf_release(&sb);
1169}
1170
Elijah Newren8daec1d2019-04-05 08:00:22 -07001171static int is_valid(const struct diff_filespec *dfs)
1172{
1173 return dfs->mode != 0 && !is_null_oid(&dfs->oid);
1174}
1175
Elijah Newren259ccb62019-04-05 08:00:13 -07001176static int merge_submodule(struct merge_options *opt,
Stefan Beller325f3a82018-05-15 13:00:29 -07001177 struct object_id *result, const char *path,
Stefan Beller18cfc082018-05-15 13:00:28 -07001178 const struct object_id *base, const struct object_id *a,
Stefan Beller325f3a82018-05-15 13:00:29 -07001179 const struct object_id *b)
Stefan Beller18cfc082018-05-15 13:00:28 -07001180{
1181 struct commit *commit_base, *commit_a, *commit_b;
1182 int parent_count;
1183 struct object_array merges;
1184
1185 int i;
Elijah Newren5bf7e572019-08-17 11:41:41 -07001186 int search = !opt->priv->call_depth;
Stefan Beller18cfc082018-05-15 13:00:28 -07001187
1188 /* store a in result in case we fail */
Elijah Newren816147e2021-03-20 00:03:53 +00001189 /* FIXME: This is the WRONG resolution for the recursive case when
1190 * we need to be careful to avoid accidentally matching either side.
1191 * Should probably use o instead there, much like we do for merging
1192 * binaries.
1193 */
Stefan Beller18cfc082018-05-15 13:00:28 -07001194 oidcpy(result, a);
1195
1196 /* we can not handle deletion conflicts */
1197 if (is_null_oid(base))
1198 return 0;
1199 if (is_null_oid(a))
1200 return 0;
1201 if (is_null_oid(b))
1202 return 0;
1203
1204 if (add_submodule_odb(path)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07001205 output(opt, 1, _("Failed to merge submodule %s (not checked out)"), path);
Stefan Beller18cfc082018-05-15 13:00:28 -07001206 return 0;
1207 }
1208
Elijah Newren259ccb62019-04-05 08:00:13 -07001209 if (!(commit_base = lookup_commit_reference(opt->repo, base)) ||
1210 !(commit_a = lookup_commit_reference(opt->repo, a)) ||
1211 !(commit_b = lookup_commit_reference(opt->repo, b))) {
1212 output(opt, 1, _("Failed to merge submodule %s (commits not present)"), path);
Stefan Beller18cfc082018-05-15 13:00:28 -07001213 return 0;
1214 }
1215
1216 /* check whether both changes are forward */
1217 if (!in_merge_bases(commit_base, commit_a) ||
1218 !in_merge_bases(commit_base, commit_b)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07001219 output(opt, 1, _("Failed to merge submodule %s (commits don't follow merge-base)"), path);
Stefan Beller18cfc082018-05-15 13:00:28 -07001220 return 0;
1221 }
1222
1223 /* Case #1: a is contained in b or vice versa */
1224 if (in_merge_bases(commit_a, commit_b)) {
1225 oidcpy(result, b);
Elijah Newren259ccb62019-04-05 08:00:13 -07001226 if (show(opt, 3)) {
1227 output(opt, 3, _("Fast-forwarding submodule %s to the following commit:"), path);
1228 output_commit_title(opt, commit_b);
1229 } else if (show(opt, 2))
1230 output(opt, 2, _("Fast-forwarding submodule %s"), path);
Leif Middelschulte76f42122018-05-17 11:40:08 -07001231 else
1232 ; /* no output */
1233
Stefan Beller18cfc082018-05-15 13:00:28 -07001234 return 1;
1235 }
1236 if (in_merge_bases(commit_b, commit_a)) {
1237 oidcpy(result, a);
Elijah Newren259ccb62019-04-05 08:00:13 -07001238 if (show(opt, 3)) {
1239 output(opt, 3, _("Fast-forwarding submodule %s to the following commit:"), path);
1240 output_commit_title(opt, commit_a);
1241 } else if (show(opt, 2))
1242 output(opt, 2, _("Fast-forwarding submodule %s"), path);
Leif Middelschulte76f42122018-05-17 11:40:08 -07001243 else
1244 ; /* no output */
1245
Stefan Beller18cfc082018-05-15 13:00:28 -07001246 return 1;
1247 }
1248
1249 /*
1250 * Case #2: There are one or more merges that contain a and b in
1251 * the submodule. If there is only one, then present it as a
1252 * suggestion to the user, but leave it marked unmerged so the
1253 * user needs to confirm the resolution.
1254 */
1255
1256 /* Skip the search if makes no sense to the calling context. */
1257 if (!search)
1258 return 0;
1259
1260 /* find commit which merges them */
Elijah Newren259ccb62019-04-05 08:00:13 -07001261 parent_count = find_first_merges(opt->repo, &merges, path,
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +07001262 commit_a, commit_b);
Stefan Beller18cfc082018-05-15 13:00:28 -07001263 switch (parent_count) {
1264 case 0:
Elijah Newren259ccb62019-04-05 08:00:13 -07001265 output(opt, 1, _("Failed to merge submodule %s (merge following commits not found)"), path);
Stefan Beller18cfc082018-05-15 13:00:28 -07001266 break;
1267
1268 case 1:
Elijah Newren259ccb62019-04-05 08:00:13 -07001269 output(opt, 1, _("Failed to merge submodule %s (not fast-forward)"), path);
1270 output(opt, 2, _("Found a possible merge resolution for the submodule:\n"));
Stefan Beller18cfc082018-05-15 13:00:28 -07001271 print_commit((struct commit *) merges.objects[0].item);
Elijah Newren259ccb62019-04-05 08:00:13 -07001272 output(opt, 2, _(
Elijah Newrend90e7592018-06-09 21:16:12 -07001273 "If this is correct simply add it to the index "
1274 "for example\n"
1275 "by using:\n\n"
1276 " git update-index --cacheinfo 160000 %s \"%s\"\n\n"
1277 "which will accept this suggestion.\n"),
1278 oid_to_hex(&merges.objects[0].item->oid), path);
Stefan Beller18cfc082018-05-15 13:00:28 -07001279 break;
1280
1281 default:
Elijah Newren259ccb62019-04-05 08:00:13 -07001282 output(opt, 1, _("Failed to merge submodule %s (multiple merges found)"), path);
Stefan Beller18cfc082018-05-15 13:00:28 -07001283 for (i = 0; i < merges.nr; i++)
1284 print_commit((struct commit *) merges.objects[i].item);
1285 }
1286
1287 object_array_clear(&merges);
1288 return 0;
1289}
1290
Elijah Newren259ccb62019-04-05 08:00:13 -07001291static int merge_mode_and_contents(struct merge_options *opt,
Elijah Newrene3de8882019-04-05 08:00:14 -07001292 const struct diff_filespec *o,
Elijah Newrend9573552018-09-19 09:14:34 -07001293 const struct diff_filespec *a,
1294 const struct diff_filespec *b,
1295 const char *filename,
1296 const char *branch1,
1297 const char *branch2,
Elijah Newrenb2a79422018-11-07 20:40:24 -08001298 const int extra_marker_size,
Elijah Newrend9573552018-09-19 09:14:34 -07001299 struct merge_file_info *result)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001300{
Elijah Newren259ccb62019-04-05 08:00:13 -07001301 if (opt->branch1 != branch1) {
Elijah Newren4f445452018-10-16 13:19:48 -07001302 /*
1303 * It's weird getting a reverse merge with HEAD on the bottom
1304 * side of the conflict markers and the other branch on the
1305 * top. Fix that.
1306 */
Elijah Newrene3de8882019-04-05 08:00:14 -07001307 return merge_mode_and_contents(opt, o, b, a,
Elijah Newren4f445452018-10-16 13:19:48 -07001308 filename,
Elijah Newrenb2a79422018-11-07 20:40:24 -08001309 branch2, branch1,
1310 extra_marker_size, result);
Elijah Newren4f445452018-10-16 13:19:48 -07001311 }
1312
Johannes Schindelin3c8a51e2016-07-26 18:06:10 +02001313 result->merge = 0;
1314 result->clean = 1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001315
1316 if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {
Johannes Schindelin3c8a51e2016-07-26 18:06:10 +02001317 result->clean = 0;
Elijah Newren816147e2021-03-20 00:03:53 +00001318 /*
1319 * FIXME: This is a bad resolution for recursive case; for
1320 * the recursive case we want something that is unlikely to
1321 * accidentally match either side. Also, while it makes
1322 * sense to prefer regular files over symlinks, it doesn't
1323 * make sense to prefer regular files over submodules.
1324 */
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001325 if (S_ISREG(a->mode)) {
Elijah Newren8daec1d2019-04-05 08:00:22 -07001326 result->blob.mode = a->mode;
1327 oidcpy(&result->blob.oid, &a->oid);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001328 } else {
Elijah Newren8daec1d2019-04-05 08:00:22 -07001329 result->blob.mode = b->mode;
1330 oidcpy(&result->blob.oid, &b->oid);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001331 }
1332 } else {
Elijah Newren763a59e2020-01-01 05:20:57 +00001333 if (!oideq(&a->oid, &o->oid) && !oideq(&b->oid, &o->oid))
Johannes Schindelin3c8a51e2016-07-26 18:06:10 +02001334 result->merge = 1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001335
1336 /*
1337 * Merge modes
1338 */
Elijah Newrene3de8882019-04-05 08:00:14 -07001339 if (a->mode == b->mode || a->mode == o->mode)
Elijah Newren8daec1d2019-04-05 08:00:22 -07001340 result->blob.mode = b->mode;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001341 else {
Elijah Newren8daec1d2019-04-05 08:00:22 -07001342 result->blob.mode = a->mode;
Elijah Newrene3de8882019-04-05 08:00:14 -07001343 if (b->mode != o->mode) {
Johannes Schindelin3c8a51e2016-07-26 18:06:10 +02001344 result->clean = 0;
1345 result->merge = 1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001346 }
1347 }
1348
Elijah Newren763a59e2020-01-01 05:20:57 +00001349 if (oideq(&a->oid, &b->oid) || oideq(&a->oid, &o->oid))
Elijah Newren8daec1d2019-04-05 08:00:22 -07001350 oidcpy(&result->blob.oid, &b->oid);
Elijah Newren763a59e2020-01-01 05:20:57 +00001351 else if (oideq(&b->oid, &o->oid))
Elijah Newren8daec1d2019-04-05 08:00:22 -07001352 oidcpy(&result->blob.oid, &a->oid);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001353 else if (S_ISREG(a->mode)) {
1354 mmbuffer_t result_buf;
Johannes Schindelin60033032016-07-26 18:06:26 +02001355 int ret = 0, merge_status;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001356
Elijah Newrene3de8882019-04-05 08:00:14 -07001357 merge_status = merge_3way(opt, &result_buf, o, a, b,
Elijah Newrenb2a79422018-11-07 20:40:24 -08001358 branch1, branch2,
1359 extra_marker_size);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001360
1361 if ((merge_status < 0) || !result_buf.ptr)
Elijah Newren259ccb62019-04-05 08:00:13 -07001362 ret = err(opt, _("Failed to execute internal merge"));
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001363
Patryk Obaraa09c9852018-01-28 01:13:19 +01001364 if (!ret &&
1365 write_object_file(result_buf.ptr, result_buf.size,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001366 blob_type, &result->blob.oid))
Elijah Newren259ccb62019-04-05 08:00:13 -07001367 ret = err(opt, _("Unable to add %s to database"),
Johannes Schindelinbc9204d2016-08-01 13:44:37 +02001368 a->path);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001369
1370 free(result_buf.ptr);
Johannes Schindelin60033032016-07-26 18:06:26 +02001371 if (ret)
1372 return ret;
Elijah Newren816147e2021-03-20 00:03:53 +00001373 /* FIXME: bug, what if modes didn't match? */
Johannes Schindelin3c8a51e2016-07-26 18:06:10 +02001374 result->clean = (merge_status == 0);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001375 } else if (S_ISGITLINK(a->mode)) {
Elijah Newren8daec1d2019-04-05 08:00:22 -07001376 result->clean = merge_submodule(opt, &result->blob.oid,
Elijah Newrene3de8882019-04-05 08:00:14 -07001377 o->path,
1378 &o->oid,
Elijah Newrend90e7592018-06-09 21:16:12 -07001379 &a->oid,
1380 &b->oid);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001381 } else if (S_ISLNK(a->mode)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07001382 switch (opt->recursive_variant) {
Elijah Newrenf3081da2019-08-17 11:41:42 -07001383 case MERGE_VARIANT_NORMAL:
Elijah Newren8daec1d2019-04-05 08:00:22 -07001384 oidcpy(&result->blob.oid, &a->oid);
Elijah Newren763a59e2020-01-01 05:20:57 +00001385 if (!oideq(&a->oid, &b->oid))
Junio C Hamanofd48b462017-09-26 11:40:42 +09001386 result->clean = 0;
1387 break;
Elijah Newrenf3081da2019-08-17 11:41:42 -07001388 case MERGE_VARIANT_OURS:
Elijah Newren8daec1d2019-04-05 08:00:22 -07001389 oidcpy(&result->blob.oid, &a->oid);
Junio C Hamanofd48b462017-09-26 11:40:42 +09001390 break;
Elijah Newrenf3081da2019-08-17 11:41:42 -07001391 case MERGE_VARIANT_THEIRS:
Elijah Newren8daec1d2019-04-05 08:00:22 -07001392 oidcpy(&result->blob.oid, &b->oid);
Junio C Hamanofd48b462017-09-26 11:40:42 +09001393 break;
1394 }
Johannes Schindelinef1177d12016-07-26 18:05:50 +02001395 } else
Johannes Schindelin033abf92018-05-02 11:38:39 +02001396 BUG("unsupported object type in the tree");
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001397 }
1398
Elijah Newren05cf21e2018-04-19 10:58:22 -07001399 if (result->merge)
Elijah Newren259ccb62019-04-05 08:00:13 -07001400 output(opt, 2, _("Auto-merging %s"), filename);
Elijah Newren05cf21e2018-04-19 10:58:22 -07001401
Johannes Schindelin3c8a51e2016-07-26 18:06:10 +02001402 return 0;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001403}
1404
Elijah Newren259ccb62019-04-05 08:00:13 -07001405static int handle_rename_via_dir(struct merge_options *opt,
Elijah Newrene2d563d2019-04-05 08:00:21 -07001406 struct rename_conflict_info *ci)
Elijah Newren9c0743f2018-04-19 10:58:10 -07001407{
Elijah Newren5455c332018-06-09 21:16:14 -07001408 /*
1409 * Handle file adds that need to be renamed due to directory rename
1410 * detection. This differs from handle_rename_normal, because
1411 * there is no content merge to do; just move the file into the
1412 * desired final location.
1413 */
Elijah Newrene2d563d2019-04-05 08:00:21 -07001414 const struct rename *ren = ci->ren1;
1415 const struct diff_filespec *dest = ren->pair->two;
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07001416 char *file_path = dest->path;
Derrick Stolee8e012512019-08-17 11:41:25 -07001417 int mark_conflicted = (opt->detect_directory_renames ==
1418 MERGE_DIRECTORY_RENAMES_CONFLICT);
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07001419 assert(ren->dir_rename_original_dest);
Elijah Newren9c0743f2018-04-19 10:58:10 -07001420
Elijah Newren5bf7e572019-08-17 11:41:41 -07001421 if (!opt->priv->call_depth && would_lose_untracked(opt, dest->path)) {
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07001422 mark_conflicted = 1;
1423 file_path = unique_path(opt, dest->path, ren->branch);
Elijah Newren259ccb62019-04-05 08:00:13 -07001424 output(opt, 1, _("Error: Refusing to lose untracked file at %s; "
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07001425 "writing to %s instead."),
1426 dest->path, file_path);
Elijah Newren79c47592018-04-19 10:58:11 -07001427 }
1428
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07001429 if (mark_conflicted) {
1430 /*
1431 * Write the file in worktree at file_path. In the index,
1432 * only record the file at dest->path in the appropriate
1433 * higher stage.
1434 */
1435 if (update_file(opt, 0, dest, file_path))
1436 return -1;
1437 if (file_path != dest->path)
1438 free(file_path);
1439 if (update_stages(opt, dest->path, NULL,
1440 ren->branch == opt->branch1 ? dest : NULL,
1441 ren->branch == opt->branch1 ? NULL : dest))
1442 return -1;
1443 return 0; /* not clean, but conflicted */
1444 } else {
1445 /* Update dest->path both in index and in worktree */
1446 if (update_file(opt, 1, dest, dest->path))
1447 return -1;
1448 return 1; /* clean */
1449 }
Elijah Newren6bdaead2011-08-11 23:20:12 -06001450}
1451
Elijah Newren259ccb62019-04-05 08:00:13 -07001452static int handle_change_delete(struct merge_options *opt,
Elijah Newrend90e7592018-06-09 21:16:12 -07001453 const char *path, const char *old_path,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001454 const struct diff_filespec *o,
1455 const struct diff_filespec *changed,
Elijah Newrend90e7592018-06-09 21:16:12 -07001456 const char *change_branch,
1457 const char *delete_branch,
1458 const char *change, const char *change_past)
Elijah Newrenb7033252011-08-11 23:20:19 -06001459{
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001460 char *alt_path = NULL;
1461 const char *update_path = path;
Johannes Schindelin75456f92016-07-26 18:06:21 +02001462 int ret = 0;
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001463
Elijah Newren5bf7e572019-08-17 11:41:41 -07001464 if (dir_in_way(opt->repo->index, path, !opt->priv->call_depth, 0) ||
1465 (!opt->priv->call_depth && would_lose_untracked(opt, path))) {
Elijah Newren259ccb62019-04-05 08:00:13 -07001466 update_path = alt_path = unique_path(opt, path, change_branch);
Elijah Newrenb7033252011-08-11 23:20:19 -06001467 }
1468
Elijah Newren5bf7e572019-08-17 11:41:41 -07001469 if (opt->priv->call_depth) {
Elijah Newrenb7033252011-08-11 23:20:19 -06001470 /*
1471 * We cannot arbitrarily accept either a_sha or b_sha as
1472 * correct; since there is no true "middle point" between
1473 * them, simply reuse the base version for virtual merge base.
1474 */
Elijah Newren259ccb62019-04-05 08:00:13 -07001475 ret = remove_file_from_index(opt->repo->index, path);
Johannes Schindelin75456f92016-07-26 18:06:21 +02001476 if (!ret)
Elijah Newren8daec1d2019-04-05 08:00:22 -07001477 ret = update_file(opt, 0, o, update_path);
Elijah Newrenb7033252011-08-11 23:20:19 -06001478 } else {
Elijah Newren5b26c3c2018-06-09 21:16:16 -07001479 /*
1480 * Despite the four nearly duplicate messages and argument
1481 * lists below and the ugliness of the nested if-statements,
1482 * having complete messages makes the job easier for
1483 * translators.
1484 *
1485 * The slight variance among the cases is due to the fact
1486 * that:
1487 * 1) directory/file conflicts (in effect if
1488 * !alt_path) could cause us to need to write the
1489 * file to a different path.
1490 * 2) renames (in effect if !old_path) could mean that
1491 * there are two names for the path that the user
1492 * may know the file by.
1493 */
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001494 if (!alt_path) {
1495 if (!old_path) {
Elijah Newren259ccb62019-04-05 08:00:13 -07001496 output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s "
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001497 "and %s in %s. Version %s of %s left in tree."),
1498 change, path, delete_branch, change_past,
1499 change_branch, change_branch, path);
1500 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07001501 output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s "
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001502 "and %s to %s in %s. Version %s of %s left in tree."),
1503 change, old_path, delete_branch, change_past, path,
1504 change_branch, change_branch, path);
1505 }
Jiang Xin55653a62012-07-25 22:53:13 +08001506 } else {
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001507 if (!old_path) {
Elijah Newren259ccb62019-04-05 08:00:13 -07001508 output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s "
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001509 "and %s in %s. Version %s of %s left in tree at %s."),
1510 change, path, delete_branch, change_past,
1511 change_branch, change_branch, path, alt_path);
1512 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07001513 output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s "
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001514 "and %s to %s in %s. Version %s of %s left in tree at %s."),
1515 change, old_path, delete_branch, change_past, path,
1516 change_branch, change_branch, path, alt_path);
1517 }
Jiang Xin55653a62012-07-25 22:53:13 +08001518 }
Elijah Newren35a74ab2011-08-11 23:20:27 -06001519 /*
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001520 * No need to call update_file() on path when change_branch ==
Elijah Newren259ccb62019-04-05 08:00:13 -07001521 * opt->branch1 && !alt_path, since that would needlessly touch
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001522 * path. We could call update_file_flags() with update_cache=0
1523 * and update_wd=0, but that's a no-op.
Elijah Newren35a74ab2011-08-11 23:20:27 -06001524 */
Elijah Newren259ccb62019-04-05 08:00:13 -07001525 if (change_branch != opt->branch1 || alt_path)
Elijah Newren8daec1d2019-04-05 08:00:22 -07001526 ret = update_file(opt, 0, changed, update_path);
Elijah Newrenb7033252011-08-11 23:20:19 -06001527 }
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001528 free(alt_path);
Johannes Schindelin75456f92016-07-26 18:06:21 +02001529
1530 return ret;
Elijah Newrenb7033252011-08-11 23:20:19 -06001531}
1532
Elijah Newren259ccb62019-04-05 08:00:13 -07001533static int handle_rename_delete(struct merge_options *opt,
Elijah Newrene2d563d2019-04-05 08:00:21 -07001534 struct rename_conflict_info *ci)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001535{
Elijah Newrene2d563d2019-04-05 08:00:21 -07001536 const struct rename *ren = ci->ren1;
1537 const struct diff_filespec *orig = ren->pair->one;
1538 const struct diff_filespec *dest = ren->pair->two;
1539 const char *rename_branch = ren->branch;
1540 const char *delete_branch = (opt->branch1 == ren->branch ?
1541 opt->branch2 : opt->branch1);
Elijah Newrene03acb82011-08-11 23:20:20 -06001542
Elijah Newren259ccb62019-04-05 08:00:13 -07001543 if (handle_change_delete(opt,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001544 opt->priv->call_depth ? orig->path : dest->path,
1545 opt->priv->call_depth ? NULL : orig->path,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001546 orig, dest,
Matt McCutchenb26d87f2017-01-28 15:37:01 -05001547 rename_branch, delete_branch,
Johannes Schindelin75456f92016-07-26 18:06:21 +02001548 _("rename"), _("renamed")))
1549 return -1;
Elijah Newrenf53d3972011-08-11 23:20:25 -06001550
Elijah Newren5bf7e572019-08-17 11:41:41 -07001551 if (opt->priv->call_depth)
Elijah Newren259ccb62019-04-05 08:00:13 -07001552 return remove_file_from_index(opt->repo->index, dest->path);
Johannes Schindelin75456f92016-07-26 18:06:21 +02001553 else
Elijah Newren259ccb62019-04-05 08:00:13 -07001554 return update_stages(opt, dest->path, NULL,
1555 rename_branch == opt->branch1 ? dest : NULL,
1556 rename_branch == opt->branch1 ? NULL : dest);
Elijah Newren6ef2cb02010-09-20 02:28:50 -06001557}
1558
Elijah Newren259ccb62019-04-05 08:00:13 -07001559static int handle_file_collision(struct merge_options *opt,
Elijah Newren37b65ce2018-11-07 20:40:25 -08001560 const char *collide_path,
1561 const char *prev_path1,
1562 const char *prev_path2,
1563 const char *branch1, const char *branch2,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001564 struct diff_filespec *a,
1565 struct diff_filespec *b)
Elijah Newren3672c972011-08-11 23:20:22 -06001566{
Elijah Newren37b65ce2018-11-07 20:40:25 -08001567 struct merge_file_info mfi;
Elijah Newren8daec1d2019-04-05 08:00:22 -07001568 struct diff_filespec null;
Elijah Newren37b65ce2018-11-07 20:40:25 -08001569 char *alt_path = NULL;
1570 const char *update_path = collide_path;
Elijah Newren3672c972011-08-11 23:20:22 -06001571
Elijah Newren37b65ce2018-11-07 20:40:25 -08001572 /*
Elijah Newren7f867162018-11-07 20:40:26 -08001573 * It's easiest to get the correct things into stage 2 and 3, and
1574 * to make sure that the content merge puts HEAD before the other
Elijah Newren259ccb62019-04-05 08:00:13 -07001575 * branch if we just ensure that branch1 == opt->branch1. So, simply
Elijah Newren7f867162018-11-07 20:40:26 -08001576 * flip arguments around if we don't have that.
1577 */
Elijah Newren259ccb62019-04-05 08:00:13 -07001578 if (branch1 != opt->branch1) {
1579 return handle_file_collision(opt, collide_path,
Elijah Newren7f867162018-11-07 20:40:26 -08001580 prev_path2, prev_path1,
1581 branch2, branch1,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001582 b, a);
Elijah Newren3672c972011-08-11 23:20:22 -06001583 }
1584
Elijah Newren37b65ce2018-11-07 20:40:25 -08001585 /* Remove rename sources if rename/add or rename/rename(2to1) */
1586 if (prev_path1)
Elijah Newren259ccb62019-04-05 08:00:13 -07001587 remove_file(opt, 1, prev_path1,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001588 opt->priv->call_depth || would_lose_untracked(opt, prev_path1));
Elijah Newren37b65ce2018-11-07 20:40:25 -08001589 if (prev_path2)
Elijah Newren259ccb62019-04-05 08:00:13 -07001590 remove_file(opt, 1, prev_path2,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001591 opt->priv->call_depth || would_lose_untracked(opt, prev_path2));
Elijah Newren37b65ce2018-11-07 20:40:25 -08001592
1593 /*
1594 * Remove the collision path, if it wouldn't cause dirty contents
1595 * or an untracked file to get lost. We'll either overwrite with
1596 * merged contents, or just write out to differently named files.
1597 */
Elijah Newren259ccb62019-04-05 08:00:13 -07001598 if (was_dirty(opt, collide_path)) {
1599 output(opt, 1, _("Refusing to lose dirty file at %s"),
Elijah Newren37b65ce2018-11-07 20:40:25 -08001600 collide_path);
Elijah Newren259ccb62019-04-05 08:00:13 -07001601 update_path = alt_path = unique_path(opt, collide_path, "merged");
1602 } else if (would_lose_untracked(opt, collide_path)) {
Elijah Newren18797a32018-04-19 10:58:13 -07001603 /*
Elijah Newren37b65ce2018-11-07 20:40:25 -08001604 * Only way we get here is if both renames were from
1605 * a directory rename AND user had an untracked file
1606 * at the location where both files end up after the
1607 * two directory renames. See testcase 10d of t6043.
Elijah Newren18797a32018-04-19 10:58:13 -07001608 */
Elijah Newren259ccb62019-04-05 08:00:13 -07001609 output(opt, 1, _("Refusing to lose untracked file at "
Elijah Newren37b65ce2018-11-07 20:40:25 -08001610 "%s, even though it's in the way."),
1611 collide_path);
Elijah Newren259ccb62019-04-05 08:00:13 -07001612 update_path = alt_path = unique_path(opt, collide_path, "merged");
Elijah Newren3672c972011-08-11 23:20:22 -06001613 } else {
Elijah Newren37b65ce2018-11-07 20:40:25 -08001614 /*
1615 * FIXME: It's possible that the two files are identical
1616 * and that the current working copy happens to match, in
1617 * which case we are unnecessarily touching the working
1618 * tree file. It's not a likely enough scenario that I
1619 * want to code up the checks for it and a better fix is
1620 * available if we restructure how unpack_trees() and
1621 * merge-recursive interoperate anyway, so punting for
1622 * now...
1623 */
Elijah Newren259ccb62019-04-05 08:00:13 -07001624 remove_file(opt, 0, collide_path, 0);
Elijah Newren3672c972011-08-11 23:20:22 -06001625 }
Elijah Newren3672c972011-08-11 23:20:22 -06001626
Elijah Newren37b65ce2018-11-07 20:40:25 -08001627 /* Store things in diff_filespecs for functions that need it */
Elijah Newren8daec1d2019-04-05 08:00:22 -07001628 null.path = (char *)collide_path;
brian m. carlson14228442021-04-26 01:02:56 +00001629 oidcpy(&null.oid, null_oid());
Elijah Newren37b65ce2018-11-07 20:40:25 -08001630 null.mode = 0;
Johannes Schindelin75456f92016-07-26 18:06:21 +02001631
Elijah Newren8daec1d2019-04-05 08:00:22 -07001632 if (merge_mode_and_contents(opt, &null, a, b, collide_path,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001633 branch1, branch2, opt->priv->call_depth * 2, &mfi))
Elijah Newren37b65ce2018-11-07 20:40:25 -08001634 return -1;
1635 mfi.clean &= !alt_path;
Elijah Newren8daec1d2019-04-05 08:00:22 -07001636 if (update_file(opt, mfi.clean, &mfi.blob, update_path))
Elijah Newren37b65ce2018-11-07 20:40:25 -08001637 return -1;
Elijah Newren5bf7e572019-08-17 11:41:41 -07001638 if (!mfi.clean && !opt->priv->call_depth &&
Elijah Newren8daec1d2019-04-05 08:00:22 -07001639 update_stages(opt, collide_path, NULL, a, b))
Elijah Newren37b65ce2018-11-07 20:40:25 -08001640 return -1;
1641 free(alt_path);
1642 /*
1643 * FIXME: If both a & b both started with conflicts (only possible
1644 * if they came from a rename/rename(2to1)), but had IDENTICAL
1645 * contents including those conflicts, then in the next line we claim
1646 * it was clean. If someone cares about this case, we should have the
1647 * caller notify us if we started with conflicts.
1648 */
1649 return mfi.clean;
1650}
Elijah Newren7f867162018-11-07 20:40:26 -08001651
Elijah Newren259ccb62019-04-05 08:00:13 -07001652static int handle_rename_add(struct merge_options *opt,
Elijah Newren7f867162018-11-07 20:40:26 -08001653 struct rename_conflict_info *ci)
1654{
1655 /* a was renamed to c, and a separate c was added. */
Elijah Newrene9cd1b52019-04-05 08:00:18 -07001656 struct diff_filespec *a = ci->ren1->pair->one;
1657 struct diff_filespec *c = ci->ren1->pair->two;
Elijah Newren7f867162018-11-07 20:40:26 -08001658 char *path = c->path;
1659 char *prev_path_desc;
1660 struct merge_file_info mfi;
1661
Elijah Newrenc336ab82019-04-05 08:00:20 -07001662 const char *rename_branch = ci->ren1->branch;
1663 const char *add_branch = (opt->branch1 == rename_branch ?
1664 opt->branch2 : opt->branch1);
1665 int other_stage = (ci->ren1->branch == opt->branch1 ? 3 : 2);
Elijah Newren7f867162018-11-07 20:40:26 -08001666
Elijah Newren259ccb62019-04-05 08:00:13 -07001667 output(opt, 1, _("CONFLICT (rename/add): "
Elijah Newren7f867162018-11-07 20:40:26 -08001668 "Rename %s->%s in %s. Added %s in %s"),
Elijah Newrenc336ab82019-04-05 08:00:20 -07001669 a->path, c->path, rename_branch,
1670 c->path, add_branch);
Elijah Newren7f867162018-11-07 20:40:26 -08001671
1672 prev_path_desc = xstrfmt("version of %s from %s", path, a->path);
Elijah Newren481de8a2019-06-04 13:27:50 -07001673 ci->ren1->src_entry->stages[other_stage].path = a->path;
Elijah Newren8daec1d2019-04-05 08:00:22 -07001674 if (merge_mode_and_contents(opt, a, c,
1675 &ci->ren1->src_entry->stages[other_stage],
Elijah Newren3f9c92e2019-04-05 08:00:19 -07001676 prev_path_desc,
Elijah Newren259ccb62019-04-05 08:00:13 -07001677 opt->branch1, opt->branch2,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001678 1 + opt->priv->call_depth * 2, &mfi))
Elijah Newren7f867162018-11-07 20:40:26 -08001679 return -1;
1680 free(prev_path_desc);
1681
Elijah Newren8daec1d2019-04-05 08:00:22 -07001682 ci->ren1->dst_entry->stages[other_stage].path = mfi.blob.path = c->path;
Elijah Newren259ccb62019-04-05 08:00:13 -07001683 return handle_file_collision(opt,
Elijah Newren7f867162018-11-07 20:40:26 -08001684 c->path, a->path, NULL,
Elijah Newrenc336ab82019-04-05 08:00:20 -07001685 rename_branch, add_branch,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001686 &mfi.blob,
1687 &ci->ren1->dst_entry->stages[other_stage]);
Elijah Newren7f867162018-11-07 20:40:26 -08001688}
Elijah Newren37b65ce2018-11-07 20:40:25 -08001689
Elijah Newren259ccb62019-04-05 08:00:13 -07001690static char *find_path_for_conflict(struct merge_options *opt,
Derrick Stolee80cee6e2018-11-07 20:40:31 -08001691 const char *path,
1692 const char *branch1,
1693 const char *branch2)
1694{
1695 char *new_path = NULL;
Elijah Newren5bf7e572019-08-17 11:41:41 -07001696 if (dir_in_way(opt->repo->index, path, !opt->priv->call_depth, 0)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07001697 new_path = unique_path(opt, path, branch1);
1698 output(opt, 1, _("%s is a directory in %s adding "
Derrick Stolee80cee6e2018-11-07 20:40:31 -08001699 "as %s instead"),
1700 path, branch2, new_path);
Elijah Newren259ccb62019-04-05 08:00:13 -07001701 } else if (would_lose_untracked(opt, path)) {
1702 new_path = unique_path(opt, path, branch1);
1703 output(opt, 1, _("Refusing to lose untracked file"
Derrick Stolee80cee6e2018-11-07 20:40:31 -08001704 " at %s; adding as %s instead"),
1705 path, new_path);
1706 }
1707
1708 return new_path;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001709}
1710
Jeff Kingee798742020-01-25 00:37:23 -05001711/*
Junio C Hamano4c616c22020-01-25 18:57:45 -05001712 * Toggle the stage number between "ours" and "theirs" (2 and 3).
Jeff Kingee798742020-01-25 00:37:23 -05001713 */
1714static inline int flip_stage(int stage)
1715{
Junio C Hamano4c616c22020-01-25 18:57:45 -05001716 return (2 + 3) - stage;
Jeff Kingee798742020-01-25 00:37:23 -05001717}
1718
Elijah Newren259ccb62019-04-05 08:00:13 -07001719static int handle_rename_rename_1to2(struct merge_options *opt,
Elijah Newren8ebe7b02018-06-09 21:16:15 -07001720 struct rename_conflict_info *ci)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001721{
Elijah Newren09c01f82010-09-20 02:28:48 -06001722 /* One file was renamed in both branches, but to different names. */
Elijah Newren48c9cb92018-11-07 20:40:29 -08001723 struct merge_file_info mfi;
Elijah Newren48c9cb92018-11-07 20:40:29 -08001724 struct diff_filespec *add;
Elijah Newrene9cd1b52019-04-05 08:00:18 -07001725 struct diff_filespec *o = ci->ren1->pair->one;
1726 struct diff_filespec *a = ci->ren1->pair->two;
1727 struct diff_filespec *b = ci->ren2->pair->two;
Elijah Newren48c9cb92018-11-07 20:40:29 -08001728 char *path_desc;
Elijah Newren07413c52010-09-20 02:29:00 -06001729
Elijah Newren259ccb62019-04-05 08:00:13 -07001730 output(opt, 1, _("CONFLICT (rename/rename): "
Elijah Newren4f66dad2011-08-11 23:20:08 -06001731 "Rename \"%s\"->\"%s\" in branch \"%s\" "
Jiang Xin55653a62012-07-25 22:53:13 +08001732 "rename \"%s\"->\"%s\" in \"%s\"%s"),
Elijah Newrenc336ab82019-04-05 08:00:20 -07001733 o->path, a->path, ci->ren1->branch,
1734 o->path, b->path, ci->ren2->branch,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001735 opt->priv->call_depth ? _(" (left unresolved)") : "");
Johannes Schindelin75456f92016-07-26 18:06:21 +02001736
Elijah Newren48c9cb92018-11-07 20:40:29 -08001737 path_desc = xstrfmt("%s and %s, both renamed from %s",
Elijah Newrene3de8882019-04-05 08:00:14 -07001738 a->path, b->path, o->path);
1739 if (merge_mode_and_contents(opt, o, a, b, path_desc,
Elijah Newrenc336ab82019-04-05 08:00:20 -07001740 ci->ren1->branch, ci->ren2->branch,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001741 opt->priv->call_depth * 2, &mfi))
Elijah Newren48c9cb92018-11-07 20:40:29 -08001742 return -1;
1743 free(path_desc);
1744
Elijah Newren80205042020-02-27 00:05:05 +00001745 if (opt->priv->call_depth)
1746 remove_file_from_index(opt->repo->index, o->path);
1747
1748 /*
1749 * For each destination path, we need to see if there is a
1750 * rename/add collision. If not, we can write the file out
1751 * to the specified location.
1752 */
1753 add = &ci->ren1->dst_entry->stages[flip_stage(2)];
1754 if (is_valid(add)) {
1755 add->path = mfi.blob.path = a->path;
1756 if (handle_file_collision(opt, a->path,
1757 NULL, NULL,
1758 ci->ren1->branch,
1759 ci->ren2->branch,
1760 &mfi.blob, add) < 0)
Johannes Schindelin75456f92016-07-26 18:06:21 +02001761 return -1;
Elijah Newren48c9cb92018-11-07 20:40:29 -08001762 } else {
Elijah Newren80205042020-02-27 00:05:05 +00001763 char *new_path = find_path_for_conflict(opt, a->path,
1764 ci->ren1->branch,
1765 ci->ren2->branch);
1766 if (update_file(opt, 0, &mfi.blob,
1767 new_path ? new_path : a->path))
1768 return -1;
1769 free(new_path);
1770 if (!opt->priv->call_depth &&
1771 update_stages(opt, a->path, NULL, a, NULL))
1772 return -1;
1773 }
Elijah Newren48c9cb92018-11-07 20:40:29 -08001774
Elijah Newren95983da2020-05-13 23:56:32 +00001775 if (!mfi.clean && mfi.blob.mode == a->mode &&
1776 oideq(&mfi.blob.oid, &a->oid)) {
1777 /*
1778 * Getting here means we were attempting to merge a binary
1779 * blob. Since we can't merge binaries, the merge algorithm
1780 * just takes one side. But we don't want to copy the
1781 * contents of one side to both paths; we'd rather use the
1782 * original content at the given path for each path.
1783 */
1784 oidcpy(&mfi.blob.oid, &b->oid);
1785 mfi.blob.mode = b->mode;
1786 }
Elijah Newren80205042020-02-27 00:05:05 +00001787 add = &ci->ren2->dst_entry->stages[flip_stage(3)];
1788 if (is_valid(add)) {
1789 add->path = mfi.blob.path = b->path;
1790 if (handle_file_collision(opt, b->path,
1791 NULL, NULL,
1792 ci->ren1->branch,
1793 ci->ren2->branch,
1794 add, &mfi.blob) < 0)
1795 return -1;
1796 } else {
1797 char *new_path = find_path_for_conflict(opt, b->path,
1798 ci->ren2->branch,
1799 ci->ren1->branch);
1800 if (update_file(opt, 0, &mfi.blob,
1801 new_path ? new_path : b->path))
1802 return -1;
1803 free(new_path);
1804 if (!opt->priv->call_depth &&
1805 update_stages(opt, b->path, NULL, NULL, b))
1806 return -1;
Elijah Newren48c9cb92018-11-07 20:40:29 -08001807 }
Johannes Schindelin75456f92016-07-26 18:06:21 +02001808
1809 return 0;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001810}
1811
Elijah Newren259ccb62019-04-05 08:00:13 -07001812static int handle_rename_rename_2to1(struct merge_options *opt,
Elijah Newren8ebe7b02018-06-09 21:16:15 -07001813 struct rename_conflict_info *ci)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001814{
Elijah Newren461f5042011-08-11 23:20:15 -06001815 /* Two files, a & b, were renamed to the same thing, c. */
Elijah Newrene9cd1b52019-04-05 08:00:18 -07001816 struct diff_filespec *a = ci->ren1->pair->one;
1817 struct diff_filespec *b = ci->ren2->pair->one;
1818 struct diff_filespec *c1 = ci->ren1->pair->two;
1819 struct diff_filespec *c2 = ci->ren2->pair->two;
Elijah Newren461f5042011-08-11 23:20:15 -06001820 char *path = c1->path; /* == c2->path */
Elijah Newren05cf21e2018-04-19 10:58:22 -07001821 char *path_side_1_desc;
1822 char *path_side_2_desc;
Elijah Newren434b8522011-08-11 23:20:18 -06001823 struct merge_file_info mfi_c1;
1824 struct merge_file_info mfi_c2;
Elijah Newren8daec1d2019-04-05 08:00:22 -07001825 int ostage1, ostage2;
Elijah Newren461f5042011-08-11 23:20:15 -06001826
Elijah Newren259ccb62019-04-05 08:00:13 -07001827 output(opt, 1, _("CONFLICT (rename/rename): "
Elijah Newren461f5042011-08-11 23:20:15 -06001828 "Rename %s->%s in %s. "
Jiang Xin55653a62012-07-25 22:53:13 +08001829 "Rename %s->%s in %s"),
Elijah Newrenc336ab82019-04-05 08:00:20 -07001830 a->path, c1->path, ci->ren1->branch,
1831 b->path, c2->path, ci->ren2->branch);
Elijah Newren461f5042011-08-11 23:20:15 -06001832
Elijah Newren2b168ef2018-10-16 13:19:47 -07001833 path_side_1_desc = xstrfmt("version of %s from %s", path, a->path);
1834 path_side_2_desc = xstrfmt("version of %s from %s", path, b->path);
Elijah Newren8daec1d2019-04-05 08:00:22 -07001835 ostage1 = ci->ren1->branch == opt->branch1 ? 3 : 2;
Jeff Kingee798742020-01-25 00:37:23 -05001836 ostage2 = flip_stage(ostage1);
Elijah Newren8daec1d2019-04-05 08:00:22 -07001837 ci->ren1->src_entry->stages[ostage1].path = a->path;
1838 ci->ren2->src_entry->stages[ostage2].path = b->path;
1839 if (merge_mode_and_contents(opt, a, c1,
1840 &ci->ren1->src_entry->stages[ostage1],
1841 path_side_1_desc,
Elijah Newren259ccb62019-04-05 08:00:13 -07001842 opt->branch1, opt->branch2,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001843 1 + opt->priv->call_depth * 2, &mfi_c1) ||
Elijah Newren8daec1d2019-04-05 08:00:22 -07001844 merge_mode_and_contents(opt, b,
1845 &ci->ren2->src_entry->stages[ostage2],
1846 c2, path_side_2_desc,
Elijah Newren259ccb62019-04-05 08:00:13 -07001847 opt->branch1, opt->branch2,
Elijah Newren5bf7e572019-08-17 11:41:41 -07001848 1 + opt->priv->call_depth * 2, &mfi_c2))
Johannes Schindelin75456f92016-07-26 18:06:21 +02001849 return -1;
Elijah Newren05cf21e2018-04-19 10:58:22 -07001850 free(path_side_1_desc);
1851 free(path_side_2_desc);
Elijah Newren8daec1d2019-04-05 08:00:22 -07001852 mfi_c1.blob.path = path;
1853 mfi_c2.blob.path = path;
Elijah Newren434b8522011-08-11 23:20:18 -06001854
Elijah Newren259ccb62019-04-05 08:00:13 -07001855 return handle_file_collision(opt, path, a->path, b->path,
Elijah Newrenc336ab82019-04-05 08:00:20 -07001856 ci->ren1->branch, ci->ren2->branch,
Elijah Newren8daec1d2019-04-05 08:00:22 -07001857 &mfi_c1.blob, &mfi_c2.blob);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02001858}
1859
Elijah Newren9ba91552018-04-19 10:57:59 -07001860/*
Elijah Newrene5257b22018-04-19 10:58:03 -07001861 * Get the diff_filepairs changed between o_tree and tree.
Elijah Newren9ba91552018-04-19 10:57:59 -07001862 */
Elijah Newren259ccb62019-04-05 08:00:13 -07001863static struct diff_queue_struct *get_diffpairs(struct merge_options *opt,
Elijah Newrene5257b22018-04-19 10:58:03 -07001864 struct tree *o_tree,
1865 struct tree *tree)
Elijah Newren9ba91552018-04-19 10:57:59 -07001866{
Elijah Newrene5257b22018-04-19 10:58:03 -07001867 struct diff_queue_struct *ret;
Elijah Newren9ba91552018-04-19 10:57:59 -07001868 struct diff_options opts;
1869
Elijah Newren259ccb62019-04-05 08:00:13 -07001870 repo_diff_setup(opt->repo, &opts);
Elijah Newren9ba91552018-04-19 10:57:59 -07001871 opts.flags.recursive = 1;
1872 opts.flags.rename_empty = 0;
Elijah Newren259ccb62019-04-05 08:00:13 -07001873 opts.detect_rename = merge_detect_rename(opt);
Ben Peart85b46032018-05-02 16:01:14 +00001874 /*
1875 * We do not have logic to handle the detection of copies. In
1876 * fact, it may not even make sense to add such logic: would we
1877 * really want a change to a base file to be propagated through
1878 * multiple other files by a merge?
1879 */
1880 if (opts.detect_rename > DIFF_DETECT_RENAME)
1881 opts.detect_rename = DIFF_DETECT_RENAME;
Elijah Newren8599ab42019-08-17 11:41:38 -07001882 opts.rename_limit = (opt->rename_limit >= 0) ? opt->rename_limit : 1000;
Elijah Newren259ccb62019-04-05 08:00:13 -07001883 opts.rename_score = opt->rename_score;
1884 opts.show_rename_progress = opt->show_rename_progress;
Elijah Newren9ba91552018-04-19 10:57:59 -07001885 opts.output_format = DIFF_FORMAT_NO_OUTPUT;
1886 diff_setup_done(&opts);
1887 diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);
1888 diffcore_std(&opts);
Elijah Newren5bf7e572019-08-17 11:41:41 -07001889 if (opts.needed_rename_limit > opt->priv->needed_rename_limit)
1890 opt->priv->needed_rename_limit = opts.needed_rename_limit;
Elijah Newrene5257b22018-04-19 10:58:03 -07001891
1892 ret = xmalloc(sizeof(*ret));
1893 *ret = diff_queued_diff;
1894
1895 opts.output_format = DIFF_FORMAT_NO_OUTPUT;
1896 diff_queued_diff.nr = 0;
1897 diff_queued_diff.queue = NULL;
1898 diff_flush(&opts);
1899 return ret;
1900}
1901
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07001902static int tree_has_path(struct repository *r, struct tree *tree,
1903 const char *path)
Elijah Newren96e7ffb2018-04-19 10:58:06 -07001904{
1905 struct object_id hashy;
Elijah Newren5ec1e722019-04-05 08:00:12 -07001906 unsigned short mode_o;
Elijah Newren96e7ffb2018-04-19 10:58:06 -07001907
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07001908 return !get_tree_entry(r,
Nguyễn Thái Ngọc Duy50ddb082019-06-27 16:28:49 +07001909 &tree->object.oid, path,
Elijah Newren96e7ffb2018-04-19 10:58:06 -07001910 &hashy, &mode_o);
1911}
1912
Elijah Newrene95ab702018-04-19 10:58:07 -07001913/*
1914 * Return a new string that replaces the beginning portion (which matches
1915 * entry->dir), with entry->new_dir. In perl-speak:
1916 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);
1917 * NOTE:
1918 * Caller must ensure that old_path starts with entry->dir + '/'.
1919 */
1920static char *apply_dir_rename(struct dir_rename_entry *entry,
1921 const char *old_path)
1922{
1923 struct strbuf new_path = STRBUF_INIT;
1924 int oldlen, newlen;
1925
1926 if (entry->non_unique_new_dir)
1927 return NULL;
1928
1929 oldlen = strlen(entry->dir);
Elijah Newren49b8133a2019-10-22 21:22:50 +00001930 if (entry->new_dir.len == 0)
1931 /*
1932 * If someone renamed/merged a subdirectory into the root
1933 * directory (e.g. 'some/subdir' -> ''), then we want to
1934 * avoid returning
1935 * '' + '/filename'
1936 * as the rename; we need to make old_path + oldlen advance
1937 * past the '/' character.
1938 */
1939 oldlen++;
Elijah Newrene95ab702018-04-19 10:58:07 -07001940 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) + 1;
1941 strbuf_grow(&new_path, newlen);
1942 strbuf_addbuf(&new_path, &entry->new_dir);
1943 strbuf_addstr(&new_path, &old_path[oldlen]);
1944
1945 return strbuf_detach(&new_path, NULL);
1946}
1947
Elijah Newren7fe40b82018-04-19 10:58:05 -07001948static void get_renamed_dir_portion(const char *old_path, const char *new_path,
1949 char **old_dir, char **new_dir)
1950{
1951 char *end_of_old, *end_of_new;
Elijah Newren7fe40b82018-04-19 10:58:05 -07001952
Elijah Newrend3eebaa2019-10-22 21:22:49 +00001953 /* Default return values: NULL, meaning no rename */
Elijah Newren7fe40b82018-04-19 10:58:05 -07001954 *old_dir = NULL;
1955 *new_dir = NULL;
1956
1957 /*
1958 * For
1959 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"
1960 * the "e/foo.c" part is the same, we just want to know that
1961 * "a/b/c/d" was renamed to "a/b/some/thing/else"
1962 * so, for this example, this function returns "a/b/c/d" in
1963 * *old_dir and "a/b/some/thing/else" in *new_dir.
Elijah Newrend3eebaa2019-10-22 21:22:49 +00001964 */
1965
1966 /*
1967 * If the basename of the file changed, we don't care. We want
1968 * to know which portion of the directory, if any, changed.
Elijah Newren7fe40b82018-04-19 10:58:05 -07001969 */
1970 end_of_old = strrchr(old_path, '/');
1971 end_of_new = strrchr(new_path, '/');
1972
Elijah Newren49b8133a2019-10-22 21:22:50 +00001973 /*
1974 * If end_of_old is NULL, old_path wasn't in a directory, so there
1975 * could not be a directory rename (our rule elsewhere that a
1976 * directory which still exists is not considered to have been
1977 * renamed means the root directory can never be renamed -- because
1978 * the root directory always exists).
1979 */
1980 if (end_of_old == NULL)
1981 return; /* Note: *old_dir and *new_dir are still NULL */
1982
1983 /*
1984 * If new_path contains no directory (end_of_new is NULL), then we
1985 * have a rename of old_path's directory to the root directory.
1986 */
1987 if (end_of_new == NULL) {
1988 *old_dir = xstrndup(old_path, end_of_old - old_path);
1989 *new_dir = xstrdup("");
Elijah Newren7fe40b82018-04-19 10:58:05 -07001990 return;
Elijah Newren49b8133a2019-10-22 21:22:50 +00001991 }
Elijah Newrend3eebaa2019-10-22 21:22:49 +00001992
1993 /* Find the first non-matching character traversing backwards */
Elijah Newren7fe40b82018-04-19 10:58:05 -07001994 while (*--end_of_new == *--end_of_old &&
1995 end_of_old != old_path &&
1996 end_of_new != new_path)
1997 ; /* Do nothing; all in the while loop */
Elijah Newrend3eebaa2019-10-22 21:22:49 +00001998
1999 /*
2000 * If both got back to the beginning of their strings, then the
2001 * directory didn't change at all, only the basename did.
2002 */
2003 if (end_of_old == old_path && end_of_new == new_path &&
2004 *end_of_old == *end_of_new)
Elijah Newren49b8133a2019-10-22 21:22:50 +00002005 return; /* Note: *old_dir and *new_dir are still NULL */
2006
2007 /*
2008 * If end_of_new got back to the beginning of its string, and
2009 * end_of_old got back to the beginning of some subdirectory, then
2010 * we have a rename/merge of a subdirectory into the root, which
2011 * needs slightly special handling.
2012 *
2013 * Note: There is no need to consider the opposite case, with a
2014 * rename/merge of the root directory into some subdirectory
2015 * because as noted above the root directory always exists so it
2016 * cannot be considered to be renamed.
2017 */
2018 if (end_of_new == new_path &&
2019 end_of_old != old_path && end_of_old[-1] == '/') {
2020 *old_dir = xstrndup(old_path, --end_of_old - old_path);
2021 *new_dir = xstrdup("");
2022 return;
2023 }
Elijah Newrend3eebaa2019-10-22 21:22:49 +00002024
Elijah Newren7fe40b82018-04-19 10:58:05 -07002025 /*
2026 * We've found the first non-matching character in the directory
Elijah Newrend3eebaa2019-10-22 21:22:49 +00002027 * paths. That means the current characters we were looking at
2028 * were part of the first non-matching subdir name going back from
2029 * the end of the strings. Get the whole name by advancing both
2030 * end_of_old and end_of_new to the NEXT '/' character. That will
2031 * represent the entire directory rename.
2032 *
2033 * The reason for the increment is cases like
2034 * a/b/star/foo/whatever.c -> a/b/tar/foo/random.c
2035 * After dropping the basename and going back to the first
2036 * non-matching character, we're now comparing:
2037 * a/b/s and a/b/
2038 * and we want to be comparing:
2039 * a/b/star/ and a/b/tar/
2040 * but without the pre-increment, the one on the right would stay
2041 * a/b/.
Elijah Newren7fe40b82018-04-19 10:58:05 -07002042 */
Elijah Newrend3eebaa2019-10-22 21:22:49 +00002043 end_of_old = strchr(++end_of_old, '/');
2044 end_of_new = strchr(++end_of_new, '/');
Elijah Newren7fe40b82018-04-19 10:58:05 -07002045
Elijah Newrend3eebaa2019-10-22 21:22:49 +00002046 /* Copy the old and new directories into *old_dir and *new_dir. */
2047 *old_dir = xstrndup(old_path, end_of_old - old_path);
2048 *new_dir = xstrndup(new_path, end_of_new - new_path);
Elijah Newren7fe40b82018-04-19 10:58:05 -07002049}
2050
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002051static void remove_hashmap_entries(struct hashmap *dir_renames,
2052 struct string_list *items_to_remove)
2053{
2054 int i;
2055 struct dir_rename_entry *entry;
2056
2057 for (i = 0; i < items_to_remove->nr; i++) {
2058 entry = items_to_remove->items[i].util;
Eric Wong28ee7942019-10-06 23:30:31 +00002059 hashmap_remove(dir_renames, &entry->ent, NULL);
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002060 }
2061 string_list_clear(items_to_remove, 0);
2062}
2063
2064/*
Elijah Newrenf6f77552018-04-19 10:58:08 -07002065 * See if there is a directory rename for path, and if there are any file
2066 * level conflicts for the renamed location. If there is a rename and
2067 * there are no conflicts, return the new name. Otherwise, return NULL.
2068 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002069static char *handle_path_level_conflicts(struct merge_options *opt,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002070 const char *path,
2071 struct dir_rename_entry *entry,
2072 struct hashmap *collisions,
2073 struct tree *tree)
2074{
2075 char *new_path = NULL;
2076 struct collision_entry *collision_ent;
2077 int clean = 1;
2078 struct strbuf collision_paths = STRBUF_INIT;
2079
2080 /*
2081 * entry has the mapping of old directory name to new directory name
2082 * that we want to apply to path.
2083 */
2084 new_path = apply_dir_rename(entry, path);
2085
2086 if (!new_path) {
2087 /* This should only happen when entry->non_unique_new_dir set */
2088 if (!entry->non_unique_new_dir)
2089 BUG("entry->non_unqiue_dir not set and !new_path");
Elijah Newren259ccb62019-04-05 08:00:13 -07002090 output(opt, 1, _("CONFLICT (directory rename split): "
Elijah Newrenf6f77552018-04-19 10:58:08 -07002091 "Unclear where to place %s because directory "
2092 "%s was renamed to multiple other directories, "
2093 "with no destination getting a majority of the "
2094 "files."),
2095 path, entry->dir);
2096 clean = 0;
2097 return NULL;
2098 }
2099
2100 /*
2101 * The caller needs to have ensured that it has pre-populated
2102 * collisions with all paths that map to new_path. Do a quick check
2103 * to ensure that's the case.
2104 */
2105 collision_ent = collision_find_entry(collisions, new_path);
2106 if (collision_ent == NULL)
2107 BUG("collision_ent is NULL");
2108
2109 /*
2110 * Check for one-sided add/add/.../add conflicts, i.e.
2111 * where implicit renames from the other side doing
2112 * directory rename(s) can affect this side of history
2113 * to put multiple paths into the same location. Warn
2114 * and bail on directory renames for such paths.
2115 */
2116 if (collision_ent->reported_already) {
2117 clean = 0;
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07002118 } else if (tree_has_path(opt->repo, tree, new_path)) {
Elijah Newrenf6f77552018-04-19 10:58:08 -07002119 collision_ent->reported_already = 1;
2120 strbuf_add_separated_string_list(&collision_paths, ", ",
2121 &collision_ent->source_files);
Elijah Newren259ccb62019-04-05 08:00:13 -07002122 output(opt, 1, _("CONFLICT (implicit dir rename): Existing "
Elijah Newrenf6f77552018-04-19 10:58:08 -07002123 "file/dir at %s in the way of implicit "
2124 "directory rename(s) putting the following "
2125 "path(s) there: %s."),
2126 new_path, collision_paths.buf);
2127 clean = 0;
2128 } else if (collision_ent->source_files.nr > 1) {
2129 collision_ent->reported_already = 1;
2130 strbuf_add_separated_string_list(&collision_paths, ", ",
2131 &collision_ent->source_files);
Elijah Newren259ccb62019-04-05 08:00:13 -07002132 output(opt, 1, _("CONFLICT (implicit dir rename): Cannot map "
Elijah Newrenf6f77552018-04-19 10:58:08 -07002133 "more than one path to %s; implicit directory "
2134 "renames tried to put these paths there: %s"),
2135 new_path, collision_paths.buf);
2136 clean = 0;
2137 }
2138
2139 /* Free memory we no longer need */
2140 strbuf_release(&collision_paths);
2141 if (!clean && new_path) {
2142 free(new_path);
2143 return NULL;
2144 }
2145
2146 return new_path;
2147}
2148
2149/*
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002150 * There are a couple things we want to do at the directory level:
2151 * 1. Check for both sides renaming to the same thing, in order to avoid
2152 * implicit renaming of files that should be left in place. (See
2153 * testcase 6b in t6043 for details.)
2154 * 2. Prune directory renames if there are still files left in the
2155 * the original directory. These represent a partial directory rename,
2156 * i.e. a rename where only some of the files within the directory
2157 * were renamed elsewhere. (Technically, this could be done earlier
2158 * in get_directory_renames(), except that would prevent us from
2159 * doing the previous check and thus failing testcase 6b.)
2160 * 3. Check for rename/rename(1to2) conflicts (at the directory level).
2161 * In the future, we could potentially record this info as well and
2162 * omit reporting rename/rename(1to2) conflicts for each path within
2163 * the affected directories, thus cleaning up the merge output.
2164 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the
2165 * directory level, because merging directories is fine. If it
2166 * causes conflicts for files within those merged directories, then
2167 * that should be detected at the individual path level.
2168 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002169static void handle_directory_level_conflicts(struct merge_options *opt,
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002170 struct hashmap *dir_re_head,
2171 struct tree *head,
2172 struct hashmap *dir_re_merge,
2173 struct tree *merge)
2174{
2175 struct hashmap_iter iter;
2176 struct dir_rename_entry *head_ent;
2177 struct dir_rename_entry *merge_ent;
2178
2179 struct string_list remove_from_head = STRING_LIST_INIT_NODUP;
2180 struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;
2181
Eric Wong87571c32019-10-06 23:30:38 +00002182 hashmap_for_each_entry(dir_re_head, &iter, head_ent,
Eric Wong87571c32019-10-06 23:30:38 +00002183 ent /* member name */) {
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002184 merge_ent = dir_rename_find_entry(dir_re_merge, head_ent->dir);
2185 if (merge_ent &&
2186 !head_ent->non_unique_new_dir &&
2187 !merge_ent->non_unique_new_dir &&
2188 !strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {
2189 /* 1. Renamed identically; remove it from both sides */
2190 string_list_append(&remove_from_head,
2191 head_ent->dir)->util = head_ent;
2192 strbuf_release(&head_ent->new_dir);
2193 string_list_append(&remove_from_merge,
2194 merge_ent->dir)->util = merge_ent;
2195 strbuf_release(&merge_ent->new_dir);
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07002196 } else if (tree_has_path(opt->repo, head, head_ent->dir)) {
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002197 /* 2. This wasn't a directory rename after all */
2198 string_list_append(&remove_from_head,
2199 head_ent->dir)->util = head_ent;
2200 strbuf_release(&head_ent->new_dir);
2201 }
2202 }
2203
2204 remove_hashmap_entries(dir_re_head, &remove_from_head);
2205 remove_hashmap_entries(dir_re_merge, &remove_from_merge);
2206
Eric Wong87571c32019-10-06 23:30:38 +00002207 hashmap_for_each_entry(dir_re_merge, &iter, merge_ent,
Eric Wong87571c32019-10-06 23:30:38 +00002208 ent /* member name */) {
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002209 head_ent = dir_rename_find_entry(dir_re_head, merge_ent->dir);
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07002210 if (tree_has_path(opt->repo, merge, merge_ent->dir)) {
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002211 /* 2. This wasn't a directory rename after all */
2212 string_list_append(&remove_from_merge,
2213 merge_ent->dir)->util = merge_ent;
2214 } else if (head_ent &&
2215 !head_ent->non_unique_new_dir &&
2216 !merge_ent->non_unique_new_dir) {
2217 /* 3. rename/rename(1to2) */
2218 /*
2219 * We can assume it's not rename/rename(1to1) because
2220 * that was case (1), already checked above. So we
2221 * know that head_ent->new_dir and merge_ent->new_dir
2222 * are different strings.
2223 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002224 output(opt, 1, _("CONFLICT (rename/rename): "
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002225 "Rename directory %s->%s in %s. "
2226 "Rename directory %s->%s in %s"),
Elijah Newren259ccb62019-04-05 08:00:13 -07002227 head_ent->dir, head_ent->new_dir.buf, opt->branch1,
2228 head_ent->dir, merge_ent->new_dir.buf, opt->branch2);
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002229 string_list_append(&remove_from_head,
2230 head_ent->dir)->util = head_ent;
2231 strbuf_release(&head_ent->new_dir);
2232 string_list_append(&remove_from_merge,
2233 merge_ent->dir)->util = merge_ent;
2234 strbuf_release(&merge_ent->new_dir);
2235 }
2236 }
2237
2238 remove_hashmap_entries(dir_re_head, &remove_from_head);
2239 remove_hashmap_entries(dir_re_merge, &remove_from_merge);
2240}
2241
Jeff Kingb53c5022019-02-14 00:50:02 -05002242static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs)
Elijah Newren7fe40b82018-04-19 10:58:05 -07002243{
2244 struct hashmap *dir_renames;
2245 struct hashmap_iter iter;
2246 struct dir_rename_entry *entry;
2247 int i;
2248
2249 /*
2250 * Typically, we think of a directory rename as all files from a
2251 * certain directory being moved to a target directory. However,
2252 * what if someone first moved two files from the original
2253 * directory in one commit, and then renamed the directory
2254 * somewhere else in a later commit? At merge time, we just know
2255 * that files from the original directory went to two different
2256 * places, and that the bulk of them ended up in the same place.
2257 * We want each directory rename to represent where the bulk of the
2258 * files from that directory end up; this function exists to find
2259 * where the bulk of the files went.
2260 *
2261 * The first loop below simply iterates through the list of file
2262 * renames, finding out how often each directory rename pair
2263 * possibility occurs.
2264 */
2265 dir_renames = xmalloc(sizeof(*dir_renames));
2266 dir_rename_init(dir_renames);
2267 for (i = 0; i < pairs->nr; ++i) {
2268 struct string_list_item *item;
2269 int *count;
2270 struct diff_filepair *pair = pairs->queue[i];
2271 char *old_dir, *new_dir;
2272
2273 /* File not part of directory rename if it wasn't renamed */
2274 if (pair->status != 'R')
2275 continue;
2276
2277 get_renamed_dir_portion(pair->one->path, pair->two->path,
2278 &old_dir, &new_dir);
2279 if (!old_dir)
2280 /* Directory didn't change at all; ignore this one. */
2281 continue;
2282
2283 entry = dir_rename_find_entry(dir_renames, old_dir);
2284 if (!entry) {
2285 entry = xmalloc(sizeof(*entry));
2286 dir_rename_entry_init(entry, old_dir);
Eric Wong26b455f2019-10-06 23:30:32 +00002287 hashmap_put(dir_renames, &entry->ent);
Elijah Newren7fe40b82018-04-19 10:58:05 -07002288 } else {
2289 free(old_dir);
2290 }
2291 item = string_list_lookup(&entry->possible_new_dirs, new_dir);
2292 if (!item) {
2293 item = string_list_insert(&entry->possible_new_dirs,
2294 new_dir);
2295 item->util = xcalloc(1, sizeof(int));
2296 } else {
2297 free(new_dir);
2298 }
2299 count = item->util;
2300 *count += 1;
2301 }
2302
2303 /*
2304 * For each directory with files moved out of it, we find out which
2305 * target directory received the most files so we can declare it to
2306 * be the "winning" target location for the directory rename. This
2307 * winner gets recorded in new_dir. If there is no winner
2308 * (multiple target directories received the same number of files),
2309 * we set non_unique_new_dir. Once we've determined the winner (or
2310 * that there is no winner), we no longer need possible_new_dirs.
2311 */
Eric Wong87571c32019-10-06 23:30:38 +00002312 hashmap_for_each_entry(dir_renames, &iter, entry,
Eric Wong87571c32019-10-06 23:30:38 +00002313 ent /* member name */) {
Elijah Newren7fe40b82018-04-19 10:58:05 -07002314 int max = 0;
2315 int bad_max = 0;
2316 char *best = NULL;
2317
2318 for (i = 0; i < entry->possible_new_dirs.nr; i++) {
2319 int *count = entry->possible_new_dirs.items[i].util;
2320
2321 if (*count == max)
2322 bad_max = max;
2323 else if (*count > max) {
2324 max = *count;
2325 best = entry->possible_new_dirs.items[i].string;
2326 }
2327 }
2328 if (bad_max == max)
2329 entry->non_unique_new_dir = 1;
2330 else {
2331 assert(entry->new_dir.len == 0);
2332 strbuf_addstr(&entry->new_dir, best);
2333 }
2334 /*
2335 * The relevant directory sub-portion of the original full
2336 * filepaths were xstrndup'ed before inserting into
2337 * possible_new_dirs, and instead of manually iterating the
2338 * list and free'ing each, just lie and tell
2339 * possible_new_dirs that it did the strdup'ing so that it
2340 * will free them for us.
2341 */
2342 entry->possible_new_dirs.strdup_strings = 1;
2343 string_list_clear(&entry->possible_new_dirs, 1);
2344 }
2345
2346 return dir_renames;
2347}
2348
Elijah Newrene95ab702018-04-19 10:58:07 -07002349static struct dir_rename_entry *check_dir_renamed(const char *path,
2350 struct hashmap *dir_renames)
2351{
René Scharfe9da2d032018-06-10 12:56:31 +02002352 char *temp = xstrdup(path);
Elijah Newrene95ab702018-04-19 10:58:07 -07002353 char *end;
Elijah Newrenc3b9bc92018-09-05 10:03:07 -07002354 struct dir_rename_entry *entry = NULL;
Elijah Newrene95ab702018-04-19 10:58:07 -07002355
Elijah Newrene95ab702018-04-19 10:58:07 -07002356 while ((end = strrchr(temp, '/'))) {
2357 *end = '\0';
2358 entry = dir_rename_find_entry(dir_renames, temp);
2359 if (entry)
René Scharfe9da2d032018-06-10 12:56:31 +02002360 break;
Elijah Newrene95ab702018-04-19 10:58:07 -07002361 }
René Scharfe9da2d032018-06-10 12:56:31 +02002362 free(temp);
2363 return entry;
Elijah Newrene95ab702018-04-19 10:58:07 -07002364}
2365
2366static void compute_collisions(struct hashmap *collisions,
2367 struct hashmap *dir_renames,
2368 struct diff_queue_struct *pairs)
2369{
2370 int i;
2371
2372 /*
2373 * Multiple files can be mapped to the same path due to directory
2374 * renames done by the other side of history. Since that other
2375 * side of history could have merged multiple directories into one,
2376 * if our side of history added the same file basename to each of
2377 * those directories, then all N of them would get implicitly
2378 * renamed by the directory rename detection into the same path,
2379 * and we'd get an add/add/.../add conflict, and all those adds
2380 * from *this* side of history. This is not representable in the
2381 * index, and users aren't going to easily be able to make sense of
2382 * it. So we need to provide a good warning about what's
2383 * happening, and fall back to no-directory-rename detection
2384 * behavior for those paths.
2385 *
2386 * See testcases 9e and all of section 5 from t6043 for examples.
2387 */
2388 collision_init(collisions);
2389
2390 for (i = 0; i < pairs->nr; ++i) {
2391 struct dir_rename_entry *dir_rename_ent;
2392 struct collision_entry *collision_ent;
2393 char *new_path;
2394 struct diff_filepair *pair = pairs->queue[i];
2395
Elijah Newren6e7e0272018-04-19 10:58:15 -07002396 if (pair->status != 'A' && pair->status != 'R')
Elijah Newrene95ab702018-04-19 10:58:07 -07002397 continue;
2398 dir_rename_ent = check_dir_renamed(pair->two->path,
2399 dir_renames);
2400 if (!dir_rename_ent)
2401 continue;
2402
2403 new_path = apply_dir_rename(dir_rename_ent, pair->two->path);
2404 if (!new_path)
2405 /*
2406 * dir_rename_ent->non_unique_new_path is true, which
2407 * means there is no directory rename for us to use,
2408 * which means it won't cause us any additional
2409 * collisions.
2410 */
2411 continue;
2412 collision_ent = collision_find_entry(collisions, new_path);
2413 if (!collision_ent) {
René Scharfeca56dad2021-03-13 17:17:22 +01002414 CALLOC_ARRAY(collision_ent, 1);
Eric Wongd22245a2019-10-06 23:30:27 +00002415 hashmap_entry_init(&collision_ent->ent,
2416 strhash(new_path));
Eric Wong26b455f2019-10-06 23:30:32 +00002417 hashmap_put(collisions, &collision_ent->ent);
Elijah Newrene95ab702018-04-19 10:58:07 -07002418 collision_ent->target_file = new_path;
2419 } else {
2420 free(new_path);
2421 }
2422 string_list_insert(&collision_ent->source_files,
2423 pair->two->path);
2424 }
2425}
2426
Elijah Newren259ccb62019-04-05 08:00:13 -07002427static char *check_for_directory_rename(struct merge_options *opt,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002428 const char *path,
2429 struct tree *tree,
2430 struct hashmap *dir_renames,
2431 struct hashmap *dir_rename_exclusions,
2432 struct hashmap *collisions,
2433 int *clean_merge)
2434{
2435 char *new_path = NULL;
2436 struct dir_rename_entry *entry = check_dir_renamed(path, dir_renames);
2437 struct dir_rename_entry *oentry = NULL;
2438
2439 if (!entry)
2440 return new_path;
2441
2442 /*
2443 * This next part is a little weird. We do not want to do an
2444 * implicit rename into a directory we renamed on our side, because
2445 * that will result in a spurious rename/rename(1to2) conflict. An
2446 * example:
2447 * Base commit: dumbdir/afile, otherdir/bfile
2448 * Side 1: smrtdir/afile, otherdir/bfile
2449 * Side 2: dumbdir/afile, dumbdir/bfile
2450 * Here, while working on Side 1, we could notice that otherdir was
2451 * renamed/merged to dumbdir, and change the diff_filepair for
2452 * otherdir/bfile into a rename into dumbdir/bfile. However, Side
2453 * 2 will notice the rename from dumbdir to smrtdir, and do the
2454 * transitive rename to move it from dumbdir/bfile to
2455 * smrtdir/bfile. That gives us bfile in dumbdir vs being in
2456 * smrtdir, a rename/rename(1to2) conflict. We really just want
2457 * the file to end up in smrtdir. And the way to achieve that is
2458 * to not let Side1 do the rename to dumbdir, since we know that is
2459 * the source of one of our directory renames.
2460 *
2461 * That's why oentry and dir_rename_exclusions is here.
2462 *
2463 * As it turns out, this also prevents N-way transient rename
2464 * confusion; See testcases 9c and 9d of t6043.
2465 */
2466 oentry = dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);
2467 if (oentry) {
Elijah Newren259ccb62019-04-05 08:00:13 -07002468 output(opt, 1, _("WARNING: Avoiding applying %s -> %s rename "
Elijah Newrenf6f77552018-04-19 10:58:08 -07002469 "to %s, because %s itself was renamed."),
2470 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);
2471 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07002472 new_path = handle_path_level_conflicts(opt, path, entry,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002473 collisions, tree);
2474 *clean_merge &= (new_path != NULL);
2475 }
2476
2477 return new_path;
2478}
2479
Elijah Newren259ccb62019-04-05 08:00:13 -07002480static void apply_directory_rename_modifications(struct merge_options *opt,
Elijah Newren9c0743f2018-04-19 10:58:10 -07002481 struct diff_filepair *pair,
2482 char *new_path,
2483 struct rename *re,
2484 struct tree *tree,
2485 struct tree *o_tree,
2486 struct tree *a_tree,
2487 struct tree *b_tree,
Jeff Kingb53c5022019-02-14 00:50:02 -05002488 struct string_list *entries)
Elijah Newren9c0743f2018-04-19 10:58:10 -07002489{
2490 struct string_list_item *item;
2491 int stage = (tree == a_tree ? 2 : 3);
Elijah Newren18797a32018-04-19 10:58:13 -07002492 int update_wd;
Elijah Newren9c0743f2018-04-19 10:58:10 -07002493
2494 /*
2495 * In all cases where we can do directory rename detection,
2496 * unpack_trees() will have read pair->two->path into the
2497 * index and the working copy. We need to remove it so that
2498 * we can instead place it at new_path. It is guaranteed to
2499 * not be untracked (unpack_trees() would have errored out
2500 * saying the file would have been overwritten), but it might
2501 * be dirty, though.
2502 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002503 update_wd = !was_dirty(opt, pair->two->path);
Elijah Newren18797a32018-04-19 10:58:13 -07002504 if (!update_wd)
Elijah Newren259ccb62019-04-05 08:00:13 -07002505 output(opt, 1, _("Refusing to lose dirty file at %s"),
Elijah Newren18797a32018-04-19 10:58:13 -07002506 pair->two->path);
Elijah Newren259ccb62019-04-05 08:00:13 -07002507 remove_file(opt, 1, pair->two->path, !update_wd);
Elijah Newren9c0743f2018-04-19 10:58:10 -07002508
2509 /* Find or create a new re->dst_entry */
2510 item = string_list_lookup(entries, new_path);
2511 if (item) {
2512 /*
2513 * Since we're renaming on this side of history, and it's
2514 * due to a directory rename on the other side of history
2515 * (which we only allow when the directory in question no
2516 * longer exists on the other side of history), the
2517 * original entry for re->dst_entry is no longer
2518 * necessary...
2519 */
2520 re->dst_entry->processed = 1;
2521
2522 /*
2523 * ...because we'll be using this new one.
2524 */
2525 re->dst_entry = item->util;
2526 } else {
2527 /*
2528 * re->dst_entry is for the before-dir-rename path, and we
2529 * need it to hold information for the after-dir-rename
2530 * path. Before creating a new entry, we need to mark the
2531 * old one as unnecessary (...unless it is shared by
2532 * src_entry, i.e. this didn't use to be a rename, in which
2533 * case we can just allow the normal processing to happen
2534 * for it).
2535 */
2536 if (pair->status == 'R')
2537 re->dst_entry->processed = 1;
2538
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07002539 re->dst_entry = insert_stage_data(opt->repo, new_path,
Elijah Newren9c0743f2018-04-19 10:58:10 -07002540 o_tree, a_tree, b_tree,
2541 entries);
2542 item = string_list_insert(entries, new_path);
2543 item->util = re->dst_entry;
2544 }
2545
2546 /*
2547 * Update the stage_data with the information about the path we are
2548 * moving into place. That slot will be empty and available for us
2549 * to write to because of the collision checks in
2550 * handle_path_level_conflicts(). In other words,
2551 * re->dst_entry->stages[stage].oid will be the null_oid, so it's
2552 * open for us to write to.
2553 *
2554 * It may be tempting to actually update the index at this point as
2555 * well, using update_stages_for_stage_data(), but as per the big
2556 * "NOTE" in update_stages(), doing so will modify the current
2557 * in-memory index which will break calls to would_lose_untracked()
2558 * that we need to make. Instead, we need to just make sure that
Elijah Newren8ebe7b02018-06-09 21:16:15 -07002559 * the various handle_rename_*() functions update the index
Elijah Newren9c0743f2018-04-19 10:58:10 -07002560 * explicitly rather than relying on unpack_trees() to have done it.
2561 */
Nguyễn Thái Ngọc Duy50ddb082019-06-27 16:28:49 +07002562 get_tree_entry(opt->repo,
2563 &tree->object.oid,
Elijah Newren9c0743f2018-04-19 10:58:10 -07002564 pair->two->path,
2565 &re->dst_entry->stages[stage].oid,
2566 &re->dst_entry->stages[stage].mode);
2567
Elijah Newren6d169fd2019-04-05 08:00:24 -07002568 /*
2569 * Record the original change status (or 'type' of change). If it
2570 * was originally an add ('A'), this lets us differentiate later
2571 * between a RENAME_DELETE conflict and RENAME_VIA_DIR (they
2572 * otherwise look the same). If it was originally a rename ('R'),
2573 * this lets us remember and report accurately about the transitive
2574 * renaming that occurred via the directory rename detection. Also,
2575 * record the original destination name.
2576 */
2577 re->dir_rename_original_type = pair->status;
2578 re->dir_rename_original_dest = pair->two->path;
2579
Elijah Newren9c0743f2018-04-19 10:58:10 -07002580 /*
2581 * We don't actually look at pair->status again, but it seems
2582 * pedagogically correct to adjust it.
2583 */
2584 pair->status = 'R';
2585
2586 /*
2587 * Finally, record the new location.
2588 */
2589 pair->two->path = new_path;
2590}
2591
Elijah Newrene5257b22018-04-19 10:58:03 -07002592/*
2593 * Get information of all renames which occurred in 'pairs', making use of
2594 * any implicit directory renames inferred from the other side of history.
2595 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')
2596 * to be able to associate the correct cache entries with the rename
2597 * information; tree is always equal to either a_tree or b_tree.
2598 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002599static struct string_list *get_renames(struct merge_options *opt,
Elijah Newrenc336ab82019-04-05 08:00:20 -07002600 const char *branch,
Elijah Newrene5257b22018-04-19 10:58:03 -07002601 struct diff_queue_struct *pairs,
Elijah Newrene95ab702018-04-19 10:58:07 -07002602 struct hashmap *dir_renames,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002603 struct hashmap *dir_rename_exclusions,
Elijah Newrene5257b22018-04-19 10:58:03 -07002604 struct tree *tree,
2605 struct tree *o_tree,
2606 struct tree *a_tree,
2607 struct tree *b_tree,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002608 struct string_list *entries,
2609 int *clean_merge)
Elijah Newrene5257b22018-04-19 10:58:03 -07002610{
2611 int i;
Elijah Newrene95ab702018-04-19 10:58:07 -07002612 struct hashmap collisions;
2613 struct hashmap_iter iter;
2614 struct collision_entry *e;
Elijah Newrene5257b22018-04-19 10:58:03 -07002615 struct string_list *renames;
2616
Elijah Newrene95ab702018-04-19 10:58:07 -07002617 compute_collisions(&collisions, dir_renames, pairs);
René Scharfeca56dad2021-03-13 17:17:22 +01002618 CALLOC_ARRAY(renames, 1);
Elijah Newrene5257b22018-04-19 10:58:03 -07002619
2620 for (i = 0; i < pairs->nr; ++i) {
Elijah Newren9ba91552018-04-19 10:57:59 -07002621 struct string_list_item *item;
2622 struct rename *re;
Elijah Newrene5257b22018-04-19 10:58:03 -07002623 struct diff_filepair *pair = pairs->queue[i];
Elijah Newrenf6f77552018-04-19 10:58:08 -07002624 char *new_path; /* non-NULL only with directory renames */
Elijah Newren9ba91552018-04-19 10:57:59 -07002625
Elijah Newren6e7e0272018-04-19 10:58:15 -07002626 if (pair->status != 'A' && pair->status != 'R') {
Elijah Newren9ba91552018-04-19 10:57:59 -07002627 diff_free_filepair(pair);
2628 continue;
2629 }
Elijah Newren259ccb62019-04-05 08:00:13 -07002630 new_path = check_for_directory_rename(opt, pair->two->path, tree,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002631 dir_renames,
2632 dir_rename_exclusions,
2633 &collisions,
2634 clean_merge);
2635 if (pair->status != 'R' && !new_path) {
2636 diff_free_filepair(pair);
2637 continue;
2638 }
2639
Elijah Newren9ba91552018-04-19 10:57:59 -07002640 re = xmalloc(sizeof(*re));
2641 re->processed = 0;
2642 re->pair = pair;
Elijah Newrenc336ab82019-04-05 08:00:20 -07002643 re->branch = branch;
Elijah Newren6d169fd2019-04-05 08:00:24 -07002644 re->dir_rename_original_type = '\0';
2645 re->dir_rename_original_dest = NULL;
Elijah Newren9ba91552018-04-19 10:57:59 -07002646 item = string_list_lookup(entries, re->pair->one->path);
2647 if (!item)
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07002648 re->src_entry = insert_stage_data(opt->repo,
2649 re->pair->one->path,
Elijah Newren9ba91552018-04-19 10:57:59 -07002650 o_tree, a_tree, b_tree, entries);
2651 else
2652 re->src_entry = item->util;
2653
2654 item = string_list_lookup(entries, re->pair->two->path);
2655 if (!item)
Nguyễn Thái Ngọc Duy34e77712019-06-27 16:28:52 +07002656 re->dst_entry = insert_stage_data(opt->repo,
2657 re->pair->two->path,
Elijah Newren9ba91552018-04-19 10:57:59 -07002658 o_tree, a_tree, b_tree, entries);
2659 else
2660 re->dst_entry = item->util;
2661 item = string_list_insert(renames, pair->one->path);
2662 item->util = re;
Elijah Newren9c0743f2018-04-19 10:58:10 -07002663 if (new_path)
Elijah Newren259ccb62019-04-05 08:00:13 -07002664 apply_directory_rename_modifications(opt, pair, new_path,
Elijah Newren9c0743f2018-04-19 10:58:10 -07002665 re, tree, o_tree,
2666 a_tree, b_tree,
Jeff Kingb53c5022019-02-14 00:50:02 -05002667 entries);
Elijah Newren9ba91552018-04-19 10:57:59 -07002668 }
Elijah Newrene95ab702018-04-19 10:58:07 -07002669
Eric Wong87571c32019-10-06 23:30:38 +00002670 hashmap_for_each_entry(&collisions, &iter, e,
Eric Wong87571c32019-10-06 23:30:38 +00002671 ent /* member name */) {
Elijah Newrene95ab702018-04-19 10:58:07 -07002672 free(e->target_file);
2673 string_list_clear(&e->source_files, 0);
2674 }
Elijah Newren6da1a252020-11-02 18:55:05 +00002675 hashmap_clear_and_free(&collisions, struct collision_entry, ent);
Elijah Newren9ba91552018-04-19 10:57:59 -07002676 return renames;
2677}
2678
Elijah Newren259ccb62019-04-05 08:00:13 -07002679static int process_renames(struct merge_options *opt,
Miklos Vajna8a2fce12008-08-25 16:25:57 +02002680 struct string_list *a_renames,
2681 struct string_list *b_renames)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002682{
2683 int clean_merge = 1, i, j;
Thiago Farina183113a2010-07-04 16:46:19 -03002684 struct string_list a_by_dst = STRING_LIST_INIT_NODUP;
2685 struct string_list b_by_dst = STRING_LIST_INIT_NODUP;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002686 const struct rename *sre;
2687
Elijah Newren816147e2021-03-20 00:03:53 +00002688 /*
2689 * FIXME: As string-list.h notes, it's O(n^2) to build a sorted
2690 * string_list one-by-one, but O(n log n) to build it unsorted and
2691 * then sort it. Note that as we build the list, we do not need to
2692 * check if the existing destination path is already in the list,
2693 * because the structure of diffcore_rename guarantees we won't
2694 * have duplicates.
2695 */
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002696 for (i = 0; i < a_renames->nr; i++) {
2697 sre = a_renames->items[i].util;
Julian Phillips78a395d2010-06-26 00:41:35 +01002698 string_list_insert(&a_by_dst, sre->pair->two->path)->util
Elijah Newren0a6b8712011-08-11 23:20:04 -06002699 = (void *)sre;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002700 }
2701 for (i = 0; i < b_renames->nr; i++) {
2702 sre = b_renames->items[i].util;
Julian Phillips78a395d2010-06-26 00:41:35 +01002703 string_list_insert(&b_by_dst, sre->pair->two->path)->util
Elijah Newren0a6b8712011-08-11 23:20:04 -06002704 = (void *)sre;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002705 }
2706
2707 for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {
Benjamin Kramer8e24cba2009-03-15 22:01:20 +01002708 struct string_list *renames1, *renames2Dst;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002709 struct rename *ren1 = NULL, *ren2 = NULL;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002710 const char *ren1_src, *ren1_dst;
Elijah Newren461f5042011-08-11 23:20:15 -06002711 struct string_list_item *lookup;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002712
2713 if (i >= a_renames->nr) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002714 ren2 = b_renames->items[j++].util;
2715 } else if (j >= b_renames->nr) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002716 ren1 = a_renames->items[i++].util;
2717 } else {
Benjamin Kramer8e24cba2009-03-15 22:01:20 +01002718 int compare = strcmp(a_renames->items[i].string,
2719 b_renames->items[j].string);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002720 if (compare <= 0)
2721 ren1 = a_renames->items[i++].util;
2722 if (compare >= 0)
2723 ren2 = b_renames->items[j++].util;
2724 }
2725
2726 /* TODO: refactor, so that 1/2 are not needed */
2727 if (ren1) {
2728 renames1 = a_renames;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002729 renames2Dst = &b_by_dst;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002730 } else {
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002731 renames1 = b_renames;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002732 renames2Dst = &a_by_dst;
René Scharfe35d803b2017-01-28 22:40:58 +01002733 SWAP(ren2, ren1);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002734 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002735
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002736 if (ren1->processed)
2737 continue;
2738 ren1->processed = 1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002739 ren1->dst_entry->processed = 1;
Elijah Newren7769a752011-08-11 23:20:05 -06002740 /* BUG: We should only mark src_entry as processed if we
2741 * are not dealing with a rename + add-source case.
2742 */
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002743 ren1->src_entry->processed = 1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002744
2745 ren1_src = ren1->pair->one->path;
2746 ren1_dst = ren1->pair->two->path;
2747
2748 if (ren2) {
Elijah Newren461f5042011-08-11 23:20:15 -06002749 /* One file renamed on both sides */
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002750 const char *ren2_src = ren2->pair->one->path;
2751 const char *ren2_dst = ren2->pair->two->path;
Elijah Newren4f66dad2011-08-11 23:20:08 -06002752 enum rename_type rename_type;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002753 if (strcmp(ren1_src, ren2_src) != 0)
Johannes Schindelin033abf92018-05-02 11:38:39 +02002754 BUG("ren1_src != ren2_src");
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002755 ren2->dst_entry->processed = 1;
2756 ren2->processed = 1;
2757 if (strcmp(ren1_dst, ren2_dst) != 0) {
Elijah Newren4f66dad2011-08-11 23:20:08 -06002758 rename_type = RENAME_ONE_FILE_TO_TWO;
Elijah Newren461f5042011-08-11 23:20:15 -06002759 clean_merge = 0;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002760 } else {
Elijah Newren4f66dad2011-08-11 23:20:08 -06002761 rename_type = RENAME_ONE_FILE_TO_ONE;
Elijah Newren7769a752011-08-11 23:20:05 -06002762 /* BUG: We should only remove ren1_src in
2763 * the base stage (think of rename +
2764 * add-source cases).
2765 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002766 remove_file(opt, 1, ren1_src, 1);
Elijah Newrenb8ddf162011-08-11 23:20:02 -06002767 update_entry(ren1->dst_entry,
2768 ren1->pair->one,
2769 ren1->pair->two,
2770 ren2->pair->two);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002771 }
Elijah Newrenc336ab82019-04-05 08:00:20 -07002772 setup_rename_conflict_info(rename_type, opt, ren1, ren2);
Elijah Newren461f5042011-08-11 23:20:15 -06002773 } else if ((lookup = string_list_lookup(renames2Dst, ren1_dst))) {
2774 /* Two different files renamed to the same thing */
2775 char *ren2_dst;
2776 ren2 = lookup->util;
2777 ren2_dst = ren2->pair->two->path;
2778 if (strcmp(ren1_dst, ren2_dst) != 0)
Johannes Schindelin033abf92018-05-02 11:38:39 +02002779 BUG("ren1_dst != ren2_dst");
Elijah Newren461f5042011-08-11 23:20:15 -06002780
2781 clean_merge = 0;
2782 ren2->processed = 1;
2783 /*
2784 * BUG: We should only mark src_entry as processed
2785 * if we are not dealing with a rename + add-source
2786 * case.
2787 */
2788 ren2->src_entry->processed = 1;
2789
2790 setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,
Elijah Newrenc336ab82019-04-05 08:00:20 -07002791 opt, ren1, ren2);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002792 } else {
2793 /* Renamed in 1, maybe changed in 2 */
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002794 /* we only use sha1 and mode of these */
2795 struct diff_filespec src_other, dst_other;
Elijah Newren41d70bd2010-09-20 02:28:47 -06002796 int try_merge;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002797
Elijah Newren41d70bd2010-09-20 02:28:47 -06002798 /*
2799 * unpack_trees loads entries from common-commit
2800 * into stage 1, from head-commit into stage 2, and
2801 * from merge-commit into stage 3. We keep track
2802 * of which side corresponds to the rename.
2803 */
2804 int renamed_stage = a_renames == renames1 ? 2 : 3;
2805 int other_stage = a_renames == renames1 ? 3 : 2;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002806
Elijah Newren7769a752011-08-11 23:20:05 -06002807 /* BUG: We should only remove ren1_src in the base
2808 * stage and in other_stage (think of rename +
2809 * add-source case).
2810 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002811 remove_file(opt, 1, ren1_src,
2812 renamed_stage == 2 || !was_tracked(opt, ren1_src));
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002813
brian m. carlsonfd429e92016-06-24 23:09:25 +00002814 oidcpy(&src_other.oid,
2815 &ren1->src_entry->stages[other_stage].oid);
Elijah Newren41d70bd2010-09-20 02:28:47 -06002816 src_other.mode = ren1->src_entry->stages[other_stage].mode;
brian m. carlsonfd429e92016-06-24 23:09:25 +00002817 oidcpy(&dst_other.oid,
2818 &ren1->dst_entry->stages[other_stage].oid);
Elijah Newren41d70bd2010-09-20 02:28:47 -06002819 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002820 try_merge = 0;
2821
brian m. carlson14228442021-04-26 01:02:56 +00002822 if (oideq(&src_other.oid, null_oid()) &&
Elijah Newren6d169fd2019-04-05 08:00:24 -07002823 ren1->dir_rename_original_type == 'A') {
Elijah Newren5455c332018-06-09 21:16:14 -07002824 setup_rename_conflict_info(RENAME_VIA_DIR,
Elijah Newrenc336ab82019-04-05 08:00:20 -07002825 opt, ren1, NULL);
brian m. carlson14228442021-04-26 01:02:56 +00002826 } else if (oideq(&src_other.oid, null_oid())) {
Elijah Newren4f66dad2011-08-11 23:20:08 -06002827 setup_rename_conflict_info(RENAME_DELETE,
Elijah Newrenc336ab82019-04-05 08:00:20 -07002828 opt, ren1, NULL);
Schalk, Kend5af5102010-09-01 13:15:32 -07002829 } else if ((dst_other.mode == ren1->pair->two->mode) &&
Elijah Newren763a59e2020-01-01 05:20:57 +00002830 oideq(&dst_other.oid, &ren1->pair->two->oid)) {
Elijah Newren35a74ab2011-08-11 23:20:27 -06002831 /*
2832 * Added file on the other side identical to
2833 * the file being renamed: clean merge.
2834 * Also, there is no need to overwrite the
2835 * file already in the working copy, so call
2836 * update_file_flags() instead of
2837 * update_file().
2838 */
Elijah Newren259ccb62019-04-05 08:00:13 -07002839 if (update_file_flags(opt,
Elijah Newren8daec1d2019-04-05 08:00:22 -07002840 ren1->pair->two,
Johannes Schindelin75456f92016-07-26 18:06:21 +02002841 ren1_dst,
2842 1, /* update_cache */
2843 0 /* update_wd */))
2844 clean_merge = -1;
brian m. carlson14228442021-04-26 01:02:56 +00002845 } else if (!oideq(&dst_other.oid, null_oid())) {
Elijah Newren7f867162018-11-07 20:40:26 -08002846 /*
2847 * Probably not a clean merge, but it's
2848 * premature to set clean_merge to 0 here,
2849 * because if the rename merges cleanly and
2850 * the merge exactly matches the newly added
2851 * file, then the merge will be clean.
2852 */
2853 setup_rename_conflict_info(RENAME_ADD,
Elijah Newrenc336ab82019-04-05 08:00:20 -07002854 opt, ren1, NULL);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002855 } else
2856 try_merge = 1;
2857
Johannes Schindelin75456f92016-07-26 18:06:21 +02002858 if (clean_merge < 0)
2859 goto cleanup_and_return;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002860 if (try_merge) {
Elijah Newrene3de8882019-04-05 08:00:14 -07002861 struct diff_filespec *o, *a, *b;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002862 src_other.path = (char *)ren1_src;
2863
Elijah Newrene3de8882019-04-05 08:00:14 -07002864 o = ren1->pair->one;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002865 if (a_renames == renames1) {
2866 a = ren1->pair->two;
2867 b = &src_other;
2868 } else {
2869 b = ren1->pair->two;
2870 a = &src_other;
2871 }
Elijah Newrene3de8882019-04-05 08:00:14 -07002872 update_entry(ren1->dst_entry, o, a, b);
Elijah Newren4f66dad2011-08-11 23:20:08 -06002873 setup_rename_conflict_info(RENAME_NORMAL,
Elijah Newrenc336ab82019-04-05 08:00:20 -07002874 opt, ren1, NULL);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002875 }
2876 }
2877 }
Johannes Schindelin75456f92016-07-26 18:06:21 +02002878cleanup_and_return:
Miklos Vajna9047ebb2008-08-12 18:45:14 +02002879 string_list_clear(&a_by_dst, 0);
2880 string_list_clear(&b_by_dst, 0);
2881
2882 return clean_merge;
2883}
2884
Elijah Newrenf1725892018-04-19 10:58:00 -07002885struct rename_info {
2886 struct string_list *head_renames;
2887 struct string_list *merge_renames;
2888};
2889
Elijah Newren7fe40b82018-04-19 10:58:05 -07002890static void initial_cleanup_rename(struct diff_queue_struct *pairs,
2891 struct hashmap *dir_renames)
Elijah Newrenffc16c42018-04-19 10:58:04 -07002892{
Elijah Newren7fe40b82018-04-19 10:58:05 -07002893 struct hashmap_iter iter;
2894 struct dir_rename_entry *e;
2895
Eric Wong87571c32019-10-06 23:30:38 +00002896 hashmap_for_each_entry(dir_renames, &iter, e,
Eric Wong87571c32019-10-06 23:30:38 +00002897 ent /* member name */) {
Elijah Newren7fe40b82018-04-19 10:58:05 -07002898 free(e->dir);
2899 strbuf_release(&e->new_dir);
2900 /* possible_new_dirs already cleared in get_directory_renames */
2901 }
Elijah Newren6da1a252020-11-02 18:55:05 +00002902 hashmap_clear_and_free(dir_renames, struct dir_rename_entry, ent);
Elijah Newren7fe40b82018-04-19 10:58:05 -07002903 free(dir_renames);
2904
Elijah Newrenffc16c42018-04-19 10:58:04 -07002905 free(pairs->queue);
2906 free(pairs);
2907}
2908
Elijah Newren259ccb62019-04-05 08:00:13 -07002909static int detect_and_process_renames(struct merge_options *opt,
Elijah Newren8ebe7b02018-06-09 21:16:15 -07002910 struct tree *common,
2911 struct tree *head,
2912 struct tree *merge,
2913 struct string_list *entries,
2914 struct rename_info *ri)
Elijah Newrenf1725892018-04-19 10:58:00 -07002915{
Elijah Newrene5257b22018-04-19 10:58:03 -07002916 struct diff_queue_struct *head_pairs, *merge_pairs;
Elijah Newren7fe40b82018-04-19 10:58:05 -07002917 struct hashmap *dir_re_head, *dir_re_merge;
Elijah Newrenf6f77552018-04-19 10:58:08 -07002918 int clean = 1;
Elijah Newrene5257b22018-04-19 10:58:03 -07002919
Elijah Newren3992ff02018-04-19 10:58:02 -07002920 ri->head_renames = NULL;
2921 ri->merge_renames = NULL;
2922
Elijah Newren259ccb62019-04-05 08:00:13 -07002923 if (!merge_detect_rename(opt))
Elijah Newren3992ff02018-04-19 10:58:02 -07002924 return 1;
2925
Elijah Newren259ccb62019-04-05 08:00:13 -07002926 head_pairs = get_diffpairs(opt, common, head);
2927 merge_pairs = get_diffpairs(opt, common, merge);
Elijah Newrene5257b22018-04-19 10:58:03 -07002928
Derrick Stolee8e012512019-08-17 11:41:25 -07002929 if ((opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_TRUE) ||
2930 (opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_CONFLICT &&
Elijah Newren5bf7e572019-08-17 11:41:41 -07002931 !opt->priv->call_depth)) {
Jeff Kingb53c5022019-02-14 00:50:02 -05002932 dir_re_head = get_directory_renames(head_pairs);
2933 dir_re_merge = get_directory_renames(merge_pairs);
Elijah Newren7fe40b82018-04-19 10:58:05 -07002934
Elijah Newren259ccb62019-04-05 08:00:13 -07002935 handle_directory_level_conflicts(opt,
Elijah Newren5fdddd92018-08-29 00:06:12 -07002936 dir_re_head, head,
2937 dir_re_merge, merge);
2938 } else {
2939 dir_re_head = xmalloc(sizeof(*dir_re_head));
2940 dir_re_merge = xmalloc(sizeof(*dir_re_merge));
2941 dir_rename_init(dir_re_head);
2942 dir_rename_init(dir_re_merge);
2943 }
Elijah Newren96e7ffb2018-04-19 10:58:06 -07002944
Elijah Newrenc336ab82019-04-05 08:00:20 -07002945 ri->head_renames = get_renames(opt, opt->branch1, head_pairs,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002946 dir_re_merge, dir_re_head, head,
2947 common, head, merge, entries,
2948 &clean);
2949 if (clean < 0)
2950 goto cleanup;
Elijah Newrenc336ab82019-04-05 08:00:20 -07002951 ri->merge_renames = get_renames(opt, opt->branch2, merge_pairs,
Elijah Newrenf6f77552018-04-19 10:58:08 -07002952 dir_re_head, dir_re_merge, merge,
2953 common, head, merge, entries,
2954 &clean);
2955 if (clean < 0)
2956 goto cleanup;
Elijah Newren259ccb62019-04-05 08:00:13 -07002957 clean &= process_renames(opt, ri->head_renames, ri->merge_renames);
Elijah Newrene5257b22018-04-19 10:58:03 -07002958
Elijah Newrenf6f77552018-04-19 10:58:08 -07002959cleanup:
Elijah Newrene5257b22018-04-19 10:58:03 -07002960 /*
2961 * Some cleanup is deferred until cleanup_renames() because the
2962 * data structures are still needed and referenced in
2963 * process_entry(). But there are a few things we can free now.
2964 */
Elijah Newren7fe40b82018-04-19 10:58:05 -07002965 initial_cleanup_rename(head_pairs, dir_re_head);
2966 initial_cleanup_rename(merge_pairs, dir_re_merge);
Elijah Newrene5257b22018-04-19 10:58:03 -07002967
2968 return clean;
Elijah Newrenf1725892018-04-19 10:58:00 -07002969}
2970
Elijah Newrenffc16c42018-04-19 10:58:04 -07002971static void final_cleanup_rename(struct string_list *rename)
Elijah Newren9cfee252018-04-19 10:58:01 -07002972{
2973 const struct rename *re;
2974 int i;
2975
Elijah Newren3992ff02018-04-19 10:58:02 -07002976 if (rename == NULL)
2977 return;
2978
Elijah Newren9cfee252018-04-19 10:58:01 -07002979 for (i = 0; i < rename->nr; i++) {
2980 re = rename->items[i].util;
2981 diff_free_filepair(re->pair);
2982 }
2983 string_list_clear(rename, 1);
2984 free(rename);
2985}
2986
Elijah Newrenffc16c42018-04-19 10:58:04 -07002987static void final_cleanup_renames(struct rename_info *re_info)
Elijah Newrenf1725892018-04-19 10:58:00 -07002988{
Elijah Newrenffc16c42018-04-19 10:58:04 -07002989 final_cleanup_rename(re_info->head_renames);
2990 final_cleanup_rename(re_info->merge_renames);
Elijah Newrenf1725892018-04-19 10:58:00 -07002991}
2992
Elijah Newren259ccb62019-04-05 08:00:13 -07002993static int read_oid_strbuf(struct merge_options *opt,
Elijah Newrend90e7592018-06-09 21:16:12 -07002994 const struct object_id *oid,
2995 struct strbuf *dst)
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02002996{
2997 void *buf;
2998 enum object_type type;
2999 unsigned long size;
brian m. carlsonb4f5aca2018-03-12 02:27:53 +00003000 buf = read_object_file(oid, &type, &size);
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003001 if (!buf)
Elijah Newren259ccb62019-04-05 08:00:13 -07003002 return err(opt, _("cannot read object %s"), oid_to_hex(oid));
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003003 if (type != OBJ_BLOB) {
3004 free(buf);
Elijah Newren259ccb62019-04-05 08:00:13 -07003005 return err(opt, _("object %s is not a blob"), oid_to_hex(oid));
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003006 }
3007 strbuf_attach(dst, buf, size, size + 1);
3008 return 0;
3009}
3010
Johannes Schindelinbc9204d2016-08-01 13:44:37 +02003011static int blob_unchanged(struct merge_options *opt,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003012 const struct diff_filespec *o,
3013 const struct diff_filespec *a,
Jonathan Nieder3e7589b2010-08-05 06:13:49 -05003014 int renormalize, const char *path)
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003015{
Elijah Newren93a02c52019-04-05 08:00:15 -07003016 struct strbuf obuf = STRBUF_INIT;
3017 struct strbuf abuf = STRBUF_INIT;
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003018 int ret = 0; /* assume changed for safety */
Derrick Stolee847a9e52021-04-01 01:49:39 +00003019 struct index_state *idx = opt->repo->index;
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003020
Elijah Newren8daec1d2019-04-05 08:00:22 -07003021 if (a->mode != o->mode)
Jeff King72fac662015-10-26 17:39:39 -04003022 return 0;
Elijah Newren763a59e2020-01-01 05:20:57 +00003023 if (oideq(&o->oid, &a->oid))
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003024 return 1;
Jonathan Nieder3e7589b2010-08-05 06:13:49 -05003025 if (!renormalize)
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003026 return 0;
3027
Elijah Newren8daec1d2019-04-05 08:00:22 -07003028 if (read_oid_strbuf(opt, &o->oid, &obuf) ||
3029 read_oid_strbuf(opt, &a->oid, &abuf))
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003030 goto error_return;
3031 /*
3032 * Note: binary | is used so that both renormalizations are
3033 * performed. Comparison can be skipped if both files are
3034 * unchanged since their sha1s have already been compared.
3035 */
Elijah Newren93a02c52019-04-05 08:00:15 -07003036 if (renormalize_buffer(idx, path, obuf.buf, obuf.len, &obuf) |
3037 renormalize_buffer(idx, path, abuf.buf, abuf.len, &abuf))
3038 ret = (obuf.len == abuf.len && !memcmp(obuf.buf, abuf.buf, obuf.len));
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003039
3040error_return:
Elijah Newren93a02c52019-04-05 08:00:15 -07003041 strbuf_release(&obuf);
3042 strbuf_release(&abuf);
Eyvind Bernhardsen331a1832010-07-02 21:20:48 +02003043 return ret;
3044}
3045
Elijah Newren259ccb62019-04-05 08:00:13 -07003046static int handle_modify_delete(struct merge_options *opt,
Elijah Newrend90e7592018-06-09 21:16:12 -07003047 const char *path,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003048 const struct diff_filespec *o,
3049 const struct diff_filespec *a,
3050 const struct diff_filespec *b)
Elijah Newren5e3ce662010-09-20 02:28:51 -06003051{
Matt McCutchenb26d87f2017-01-28 15:37:01 -05003052 const char *modify_branch, *delete_branch;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003053 const struct diff_filespec *changed;
Matt McCutchenb26d87f2017-01-28 15:37:01 -05003054
Elijah Newren8daec1d2019-04-05 08:00:22 -07003055 if (is_valid(a)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003056 modify_branch = opt->branch1;
3057 delete_branch = opt->branch2;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003058 changed = a;
Matt McCutchenb26d87f2017-01-28 15:37:01 -05003059 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07003060 modify_branch = opt->branch2;
3061 delete_branch = opt->branch1;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003062 changed = b;
Matt McCutchenb26d87f2017-01-28 15:37:01 -05003063 }
3064
Elijah Newren259ccb62019-04-05 08:00:13 -07003065 return handle_change_delete(opt,
Matt McCutchenb26d87f2017-01-28 15:37:01 -05003066 path, NULL,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003067 o, changed,
Matt McCutchenb26d87f2017-01-28 15:37:01 -05003068 modify_branch, delete_branch,
Johannes Schindelin75456f92016-07-26 18:06:21 +02003069 _("modify"), _("modified"));
Elijah Newren5e3ce662010-09-20 02:28:51 -06003070}
3071
Elijah Newrene62d1122019-04-05 08:00:25 -07003072static int handle_content_merge(struct merge_file_info *mfi,
3073 struct merge_options *opt,
Elijah Newrend9573552018-09-19 09:14:34 -07003074 const char *path,
3075 int is_dirty,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003076 const struct diff_filespec *o,
3077 const struct diff_filespec *a,
3078 const struct diff_filespec *b,
Elijah Newren043622b2019-04-05 08:00:16 -07003079 struct rename_conflict_info *ci)
Elijah Newren0c4918d2010-09-20 02:28:52 -06003080{
Jiang Xin55653a62012-07-25 22:53:13 +08003081 const char *reason = _("content");
Elijah Newren4ab9a152010-09-20 02:29:07 -06003082 unsigned df_conflict_remains = 0;
Elijah Newren0c4918d2010-09-20 02:28:52 -06003083
Elijah Newren8daec1d2019-04-05 08:00:22 -07003084 if (!is_valid(o))
Jiang Xin55653a62012-07-25 22:53:13 +08003085 reason = _("add/add");
Elijah Newren0c4918d2010-09-20 02:28:52 -06003086
Elijah Newren8daec1d2019-04-05 08:00:22 -07003087 assert(o->path && a->path && b->path);
Elijah Newren5bf7e572019-08-17 11:41:41 -07003088 if (ci && dir_in_way(opt->repo->index, path, !opt->priv->call_depth,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003089 S_ISGITLINK(ci->ren1->pair->two->mode)))
3090 df_conflict_remains = 1;
Elijah Newren3c217c02011-08-11 23:20:09 -06003091
Elijah Newren8daec1d2019-04-05 08:00:22 -07003092 if (merge_mode_and_contents(opt, o, a, b, path,
Elijah Newren259ccb62019-04-05 08:00:13 -07003093 opt->branch1, opt->branch2,
Elijah Newren5bf7e572019-08-17 11:41:41 -07003094 opt->priv->call_depth * 2, mfi))
Johannes Schindelin3c8a51e2016-07-26 18:06:10 +02003095 return -1;
Elijah Newren4ab9a152010-09-20 02:29:07 -06003096
Elijah Newren1de70db2018-04-19 10:58:23 -07003097 /*
3098 * We can skip updating the working tree file iff:
3099 * a) The merge is clean
3100 * b) The merge matches what was in HEAD (content, mode, pathname)
3101 * c) The target path is usable (i.e. not involved in D/F conflict)
3102 */
Elijah Newrene62d1122019-04-05 08:00:25 -07003103 if (mfi->clean && was_tracked_and_matches(opt, path, &mfi->blob) &&
Elijah Newren1de70db2018-04-19 10:58:23 -07003104 !df_conflict_remains) {
Elijah Newren2b75fb62018-07-27 12:59:44 +00003105 int pos;
3106 struct cache_entry *ce;
3107
Elijah Newren259ccb62019-04-05 08:00:13 -07003108 output(opt, 3, _("Skipped %s (merged same as existing)"), path);
Elijah Newrene62d1122019-04-05 08:00:25 -07003109 if (add_cacheinfo(opt, &mfi->blob, path,
Elijah Newren5bf7e572019-08-17 11:41:41 -07003110 0, (!opt->priv->call_depth && !is_dirty), 0))
Elijah Newren1de70db2018-04-19 10:58:23 -07003111 return -1;
Elijah Newren2b75fb62018-07-27 12:59:44 +00003112 /*
3113 * However, add_cacheinfo() will delete the old cache entry
3114 * and add a new one. We need to copy over any skip_worktree
3115 * flag to avoid making the file appear as if it were
3116 * deleted by the user.
3117 */
Elijah Newren5bf7e572019-08-17 11:41:41 -07003118 pos = index_name_pos(&opt->priv->orig_index, path, strlen(path));
3119 ce = opt->priv->orig_index.cache[pos];
Elijah Newren2b75fb62018-07-27 12:59:44 +00003120 if (ce_skip_worktree(ce)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003121 pos = index_name_pos(opt->repo->index, path, strlen(path));
3122 ce = opt->repo->index->cache[pos];
Elijah Newren2b75fb62018-07-27 12:59:44 +00003123 ce->ce_flags |= CE_SKIP_WORKTREE;
3124 }
Elijah Newrene62d1122019-04-05 08:00:25 -07003125 return mfi->clean;
Elijah Newren05cf21e2018-04-19 10:58:22 -07003126 }
Elijah Newren0c4918d2010-09-20 02:28:52 -06003127
Elijah Newrene62d1122019-04-05 08:00:25 -07003128 if (!mfi->clean) {
3129 if (S_ISGITLINK(mfi->blob.mode))
Jiang Xin55653a62012-07-25 22:53:13 +08003130 reason = _("submodule");
Elijah Newren259ccb62019-04-05 08:00:13 -07003131 output(opt, 1, _("CONFLICT (%s): Merge conflict in %s"),
Elijah Newren0c4918d2010-09-20 02:28:52 -06003132 reason, path);
Elijah Newren043622b2019-04-05 08:00:16 -07003133 if (ci && !df_conflict_remains)
Elijah Newren8daec1d2019-04-05 08:00:22 -07003134 if (update_stages(opt, path, o, a, b))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003135 return -1;
Elijah Newren0c4918d2010-09-20 02:28:52 -06003136 }
3137
Elijah Newrenbd423802018-04-19 10:58:17 -07003138 if (df_conflict_remains || is_dirty) {
Elijah Newren3d6b8e82011-08-11 23:19:53 -06003139 char *new_path;
Elijah Newren5bf7e572019-08-17 11:41:41 -07003140 if (opt->priv->call_depth) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003141 remove_file_from_index(opt->repo->index, path);
Elijah Newren51931bf2011-08-11 23:20:06 -06003142 } else {
Elijah Newrene62d1122019-04-05 08:00:25 -07003143 if (!mfi->clean) {
Elijah Newren8daec1d2019-04-05 08:00:22 -07003144 if (update_stages(opt, path, o, a, b))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003145 return -1;
3146 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07003147 int file_from_stage2 = was_tracked(opt, path);
Elijah Newren51931bf2011-08-11 23:20:06 -06003148
Elijah Newren259ccb62019-04-05 08:00:13 -07003149 if (update_stages(opt, path, NULL,
Elijah Newrene62d1122019-04-05 08:00:25 -07003150 file_from_stage2 ? &mfi->blob : NULL,
3151 file_from_stage2 ? NULL : &mfi->blob))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003152 return -1;
Elijah Newren51931bf2011-08-11 23:20:06 -06003153 }
3154
3155 }
Elijah Newrenc336ab82019-04-05 08:00:20 -07003156 new_path = unique_path(opt, path, ci->ren1->branch);
Elijah Newrenbd423802018-04-19 10:58:17 -07003157 if (is_dirty) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003158 output(opt, 1, _("Refusing to lose dirty file at %s"),
Elijah Newrenbd423802018-04-19 10:58:17 -07003159 path);
3160 }
Elijah Newren259ccb62019-04-05 08:00:13 -07003161 output(opt, 1, _("Adding as %s instead"), new_path);
Elijah Newrene62d1122019-04-05 08:00:25 -07003162 if (update_file(opt, 0, &mfi->blob, new_path)) {
Johannes Schindelin75456f92016-07-26 18:06:21 +02003163 free(new_path);
3164 return -1;
3165 }
Elijah Newren3d6b8e82011-08-11 23:19:53 -06003166 free(new_path);
Elijah Newrene62d1122019-04-05 08:00:25 -07003167 mfi->clean = 0;
3168 } else if (update_file(opt, mfi->clean, &mfi->blob, path))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003169 return -1;
Elijah Newrene62d1122019-04-05 08:00:25 -07003170 return !is_dirty && mfi->clean;
Elijah Newren0c4918d2010-09-20 02:28:52 -06003171}
3172
Elijah Newren259ccb62019-04-05 08:00:13 -07003173static int handle_rename_normal(struct merge_options *opt,
Elijah Newren8ebe7b02018-06-09 21:16:15 -07003174 const char *path,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003175 const struct diff_filespec *o,
3176 const struct diff_filespec *a,
3177 const struct diff_filespec *b,
Elijah Newren8ebe7b02018-06-09 21:16:15 -07003178 struct rename_conflict_info *ci)
Elijah Newren64b1abe2018-04-19 10:58:12 -07003179{
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003180 struct rename *ren = ci->ren1;
Elijah Newrene62d1122019-04-05 08:00:25 -07003181 struct merge_file_info mfi;
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003182 int clean;
3183 int side = (ren->branch == opt->branch1 ? 2 : 3);
3184
Elijah Newren64b1abe2018-04-19 10:58:12 -07003185 /* Merge the content and write it out */
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003186 clean = handle_content_merge(&mfi, opt, path, was_dirty(opt, path),
3187 o, a, b, ci);
3188
Derrick Stolee8e012512019-08-17 11:41:25 -07003189 if (clean &&
3190 opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_CONFLICT &&
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003191 ren->dir_rename_original_dest) {
3192 if (update_stages(opt, path,
3193 NULL,
3194 side == 2 ? &mfi.blob : NULL,
3195 side == 2 ? NULL : &mfi.blob))
3196 return -1;
3197 clean = 0; /* not clean, but conflicted */
3198 }
3199 return clean;
3200}
3201
3202static void dir_rename_warning(const char *msg,
3203 int is_add,
3204 int clean,
3205 struct merge_options *opt,
3206 struct rename *ren)
3207{
3208 const char *other_branch;
3209 other_branch = (ren->branch == opt->branch1 ?
3210 opt->branch2 : opt->branch1);
3211 if (is_add) {
3212 output(opt, clean ? 2 : 1, msg,
3213 ren->pair->one->path, ren->branch,
3214 other_branch, ren->pair->two->path);
3215 return;
3216 }
3217 output(opt, clean ? 2 : 1, msg,
3218 ren->pair->one->path, ren->dir_rename_original_dest, ren->branch,
3219 other_branch, ren->pair->two->path);
3220}
3221static int warn_about_dir_renamed_entries(struct merge_options *opt,
3222 struct rename *ren)
3223{
3224 const char *msg;
3225 int clean = 1, is_add;
3226
3227 if (!ren)
3228 return clean;
3229
3230 /* Return early if ren was not affected/created by a directory rename */
3231 if (!ren->dir_rename_original_dest)
3232 return clean;
3233
3234 /* Sanity checks */
Derrick Stolee8e012512019-08-17 11:41:25 -07003235 assert(opt->detect_directory_renames > MERGE_DIRECTORY_RENAMES_NONE);
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003236 assert(ren->dir_rename_original_type == 'A' ||
3237 ren->dir_rename_original_type == 'R');
3238
3239 /* Check whether to treat directory renames as a conflict */
Derrick Stolee8e012512019-08-17 11:41:25 -07003240 clean = (opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_TRUE);
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003241
3242 is_add = (ren->dir_rename_original_type == 'A');
3243 if (ren->dir_rename_original_type == 'A' && clean) {
3244 msg = _("Path updated: %s added in %s inside a "
3245 "directory that was renamed in %s; moving it to %s.");
3246 } else if (ren->dir_rename_original_type == 'A' && !clean) {
3247 msg = _("CONFLICT (file location): %s added in %s "
3248 "inside a directory that was renamed in %s, "
3249 "suggesting it should perhaps be moved to %s.");
3250 } else if (ren->dir_rename_original_type == 'R' && clean) {
3251 msg = _("Path updated: %s renamed to %s in %s, inside a "
3252 "directory that was renamed in %s; moving it to %s.");
3253 } else if (ren->dir_rename_original_type == 'R' && !clean) {
3254 msg = _("CONFLICT (file location): %s renamed to %s in %s, "
3255 "inside a directory that was renamed in %s, "
3256 "suggesting it should perhaps be moved to %s.");
3257 } else {
3258 BUG("Impossible dir_rename_original_type/clean combination");
3259 }
3260 dir_rename_warning(msg, is_add, clean, opt, ren);
3261
3262 return clean;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003263}
3264
3265/* Per entry merge function */
Elijah Newren259ccb62019-04-05 08:00:13 -07003266static int process_entry(struct merge_options *opt,
Miklos Vajna8a2fce12008-08-25 16:25:57 +02003267 const char *path, struct stage_data *entry)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003268{
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003269 int clean_merge = 1;
Elijah Newren259ccb62019-04-05 08:00:13 -07003270 int normalize = opt->renormalize;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003271
3272 struct diff_filespec *o = &entry->stages[1];
3273 struct diff_filespec *a = &entry->stages[2];
3274 struct diff_filespec *b = &entry->stages[3];
3275 int o_valid = is_valid(o);
3276 int a_valid = is_valid(a);
3277 int b_valid = is_valid(b);
3278 o->path = a->path = b->path = (char*)path;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003279
Elijah Newren37348932010-07-09 07:10:53 -06003280 entry->processed = 1;
Elijah Newren4f66dad2011-08-11 23:20:08 -06003281 if (entry->rename_conflict_info) {
Elijah Newren043622b2019-04-05 08:00:16 -07003282 struct rename_conflict_info *ci = entry->rename_conflict_info;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003283 struct diff_filespec *temp;
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003284 int path_clean;
3285
3286 path_clean = warn_about_dir_renamed_entries(opt, ci->ren1);
3287 path_clean &= warn_about_dir_renamed_entries(opt, ci->ren2);
Elijah Newren8daec1d2019-04-05 08:00:22 -07003288
3289 /*
3290 * For cases with a single rename, {o,a,b}->path have all been
3291 * set to the rename target path; we need to set two of these
3292 * back to the rename source.
3293 * For rename/rename conflicts, we'll manually fix paths below.
3294 */
3295 temp = (opt->branch1 == ci->ren1->branch) ? b : a;
3296 o->path = temp->path = ci->ren1->pair->one->path;
3297 if (ci->ren2) {
3298 assert(opt->branch1 == ci->ren1->branch);
3299 }
3300
Elijah Newren043622b2019-04-05 08:00:16 -07003301 switch (ci->rename_type) {
Elijah Newren882fd112010-09-20 02:29:03 -06003302 case RENAME_NORMAL:
Elijah Newren4f66dad2011-08-11 23:20:08 -06003303 case RENAME_ONE_FILE_TO_ONE:
Elijah Newren8daec1d2019-04-05 08:00:22 -07003304 clean_merge = handle_rename_normal(opt, path, o, a, b,
Elijah Newren043622b2019-04-05 08:00:16 -07003305 ci);
Elijah Newren882fd112010-09-20 02:29:03 -06003306 break;
Elijah Newren5455c332018-06-09 21:16:14 -07003307 case RENAME_VIA_DIR:
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003308 clean_merge = handle_rename_via_dir(opt, ci);
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003309 break;
Elijah Newren7f867162018-11-07 20:40:26 -08003310 case RENAME_ADD:
3311 /*
3312 * Probably unclean merge, but if the renamed file
3313 * merges cleanly and the result can then be
3314 * two-way merged cleanly with the added file, I
3315 * guess it's a clean merge?
3316 */
Elijah Newren043622b2019-04-05 08:00:16 -07003317 clean_merge = handle_rename_add(opt, ci);
Elijah Newren7f867162018-11-07 20:40:26 -08003318 break;
Elijah Newren3b130adf2010-09-20 02:29:02 -06003319 case RENAME_DELETE:
3320 clean_merge = 0;
Elijah Newrene2d563d2019-04-05 08:00:21 -07003321 if (handle_rename_delete(opt, ci))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003322 clean_merge = -1;
Elijah Newren3b130adf2010-09-20 02:29:02 -06003323 break;
Elijah Newren07413c52010-09-20 02:29:00 -06003324 case RENAME_ONE_FILE_TO_TWO:
Elijah Newren8daec1d2019-04-05 08:00:22 -07003325 /*
3326 * Manually fix up paths; note:
3327 * ren[12]->pair->one->path are equal.
3328 */
3329 o->path = ci->ren1->pair->one->path;
3330 a->path = ci->ren1->pair->two->path;
3331 b->path = ci->ren2->pair->two->path;
3332
Elijah Newren07413c52010-09-20 02:29:00 -06003333 clean_merge = 0;
Elijah Newren043622b2019-04-05 08:00:16 -07003334 if (handle_rename_rename_1to2(opt, ci))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003335 clean_merge = -1;
Elijah Newren07413c52010-09-20 02:29:00 -06003336 break;
Elijah Newren461f5042011-08-11 23:20:15 -06003337 case RENAME_TWO_FILES_TO_ONE:
Elijah Newrenbbafc9c2018-11-07 20:40:27 -08003338 /*
Elijah Newren8daec1d2019-04-05 08:00:22 -07003339 * Manually fix up paths; note,
3340 * ren[12]->pair->two->path are actually equal.
3341 */
3342 o->path = NULL;
3343 a->path = ci->ren1->pair->two->path;
3344 b->path = ci->ren2->pair->two->path;
3345
3346 /*
Elijah Newrenbbafc9c2018-11-07 20:40:27 -08003347 * Probably unclean merge, but if the two renamed
3348 * files merge cleanly and the two resulting files
3349 * can then be two-way merged cleanly, I guess it's
3350 * a clean merge?
3351 */
Elijah Newren043622b2019-04-05 08:00:16 -07003352 clean_merge = handle_rename_rename_2to1(opt, ci);
Elijah Newren461f5042011-08-11 23:20:15 -06003353 break;
Elijah Newren07413c52010-09-20 02:29:00 -06003354 default:
3355 entry->processed = 0;
3356 break;
3357 }
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003358 if (path_clean < clean_merge)
3359 clean_merge = path_clean;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003360 } else if (o_valid && (!a_valid || !b_valid)) {
Elijah Newren37348932010-07-09 07:10:53 -06003361 /* Case A: Deleted in one */
Elijah Newren8daec1d2019-04-05 08:00:22 -07003362 if ((!a_valid && !b_valid) ||
3363 (!b_valid && blob_unchanged(opt, o, a, normalize, path)) ||
3364 (!a_valid && blob_unchanged(opt, o, b, normalize, path))) {
Elijah Newren37348932010-07-09 07:10:53 -06003365 /* Deleted in both or deleted in one and
3366 * unchanged in the other */
Elijah Newren8daec1d2019-04-05 08:00:22 -07003367 if (a_valid)
Elijah Newren259ccb62019-04-05 08:00:13 -07003368 output(opt, 2, _("Removing %s"), path);
Elijah Newren37348932010-07-09 07:10:53 -06003369 /* do not touch working file if it did not exist */
Elijah Newren8daec1d2019-04-05 08:00:22 -07003370 remove_file(opt, 1, path, !a_valid);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003371 } else {
Elijah Newrenedd2faf2011-08-11 23:20:07 -06003372 /* Modify/delete; deleted side may have put a directory in the way */
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003373 clean_merge = 0;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003374 if (handle_modify_delete(opt, path, o, a, b))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003375 clean_merge = -1;
Miklos Vajna8a2fce12008-08-25 16:25:57 +02003376 }
Elijah Newren8daec1d2019-04-05 08:00:22 -07003377 } else if ((!o_valid && a_valid && !b_valid) ||
3378 (!o_valid && !a_valid && b_valid)) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003379 /* Case B: Added in one. */
Elijah Newrenedd2faf2011-08-11 23:20:07 -06003380 /* [nothing|directory] -> ([nothing|directory], file) */
Miklos Vajna8a2fce12008-08-25 16:25:57 +02003381
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003382 const char *add_branch;
3383 const char *other_branch;
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003384 const char *conf;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003385 const struct diff_filespec *contents;
Elijah Newren37348932010-07-09 07:10:53 -06003386
Elijah Newren8daec1d2019-04-05 08:00:22 -07003387 if (a_valid) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003388 add_branch = opt->branch1;
3389 other_branch = opt->branch2;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003390 contents = a;
Jiang Xin55653a62012-07-25 22:53:13 +08003391 conf = _("file/directory");
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003392 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07003393 add_branch = opt->branch2;
3394 other_branch = opt->branch1;
Elijah Newren8daec1d2019-04-05 08:00:22 -07003395 contents = b;
Jiang Xin55653a62012-07-25 22:53:13 +08003396 conf = _("directory/file");
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003397 }
Elijah Newren259ccb62019-04-05 08:00:13 -07003398 if (dir_in_way(opt->repo->index, path,
Elijah Newren5bf7e572019-08-17 11:41:41 -07003399 !opt->priv->call_depth && !S_ISGITLINK(a->mode),
Elijah Newrenc641ca62017-11-14 09:31:24 -08003400 0)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003401 char *new_path = unique_path(opt, path, add_branch);
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003402 clean_merge = 0;
Elijah Newren259ccb62019-04-05 08:00:13 -07003403 output(opt, 1, _("CONFLICT (%s): There is a directory with name %s in %s. "
Jiang Xin55653a62012-07-25 22:53:13 +08003404 "Adding %s as %s"),
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003405 conf, path, other_branch, path, new_path);
Elijah Newren8daec1d2019-04-05 08:00:22 -07003406 if (update_file(opt, 0, contents, new_path))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003407 clean_merge = -1;
Elijah Newren5bf7e572019-08-17 11:41:41 -07003408 else if (opt->priv->call_depth)
Elijah Newren259ccb62019-04-05 08:00:13 -07003409 remove_file_from_index(opt->repo->index, path);
Elijah Newren3d6b8e82011-08-11 23:19:53 -06003410 free(new_path);
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003411 } else {
Elijah Newren259ccb62019-04-05 08:00:13 -07003412 output(opt, 2, _("Adding %s"), path);
Elijah Newren35a74ab2011-08-11 23:20:27 -06003413 /* do not overwrite file if already present */
Elijah Newren8daec1d2019-04-05 08:00:22 -07003414 if (update_file_flags(opt, contents, path, 1, !a_valid))
Johannes Schindelin75456f92016-07-26 18:06:21 +02003415 clean_merge = -1;
Elijah Newren9c0bbb52010-09-20 02:28:56 -06003416 }
Elijah Newren8daec1d2019-04-05 08:00:22 -07003417 } else if (a_valid && b_valid) {
3418 if (!o_valid) {
Elijah Newrendcf28152018-11-07 20:40:28 -08003419 /* Case C: Added in both (check for same permissions) */
Elijah Newren259ccb62019-04-05 08:00:13 -07003420 output(opt, 1,
Elijah Newrendcf28152018-11-07 20:40:28 -08003421 _("CONFLICT (add/add): Merge conflict in %s"),
3422 path);
Elijah Newren259ccb62019-04-05 08:00:13 -07003423 clean_merge = handle_file_collision(opt,
Elijah Newrendcf28152018-11-07 20:40:28 -08003424 path, NULL, NULL,
Elijah Newren259ccb62019-04-05 08:00:13 -07003425 opt->branch1,
3426 opt->branch2,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003427 a, b);
Elijah Newrendcf28152018-11-07 20:40:28 -08003428 } else {
3429 /* case D: Modified in both, but differently. */
Elijah Newrene62d1122019-04-05 08:00:25 -07003430 struct merge_file_info mfi;
Elijah Newrendcf28152018-11-07 20:40:28 -08003431 int is_dirty = 0; /* unpack_trees would have bailed if dirty */
Elijah Newrene62d1122019-04-05 08:00:25 -07003432 clean_merge = handle_content_merge(&mfi, opt, path,
Elijah Newrendcf28152018-11-07 20:40:28 -08003433 is_dirty,
Elijah Newren8daec1d2019-04-05 08:00:22 -07003434 o, a, b, NULL);
Elijah Newrendcf28152018-11-07 20:40:28 -08003435 }
Elijah Newren8daec1d2019-04-05 08:00:22 -07003436 } else if (!o_valid && !a_valid && !b_valid) {
Elijah Newrenedd2faf2011-08-11 23:20:07 -06003437 /*
3438 * this entry was deleted altogether. a_mode == 0 means
3439 * we had that path and want to actively remove it.
3440 */
Elijah Newren8daec1d2019-04-05 08:00:22 -07003441 remove_file(opt, 1, path, !a->mode);
Elijah Newrenedd2faf2011-08-11 23:20:07 -06003442 } else
Johannes Schindelin033abf92018-05-02 11:38:39 +02003443 BUG("fatal merge failure, shouldn't happen.");
Elijah Newren37348932010-07-09 07:10:53 -06003444
3445 return clean_merge;
3446}
3447
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003448static int merge_trees_internal(struct merge_options *opt,
3449 struct tree *head,
3450 struct tree *merge,
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003451 struct tree *merge_base,
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003452 struct tree **result)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003453{
Elijah Newren259ccb62019-04-05 08:00:13 -07003454 struct index_state *istate = opt->repo->index;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003455 int code, clean;
3456
Elijah Newren259ccb62019-04-05 08:00:13 -07003457 if (opt->subtree_shift) {
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003458 merge = shift_tree_object(opt->repo, head, merge,
3459 opt->subtree_shift);
3460 merge_base = shift_tree_object(opt->repo, head, merge_base,
3461 opt->subtree_shift);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003462 }
3463
Elijah Newren763a59e2020-01-01 05:20:57 +00003464 if (oideq(&merge_base->object.oid, &merge->object.oid)) {
Eric Sunshine80cde952021-05-02 01:14:22 -04003465 output(opt, 0, _("Already up to date."));
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003466 *result = head;
3467 return 1;
3468 }
3469
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003470 code = unpack_trees_start(opt, merge_base, head, merge);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003471
Junio C Hamanofadd0692009-09-07 22:43:11 -07003472 if (code != 0) {
Elijah Newren5bf7e572019-08-17 11:41:41 -07003473 if (show(opt, 4) || opt->priv->call_depth)
Elijah Newren259ccb62019-04-05 08:00:13 -07003474 err(opt, _("merging of trees %s and %s failed"),
brian m. carlsonf2fd0762015-11-10 02:22:28 +00003475 oid_to_hex(&head->object.oid),
3476 oid_to_hex(&merge->object.oid));
Elijah Newren259ccb62019-04-05 08:00:13 -07003477 unpack_trees_finish(opt);
Johannes Schindelin60033032016-07-26 18:06:26 +02003478 return -1;
Junio C Hamanofadd0692009-09-07 22:43:11 -07003479 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003480
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +07003481 if (unmerged_index(istate)) {
Elijah Newrenf1725892018-04-19 10:58:00 -07003482 struct string_list *entries;
3483 struct rename_info re_info;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003484 int i;
Kevin Willfordfc65b002017-09-07 10:25:56 -06003485 /*
3486 * Only need the hashmap while processing entries, so
3487 * initialize it here and free it when we are done running
3488 * through the entries. Keeping it in the merge_options as
3489 * opposed to decaring a local hashmap is for convenience
3490 * so that we don't have to pass it to around.
3491 */
Elijah Newren5bf7e572019-08-17 11:41:41 -07003492 hashmap_init(&opt->priv->current_file_dir_set, path_hashmap_cmp,
Elijah Newren4d7101e2019-08-17 11:41:33 -07003493 NULL, 512);
Elijah Newren259ccb62019-04-05 08:00:13 -07003494 get_files_dirs(opt, head);
3495 get_files_dirs(opt, merge);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003496
Elijah Newren259ccb62019-04-05 08:00:13 -07003497 entries = get_unmerged(opt->repo->index);
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003498 clean = detect_and_process_renames(opt, merge_base, head, merge,
Elijah Newren8ebe7b02018-06-09 21:16:15 -07003499 entries, &re_info);
Elijah Newren259ccb62019-04-05 08:00:13 -07003500 record_df_conflict_files(opt, entries);
Johannes Schindelin75456f92016-07-26 18:06:21 +02003501 if (clean < 0)
Kevin Willforde336bdc2017-08-28 14:28:27 -06003502 goto cleanup;
Elijah Newrenedd2faf2011-08-11 23:20:07 -06003503 for (i = entries->nr-1; 0 <= i; i--) {
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003504 const char *path = entries->items[i].string;
3505 struct stage_data *e = entries->items[i].util;
Johannes Schindelin75456f92016-07-26 18:06:21 +02003506 if (!e->processed) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003507 int ret = process_entry(opt, path, e);
Johannes Schindelin75456f92016-07-26 18:06:21 +02003508 if (!ret)
3509 clean = 0;
Kevin Willforde336bdc2017-08-28 14:28:27 -06003510 else if (ret < 0) {
3511 clean = ret;
3512 goto cleanup;
3513 }
Johannes Schindelin75456f92016-07-26 18:06:21 +02003514 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003515 }
Elijah Newren37348932010-07-09 07:10:53 -06003516 for (i = 0; i < entries->nr; i++) {
Junio C Hamano7edba4c2010-09-20 02:28:35 -06003517 struct stage_data *e = entries->items[i].util;
3518 if (!e->processed)
Johannes Schindelin033abf92018-05-02 11:38:39 +02003519 BUG("unprocessed path??? %s",
Junio C Hamano7edba4c2010-09-20 02:28:35 -06003520 entries->items[i].string);
3521 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003522
Elijah Newren93665362018-06-09 21:16:13 -07003523 cleanup:
Elijah Newrenffc16c42018-04-19 10:58:04 -07003524 final_cleanup_renames(&re_info);
Elijah Newrenf1725892018-04-19 10:58:00 -07003525
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003526 string_list_clear(entries, 1);
Elijah Newrenf1725892018-04-19 10:58:00 -07003527 free(entries);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003528
Elijah Newren6da1a252020-11-02 18:55:05 +00003529 hashmap_clear_and_free(&opt->priv->current_file_dir_set,
Eric Wongc8e424c2019-10-06 23:30:40 +00003530 struct path_hashmap_entry, e);
Kevin Willfordfc65b002017-09-07 10:25:56 -06003531
Elijah Newren3f1c1c32018-05-20 12:17:35 +02003532 if (clean < 0) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003533 unpack_trees_finish(opt);
Kevin Willforde336bdc2017-08-28 14:28:27 -06003534 return clean;
Elijah Newren3f1c1c32018-05-20 12:17:35 +02003535 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003536 }
3537 else
3538 clean = 1;
3539
Elijah Newren259ccb62019-04-05 08:00:13 -07003540 unpack_trees_finish(opt);
Elijah Newrena35edc82018-04-19 10:58:20 -07003541
Elijah Newren5bf7e572019-08-17 11:41:41 -07003542 if (opt->priv->call_depth &&
Elijah Newren724dd762019-08-17 11:41:32 -07003543 !(*result = write_in_core_index_as_tree(opt->repo)))
Johannes Schindelinfbc87eb2016-07-26 18:06:17 +02003544 return -1;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003545
3546 return clean;
3547}
3548
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003549/*
Elijah Newren56e74342020-08-02 03:14:27 +00003550 * Merge the commits h1 and h2, returning a flag (int) indicating the
3551 * cleanness of the merge. Also, if opt->priv->call_depth, create a
3552 * virtual commit and write its location to *result.
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003553 */
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003554static int merge_recursive_internal(struct merge_options *opt,
3555 struct commit *h1,
3556 struct commit *h2,
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003557 struct commit_list *merge_bases,
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003558 struct commit **result)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003559{
3560 struct commit_list *iter;
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003561 struct commit *merged_merge_bases;
Elijah Newrenbab56872019-08-17 11:41:35 -07003562 struct tree *result_tree;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003563 int clean;
Elijah Newren743474c2019-08-17 11:41:24 -07003564 const char *ancestor_name;
3565 struct strbuf merge_base_abbrev = STRBUF_INIT;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003566
Elijah Newren259ccb62019-04-05 08:00:13 -07003567 if (show(opt, 4)) {
3568 output(opt, 4, _("Merging:"));
3569 output_commit_title(opt, h1);
3570 output_commit_title(opt, h2);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003571 }
3572
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003573 if (!merge_bases) {
3574 merge_bases = get_merge_bases(h1, h2);
3575 merge_bases = reverse_commit_list(merge_bases);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003576 }
3577
Elijah Newren259ccb62019-04-05 08:00:13 -07003578 if (show(opt, 5)) {
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003579 unsigned cnt = commit_list_count(merge_bases);
Ralf Thielowe0453cd2012-08-05 19:56:38 +02003580
Elijah Newren259ccb62019-04-05 08:00:13 -07003581 output(opt, 5, Q_("found %u common ancestor:",
Ralf Thielowe0453cd2012-08-05 19:56:38 +02003582 "found %u common ancestors:", cnt), cnt);
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003583 for (iter = merge_bases; iter; iter = iter->next)
Elijah Newren259ccb62019-04-05 08:00:13 -07003584 output_commit_title(opt, iter->item);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003585 }
3586
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003587 merged_merge_bases = pop_commit(&merge_bases);
3588 if (merged_merge_bases == NULL) {
Jonathan Nieder03f622c2011-08-16 13:27:39 -05003589 /* if there is no common ancestor, use an empty tree */
3590 struct tree *tree;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003591
Elijah Newren259ccb62019-04-05 08:00:13 -07003592 tree = lookup_tree(opt->repo, opt->repo->hash_algo->empty_tree);
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003593 merged_merge_bases = make_virtual_commit(opt->repo, tree,
3594 "ancestor");
Elijah Newren743474c2019-08-17 11:41:24 -07003595 ancestor_name = "empty tree";
Elijah Newrenb6570472019-10-07 08:52:11 -07003596 } else if (opt->ancestor && !opt->priv->call_depth) {
Elijah Newren8e4ec332019-10-01 11:17:27 -07003597 ancestor_name = opt->ancestor;
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003598 } else if (merge_bases) {
Elijah Newren743474c2019-08-17 11:41:24 -07003599 ancestor_name = "merged common ancestors";
3600 } else {
3601 strbuf_add_unique_abbrev(&merge_base_abbrev,
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003602 &merged_merge_bases->object.oid,
Elijah Newren743474c2019-08-17 11:41:24 -07003603 DEFAULT_ABBREV);
3604 ancestor_name = merge_base_abbrev.buf;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003605 }
3606
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003607 for (iter = merge_bases; iter; iter = iter->next) {
Miklos Vajna8a2fce12008-08-25 16:25:57 +02003608 const char *saved_b1, *saved_b2;
Elijah Newren5bf7e572019-08-17 11:41:41 -07003609 opt->priv->call_depth++;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003610 /*
3611 * When the merge fails, the result contains files
3612 * with conflict markers. The cleanness flag is
Johannes Schindelinde8946d2016-07-26 18:06:07 +02003613 * ignored (unless indicating an error), it was never
3614 * actually used, as result of merge_trees has always
3615 * overwritten it: the committed "conflicts" were
3616 * already resolved.
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003617 */
Elijah Newren259ccb62019-04-05 08:00:13 -07003618 discard_index(opt->repo->index);
3619 saved_b1 = opt->branch1;
3620 saved_b2 = opt->branch2;
3621 opt->branch1 = "Temporary merge branch 1";
3622 opt->branch2 = "Temporary merge branch 2";
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003623 if (merge_recursive_internal(opt, merged_merge_bases, iter->item,
3624 NULL, &merged_merge_bases) < 0)
Johannes Schindelinde8946d2016-07-26 18:06:07 +02003625 return -1;
Elijah Newren259ccb62019-04-05 08:00:13 -07003626 opt->branch1 = saved_b1;
3627 opt->branch2 = saved_b2;
Elijah Newren5bf7e572019-08-17 11:41:41 -07003628 opt->priv->call_depth--;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003629
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003630 if (!merged_merge_bases)
Elijah Newren259ccb62019-04-05 08:00:13 -07003631 return err(opt, _("merge returned no commit"));
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003632 }
3633
Elijah Newren816147e2021-03-20 00:03:53 +00003634 /*
3635 * FIXME: Since merge_recursive_internal() is only ever called by
3636 * places that ensure the index is loaded first
3637 * (e.g. builtin/merge.c, rebase/sequencer, etc.), in the common
3638 * case where the merge base was unique that means when we get here
3639 * we immediately discard the index and re-read it, which is a
3640 * complete waste of time. We should only be discarding and
3641 * re-reading if we were forced to recurse.
3642 */
Elijah Newren259ccb62019-04-05 08:00:13 -07003643 discard_index(opt->repo->index);
Elijah Newren5bf7e572019-08-17 11:41:41 -07003644 if (!opt->priv->call_depth)
Elijah Newren259ccb62019-04-05 08:00:13 -07003645 repo_read_index(opt->repo);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003646
Elijah Newren743474c2019-08-17 11:41:24 -07003647 opt->ancestor = ancestor_name;
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003648 clean = merge_trees_internal(opt,
3649 repo_get_commit_tree(opt->repo, h1),
3650 repo_get_commit_tree(opt->repo, h2),
3651 repo_get_commit_tree(opt->repo,
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003652 merged_merge_bases),
Elijah Newrenbab56872019-08-17 11:41:35 -07003653 &result_tree);
Elijah Newren743474c2019-08-17 11:41:24 -07003654 strbuf_release(&merge_base_abbrev);
Elijah Newrenb6570472019-10-07 08:52:11 -07003655 opt->ancestor = NULL; /* avoid accidental re-use of opt->ancestor */
Johannes Schindelin6999bc72016-08-01 13:44:57 +02003656 if (clean < 0) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003657 flush_output(opt);
Johannes Schindelinde8946d2016-07-26 18:06:07 +02003658 return clean;
Johannes Schindelin6999bc72016-08-01 13:44:57 +02003659 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003660
Elijah Newren5bf7e572019-08-17 11:41:41 -07003661 if (opt->priv->call_depth) {
Elijah Newrenbab56872019-08-17 11:41:35 -07003662 *result = make_virtual_commit(opt->repo, result_tree,
3663 "merged tree");
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003664 commit_list_insert(h1, &(*result)->parents);
3665 commit_list_insert(h2, &(*result)->parents->next);
3666 }
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003667 return clean;
3668}
3669
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003670static int merge_start(struct merge_options *opt, struct tree *head)
3671{
3672 struct strbuf sb = STRBUF_INIT;
3673
Elijah Newren45ef16f2019-08-17 11:41:43 -07003674 /* Sanity checks on opt */
3675 assert(opt->repo);
3676
3677 assert(opt->branch1 && opt->branch2);
3678
3679 assert(opt->detect_renames >= -1 &&
3680 opt->detect_renames <= DIFF_DETECT_COPY);
3681 assert(opt->detect_directory_renames >= MERGE_DIRECTORY_RENAMES_NONE &&
3682 opt->detect_directory_renames <= MERGE_DIRECTORY_RENAMES_TRUE);
3683 assert(opt->rename_limit >= -1);
3684 assert(opt->rename_score >= 0 && opt->rename_score <= MAX_SCORE);
3685 assert(opt->show_rename_progress >= 0 && opt->show_rename_progress <= 1);
3686
3687 assert(opt->xdl_opts >= 0);
3688 assert(opt->recursive_variant >= MERGE_VARIANT_NORMAL &&
3689 opt->recursive_variant <= MERGE_VARIANT_THEIRS);
3690
3691 assert(opt->verbosity >= 0 && opt->verbosity <= 5);
3692 assert(opt->buffer_output <= 2);
3693 assert(opt->obuf.len == 0);
3694
3695 assert(opt->priv == NULL);
3696
3697 /* Sanity check on repo state; index must match head */
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003698 if (repo_index_has_changes(opt->repo, head, &sb)) {
3699 err(opt, _("Your local changes to the following files would be overwritten by merge:\n %s"),
3700 sb.buf);
3701 strbuf_release(&sb);
3702 return -1;
3703 }
3704
René Scharfeca56dad2021-03-13 17:17:22 +01003705 CALLOC_ARRAY(opt->priv, 1);
Elijah Newren5bf7e572019-08-17 11:41:41 -07003706 string_list_init(&opt->priv->df_conflict_file_set, 1);
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003707 return 0;
3708}
3709
3710static void merge_finalize(struct merge_options *opt)
3711{
Elijah Newrene95e4812019-08-17 11:41:40 -07003712 flush_output(opt);
Elijah Newren5bf7e572019-08-17 11:41:41 -07003713 if (!opt->priv->call_depth && opt->buffer_output < 2)
Elijah Newrene95e4812019-08-17 11:41:40 -07003714 strbuf_release(&opt->obuf);
Elijah Newren345480d2019-08-17 11:41:31 -07003715 if (show(opt, 2))
3716 diff_warn_rename_limit("merge.renamelimit",
Elijah Newren5bf7e572019-08-17 11:41:41 -07003717 opt->priv->needed_rename_limit, 0);
3718 FREE_AND_NULL(opt->priv);
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003719}
3720
3721int merge_trees(struct merge_options *opt,
3722 struct tree *head,
3723 struct tree *merge,
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003724 struct tree *merge_base)
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003725{
3726 int clean;
Elijah Newrenb4db8a22019-08-17 11:41:30 -07003727 struct tree *ignored;
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003728
3729 assert(opt->ancestor != NULL);
3730
3731 if (merge_start(opt, head))
3732 return -1;
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003733 clean = merge_trees_internal(opt, head, merge, merge_base, &ignored);
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003734 merge_finalize(opt);
3735
3736 return clean;
3737}
3738
3739int merge_recursive(struct merge_options *opt,
3740 struct commit *h1,
3741 struct commit *h2,
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003742 struct commit_list *merge_bases,
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003743 struct commit **result)
3744{
3745 int clean;
3746
Elijah Newren8e4ec332019-10-01 11:17:27 -07003747 assert(opt->ancestor == NULL ||
3748 !strcmp(opt->ancestor, "constructed merge base"));
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003749
3750 if (merge_start(opt, repo_get_commit_tree(opt->repo, h1)))
3751 return -1;
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003752 clean = merge_recursive_internal(opt, h1, h2, merge_bases, result);
Elijah Newren98a1d3d2019-08-17 11:41:29 -07003753 merge_finalize(opt);
3754
3755 return clean;
3756}
3757
Elijah Newren4d7101e2019-08-17 11:41:33 -07003758static struct commit *get_ref(struct repository *repo,
3759 const struct object_id *oid,
Nguyễn Thái Ngọc Duyd7cf3a92019-01-12 09:13:30 +07003760 const char *name)
Stephan Beyer73118f82008-08-12 22:13:59 +02003761{
3762 struct object *object;
3763
Nguyễn Thái Ngọc Duyd7cf3a92019-01-12 09:13:30 +07003764 object = deref_tag(repo, parse_object(repo, oid),
3765 name, strlen(name));
Stephan Beyer73118f82008-08-12 22:13:59 +02003766 if (!object)
3767 return NULL;
3768 if (object->type == OBJ_TREE)
Nguyễn Thái Ngọc Duyd7cf3a92019-01-12 09:13:30 +07003769 return make_virtual_commit(repo, (struct tree*)object, name);
Stephan Beyer73118f82008-08-12 22:13:59 +02003770 if (object->type != OBJ_COMMIT)
3771 return NULL;
3772 if (parse_commit((struct commit *)object))
3773 return NULL;
3774 return (struct commit *)object;
3775}
3776
Elijah Newren259ccb62019-04-05 08:00:13 -07003777int merge_recursive_generic(struct merge_options *opt,
brian m. carlson4e8161a2016-06-24 23:09:28 +00003778 const struct object_id *head,
3779 const struct object_id *merge,
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003780 int num_merge_bases,
3781 const struct object_id **merge_bases,
Miklos Vajna8a2fce12008-08-25 16:25:57 +02003782 struct commit **result)
Stephan Beyer73118f82008-08-12 22:13:59 +02003783{
Nguyễn Thái Ngọc Duy03b86642014-06-13 19:19:23 +07003784 int clean;
Martin Ågren837e34e2017-10-05 22:32:04 +02003785 struct lock_file lock = LOCK_INIT;
Elijah Newren259ccb62019-04-05 08:00:13 -07003786 struct commit *head_commit = get_ref(opt->repo, head, opt->branch1);
3787 struct commit *next_commit = get_ref(opt->repo, merge, opt->branch2);
Stephan Beyer73118f82008-08-12 22:13:59 +02003788 struct commit_list *ca = NULL;
3789
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003790 if (merge_bases) {
Stephan Beyer73118f82008-08-12 22:13:59 +02003791 int i;
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003792 for (i = 0; i < num_merge_bases; ++i) {
Stephan Beyer73118f82008-08-12 22:13:59 +02003793 struct commit *base;
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003794 if (!(base = get_ref(opt->repo, merge_bases[i],
3795 oid_to_hex(merge_bases[i]))))
Elijah Newren259ccb62019-04-05 08:00:13 -07003796 return err(opt, _("Could not parse object '%s'"),
Elijah Newrenff1bfa22019-08-17 11:41:34 -07003797 oid_to_hex(merge_bases[i]));
Stephan Beyer73118f82008-08-12 22:13:59 +02003798 commit_list_insert(base, &ca);
3799 }
Elijah Newren8e4ec332019-10-01 11:17:27 -07003800 if (num_merge_bases == 1)
3801 opt->ancestor = "constructed merge base";
Stephan Beyer73118f82008-08-12 22:13:59 +02003802 }
3803
Elijah Newren259ccb62019-04-05 08:00:13 -07003804 repo_hold_locked_index(opt->repo, &lock, LOCK_DIE_ON_ERROR);
3805 clean = merge_recursive(opt, head_commit, next_commit, ca,
Elijah Newrend90e7592018-06-09 21:16:12 -07003806 result);
Martin Ågren51d3f432018-02-28 20:07:56 +01003807 if (clean < 0) {
3808 rollback_lock_file(&lock);
Johannes Schindelinde8946d2016-07-26 18:06:07 +02003809 return clean;
Martin Ågren51d3f432018-02-28 20:07:56 +01003810 }
Johannes Schindelinde8946d2016-07-26 18:06:07 +02003811
Elijah Newren259ccb62019-04-05 08:00:13 -07003812 if (write_locked_index(opt->repo->index, &lock,
Martin Ågren61000812018-03-01 21:40:20 +01003813 COMMIT_LOCK | SKIP_IF_UNCHANGED))
Elijah Newren259ccb62019-04-05 08:00:13 -07003814 return err(opt, _("Unable to write index."));
Stephan Beyer73118f82008-08-12 22:13:59 +02003815
3816 return clean ? 0 : 1;
3817}
3818
Elijah Newren259ccb62019-04-05 08:00:13 -07003819static void merge_recursive_config(struct merge_options *opt)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003820{
Ben Peart85b46032018-05-02 16:01:14 +00003821 char *value = NULL;
Elijah Newren8d552252020-08-03 18:41:19 +00003822 int renormalize = 0;
Elijah Newren259ccb62019-04-05 08:00:13 -07003823 git_config_get_int("merge.verbosity", &opt->verbosity);
Elijah Newren8599ab42019-08-17 11:41:38 -07003824 git_config_get_int("diff.renamelimit", &opt->rename_limit);
3825 git_config_get_int("merge.renamelimit", &opt->rename_limit);
Elijah Newren8d552252020-08-03 18:41:19 +00003826 git_config_get_bool("merge.renormalize", &renormalize);
3827 opt->renormalize = renormalize;
Ben Peart85b46032018-05-02 16:01:14 +00003828 if (!git_config_get_string("diff.renames", &value)) {
Elijah Newren8599ab42019-08-17 11:41:38 -07003829 opt->detect_renames = git_config_rename("diff.renames", value);
Ben Peart85b46032018-05-02 16:01:14 +00003830 free(value);
3831 }
3832 if (!git_config_get_string("merge.renames", &value)) {
Elijah Newren8599ab42019-08-17 11:41:38 -07003833 opt->detect_renames = git_config_rename("merge.renames", value);
Ben Peart85b46032018-05-02 16:01:14 +00003834 free(value);
3835 }
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003836 if (!git_config_get_string("merge.directoryrenames", &value)) {
3837 int boolval = git_parse_maybe_bool(value);
3838 if (0 <= boolval) {
Derrick Stolee8e012512019-08-17 11:41:25 -07003839 opt->detect_directory_renames = boolval ?
3840 MERGE_DIRECTORY_RENAMES_TRUE :
3841 MERGE_DIRECTORY_RENAMES_NONE;
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003842 } else if (!strcasecmp(value, "conflict")) {
Derrick Stolee8e012512019-08-17 11:41:25 -07003843 opt->detect_directory_renames =
3844 MERGE_DIRECTORY_RENAMES_CONFLICT;
Elijah Newren8c8e5bd2019-04-05 08:00:26 -07003845 } /* avoid erroring on values from future versions of git */
Tanay Abhra0e7bcb12014-08-13 01:22:01 -07003846 free(value);
3847 }
3848 git_config(git_xmerge_config, NULL);
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003849}
3850
Elijah Newren259ccb62019-04-05 08:00:13 -07003851void init_merge_options(struct merge_options *opt,
Nguyễn Thái Ngọc Duy0d6caa22019-01-12 09:13:29 +07003852 struct repository *repo)
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003853{
Andrey Okoshkin80486222017-10-31 12:09:13 +03003854 const char *merge_verbosity;
Elijah Newren259ccb62019-04-05 08:00:13 -07003855 memset(opt, 0, sizeof(struct merge_options));
Elijah Newrena779fb82019-08-17 11:41:39 -07003856
Elijah Newren259ccb62019-04-05 08:00:13 -07003857 opt->repo = repo;
Elijah Newrena779fb82019-08-17 11:41:39 -07003858
Elijah Newren8599ab42019-08-17 11:41:38 -07003859 opt->detect_renames = -1;
Derrick Stolee8e012512019-08-17 11:41:25 -07003860 opt->detect_directory_renames = MERGE_DIRECTORY_RENAMES_CONFLICT;
Elijah Newrena779fb82019-08-17 11:41:39 -07003861 opt->rename_limit = -1;
3862
Elijah Newren259ccb62019-04-05 08:00:13 -07003863 opt->verbosity = 2;
3864 opt->buffer_output = 1;
Elijah Newrena779fb82019-08-17 11:41:39 -07003865 strbuf_init(&opt->obuf, 0);
3866
Elijah Newren259ccb62019-04-05 08:00:13 -07003867 opt->renormalize = 0;
Elijah Newrena779fb82019-08-17 11:41:39 -07003868
Elijah Newren259ccb62019-04-05 08:00:13 -07003869 merge_recursive_config(opt);
Andrey Okoshkin80486222017-10-31 12:09:13 +03003870 merge_verbosity = getenv("GIT_MERGE_VERBOSITY");
3871 if (merge_verbosity)
Elijah Newren259ccb62019-04-05 08:00:13 -07003872 opt->verbosity = strtol(merge_verbosity, NULL, 10);
3873 if (opt->verbosity >= 5)
3874 opt->buffer_output = 0;
Miklos Vajna9047ebb2008-08-12 18:45:14 +02003875}
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003876
Elijah Newren259ccb62019-04-05 08:00:13 -07003877int parse_merge_opt(struct merge_options *opt, const char *s)
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003878{
Jeff King95b567c2014-06-18 15:48:29 -04003879 const char *arg;
3880
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003881 if (!s || !*s)
3882 return -1;
3883 if (!strcmp(s, "ours"))
Elijah Newrenf3081da2019-08-17 11:41:42 -07003884 opt->recursive_variant = MERGE_VARIANT_OURS;
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003885 else if (!strcmp(s, "theirs"))
Elijah Newrenf3081da2019-08-17 11:41:42 -07003886 opt->recursive_variant = MERGE_VARIANT_THEIRS;
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003887 else if (!strcmp(s, "subtree"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003888 opt->subtree_shift = "";
Jeff King95b567c2014-06-18 15:48:29 -04003889 else if (skip_prefix(s, "subtree=", &arg))
Elijah Newren259ccb62019-04-05 08:00:13 -07003890 opt->subtree_shift = arg;
Justin Frankel58a1ece2010-08-26 00:50:45 -05003891 else if (!strcmp(s, "patience"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003892 opt->xdl_opts = DIFF_WITH_ALG(opt, PATIENCE_DIFF);
Tay Ray Chuan8c912ee2011-07-12 14:10:25 +08003893 else if (!strcmp(s, "histogram"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003894 opt->xdl_opts = DIFF_WITH_ALG(opt, HISTOGRAM_DIFF);
Jeff King95b567c2014-06-18 15:48:29 -04003895 else if (skip_prefix(s, "diff-algorithm=", &arg)) {
3896 long value = parse_algorithm_value(arg);
Michal Privoznik07924d42013-01-16 08:51:58 +01003897 if (value < 0)
3898 return -1;
3899 /* clear out previous settings */
Elijah Newren259ccb62019-04-05 08:00:13 -07003900 DIFF_XDL_CLR(opt, NEED_MINIMAL);
3901 opt->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;
3902 opt->xdl_opts |= value;
Michal Privoznik07924d42013-01-16 08:51:58 +01003903 }
Justin Frankel4e5dd042010-08-26 00:51:47 -05003904 else if (!strcmp(s, "ignore-space-change"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003905 DIFF_XDL_SET(opt, IGNORE_WHITESPACE_CHANGE);
Justin Frankel4e5dd042010-08-26 00:51:47 -05003906 else if (!strcmp(s, "ignore-all-space"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003907 DIFF_XDL_SET(opt, IGNORE_WHITESPACE);
Justin Frankel4e5dd042010-08-26 00:51:47 -05003908 else if (!strcmp(s, "ignore-space-at-eol"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003909 DIFF_XDL_SET(opt, IGNORE_WHITESPACE_AT_EOL);
Junio C Hamanoe9282f02017-10-26 15:32:27 +09003910 else if (!strcmp(s, "ignore-cr-at-eol"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003911 DIFF_XDL_SET(opt, IGNORE_CR_AT_EOL);
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003912 else if (!strcmp(s, "renormalize"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003913 opt->renormalize = 1;
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003914 else if (!strcmp(s, "no-renormalize"))
Elijah Newren259ccb62019-04-05 08:00:13 -07003915 opt->renormalize = 0;
Felipe Gonçalves Assisd2b11ec2016-02-17 01:15:25 -02003916 else if (!strcmp(s, "no-renames"))
Elijah Newren8599ab42019-08-17 11:41:38 -07003917 opt->detect_renames = 0;
Felipe Gonçalves Assis87892f62016-02-21 19:59:05 -03003918 else if (!strcmp(s, "find-renames")) {
Elijah Newren8599ab42019-08-17 11:41:38 -07003919 opt->detect_renames = 1;
Elijah Newren259ccb62019-04-05 08:00:13 -07003920 opt->rename_score = 0;
Felipe Gonçalves Assis87892f62016-02-21 19:59:05 -03003921 }
Felipe Gonçalves Assis1b47ad12016-02-17 01:15:26 -02003922 else if (skip_prefix(s, "find-renames=", &arg) ||
3923 skip_prefix(s, "rename-threshold=", &arg)) {
Elijah Newren259ccb62019-04-05 08:00:13 -07003924 if ((opt->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0)
Kevin Ballard10ae7522010-09-27 16:58:25 -07003925 return -1;
Elijah Newren8599ab42019-08-17 11:41:38 -07003926 opt->detect_renames = 1;
Kevin Ballard10ae7522010-09-27 16:58:25 -07003927 }
Nguyễn Thái Ngọc Duy5a59a232019-02-16 18:24:41 +07003928 /*
3929 * Please update $__git_merge_strategy_options in
3930 * git-completion.bash when you add new options
3931 */
Jonathan Nieder635a7bb2010-08-26 00:47:58 -05003932 else
3933 return -1;
3934 return 0;
3935}