Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1 | /* |
| 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 Newren | 4615a8c | 2019-08-17 11:41:44 -0700 | [diff] [blame] | 7 | #include "merge-recursive.h" |
| 8 | |
David Aguilar | 1c4b660 | 2014-09-14 00:40:45 -0700 | [diff] [blame] | 9 | #include "advice.h" |
Elijah Newren | 4615a8c | 2019-08-17 11:41:44 -0700 | [diff] [blame] | 10 | #include "alloc.h" |
| 11 | #include "attr.h" |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 12 | #include "blob.h" |
| 13 | #include "builtin.h" |
Elijah Newren | 4615a8c | 2019-08-17 11:41:44 -0700 | [diff] [blame] | 14 | #include "cache-tree.h" |
| 15 | #include "commit.h" |
| 16 | #include "commit-reach.h" |
| 17 | #include "config.h" |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 18 | #include "diff.h" |
| 19 | #include "diffcore.h" |
Shawn O. Pearce | 9800c0d | 2008-09-29 11:04:20 -0700 | [diff] [blame] | 20 | #include "dir.h" |
Elijah Newren | 4615a8c | 2019-08-17 11:41:44 -0700 | [diff] [blame] | 21 | #include "ll-merge.h" |
| 22 | #include "lockfile.h" |
| 23 | #include "object-store.h" |
| 24 | #include "repository.h" |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 25 | #include "revision.h" |
Elijah Newren | 4615a8c | 2019-08-17 11:41:44 -0700 | [diff] [blame] | 26 | #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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 32 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 33 | struct 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 41 | |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 42 | struct path_hashmap_entry { |
| 43 | struct hashmap_entry e; |
| 44 | char path[FLEX_ARRAY]; |
| 45 | }; |
| 46 | |
| 47 | static int path_hashmap_cmp(const void *cmp_data, |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 48 | const struct hashmap_entry *eptr, |
| 49 | const struct hashmap_entry *entry_or_key, |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 50 | const void *keydata) |
| 51 | { |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 52 | const struct path_hashmap_entry *a, *b; |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 53 | const char *key = keydata; |
| 54 | |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 55 | 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 Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 58 | 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 | |
| 64 | static unsigned int path_hash(const char *path) |
| 65 | { |
| 66 | return ignore_case ? strihash(path) : strhash(path); |
| 67 | } |
| 68 | |
Elijah Newren | 7c0a6c8 | 2019-08-17 11:41:37 -0700 | [diff] [blame] | 69 | /* |
| 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 | */ |
| 79 | struct dir_rename_entry { |
Junio C Hamano | 5efabc7 | 2019-10-15 13:48:01 +0900 | [diff] [blame] | 80 | struct hashmap_entry ent; |
Elijah Newren | 7c0a6c8 | 2019-08-17 11:41:37 -0700 | [diff] [blame] | 81 | char *dir; |
| 82 | unsigned non_unique_new_dir:1; |
| 83 | struct strbuf new_dir; |
| 84 | struct string_list possible_new_dirs; |
| 85 | }; |
| 86 | |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 87 | static 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 Wong | d22245a | 2019-10-06 23:30:27 +0000 | [diff] [blame] | 94 | hashmap_entry_init(&key.ent, strhash(dir)); |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 95 | key.dir = dir; |
Eric Wong | 404ab78 | 2019-10-06 23:30:42 +0000 | [diff] [blame] | 96 | return hashmap_get_entry(hashmap, &key, ent, NULL); |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | static int dir_rename_cmp(const void *unused_cmp_data, |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 100 | const struct hashmap_entry *eptr, |
| 101 | const struct hashmap_entry *entry_or_key, |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 102 | const void *unused_keydata) |
| 103 | { |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 104 | 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 108 | |
| 109 | return strcmp(e1->dir, e2->dir); |
| 110 | } |
| 111 | |
| 112 | static void dir_rename_init(struct hashmap *map) |
| 113 | { |
| 114 | hashmap_init(map, dir_rename_cmp, NULL, 0); |
| 115 | } |
| 116 | |
| 117 | static void dir_rename_entry_init(struct dir_rename_entry *entry, |
| 118 | char *directory) |
| 119 | { |
Eric Wong | d22245a | 2019-10-06 23:30:27 +0000 | [diff] [blame] | 120 | hashmap_entry_init(&entry->ent, strhash(directory)); |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 121 | 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 Newren | 7c0a6c8 | 2019-08-17 11:41:37 -0700 | [diff] [blame] | 127 | struct collision_entry { |
Junio C Hamano | 5efabc7 | 2019-10-15 13:48:01 +0900 | [diff] [blame] | 128 | struct hashmap_entry ent; |
Elijah Newren | 7c0a6c8 | 2019-08-17 11:41:37 -0700 | [diff] [blame] | 129 | char *target_file; |
| 130 | struct string_list source_files; |
| 131 | unsigned reported_already:1; |
| 132 | }; |
| 133 | |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 134 | static struct collision_entry *collision_find_entry(struct hashmap *hashmap, |
| 135 | char *target_file) |
| 136 | { |
| 137 | struct collision_entry key; |
| 138 | |
Eric Wong | d22245a | 2019-10-06 23:30:27 +0000 | [diff] [blame] | 139 | hashmap_entry_init(&key.ent, strhash(target_file)); |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 140 | key.target_file = target_file; |
Eric Wong | 404ab78 | 2019-10-06 23:30:42 +0000 | [diff] [blame] | 141 | return hashmap_get_entry(hashmap, &key, ent, NULL); |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 142 | } |
| 143 | |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 144 | static int collision_cmp(const void *unused_cmp_data, |
| 145 | const struct hashmap_entry *eptr, |
| 146 | const struct hashmap_entry *entry_or_key, |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 147 | const void *unused_keydata) |
| 148 | { |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 149 | 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 Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 154 | return strcmp(e1->target_file, e2->target_file); |
| 155 | } |
| 156 | |
| 157 | static void collision_init(struct hashmap *map) |
| 158 | { |
Eric Wong | 939af16 | 2019-10-06 23:30:37 +0000 | [diff] [blame] | 159 | hashmap_init(map, collision_cmp, NULL, 0); |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 160 | } |
| 161 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 162 | static void flush_output(struct merge_options *opt) |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 163 | { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 164 | if (opt->buffer_output < 2 && opt->obuf.len) { |
| 165 | fputs(opt->obuf.buf, stdout); |
| 166 | strbuf_reset(&opt->obuf); |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 167 | } |
| 168 | } |
| 169 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 170 | static int err(struct merge_options *opt, const char *err, ...) |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 171 | { |
| 172 | va_list params; |
| 173 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 174 | if (opt->buffer_output < 2) |
| 175 | flush_output(opt); |
Johannes Schindelin | f1e2426 | 2016-08-01 13:44:50 +0200 | [diff] [blame] | 176 | else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 177 | strbuf_complete(&opt->obuf, '\n'); |
| 178 | strbuf_addstr(&opt->obuf, "error: "); |
Johannes Schindelin | f1e2426 | 2016-08-01 13:44:50 +0200 | [diff] [blame] | 179 | } |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 180 | va_start(params, err); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 181 | strbuf_vaddf(&opt->obuf, err, params); |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 182 | va_end(params); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 183 | if (opt->buffer_output > 1) |
| 184 | strbuf_addch(&opt->obuf, '\n'); |
Johannes Schindelin | f1e2426 | 2016-08-01 13:44:50 +0200 | [diff] [blame] | 185 | else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 186 | error("%s", opt->obuf.buf); |
| 187 | strbuf_reset(&opt->obuf); |
Johannes Schindelin | f1e2426 | 2016-08-01 13:44:50 +0200 | [diff] [blame] | 188 | } |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 189 | |
| 190 | return -1; |
| 191 | } |
| 192 | |
Nguyễn Thái Ngọc Duy | d7cf3a9 | 2019-01-12 09:13:30 +0700 | [diff] [blame] | 193 | static struct tree *shift_tree_object(struct repository *repo, |
| 194 | struct tree *one, struct tree *two, |
Junio C Hamano | 85e51b7 | 2008-06-30 22:18:57 -0700 | [diff] [blame] | 195 | const char *subtree_shift) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 196 | { |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 197 | struct object_id shifted; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 198 | |
Junio C Hamano | 85e51b7 | 2008-06-30 22:18:57 -0700 | [diff] [blame] | 199 | if (!*subtree_shift) { |
Nguyễn Thái Ngọc Duy | 90d3405 | 2019-06-27 16:28:51 +0700 | [diff] [blame] | 200 | shift_tree(repo, &one->object.oid, &two->object.oid, &shifted, 0); |
Junio C Hamano | 85e51b7 | 2008-06-30 22:18:57 -0700 | [diff] [blame] | 201 | } else { |
Nguyễn Thái Ngọc Duy | 90d3405 | 2019-06-27 16:28:51 +0700 | [diff] [blame] | 202 | shift_tree_by(repo, &one->object.oid, &two->object.oid, &shifted, |
Junio C Hamano | 85e51b7 | 2008-06-30 22:18:57 -0700 | [diff] [blame] | 203 | subtree_shift); |
| 204 | } |
Jeff King | 4a7e27e | 2018-08-28 17:22:40 -0400 | [diff] [blame] | 205 | if (oideq(&two->object.oid, &shifted)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 206 | return two; |
Nguyễn Thái Ngọc Duy | d7cf3a9 | 2019-01-12 09:13:30 +0700 | [diff] [blame] | 207 | return lookup_tree(repo, &shifted); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 208 | } |
| 209 | |
Nguyễn Thái Ngọc Duy | a133c40 | 2019-04-16 16:33:18 +0700 | [diff] [blame] | 210 | static 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 Duy | d7cf3a9 | 2019-01-12 09:13:30 +0700 | [diff] [blame] | 215 | static struct commit *make_virtual_commit(struct repository *repo, |
| 216 | struct tree *tree, |
| 217 | const char *comment) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 218 | { |
Nguyễn Thái Ngọc Duy | d7cf3a9 | 2019-01-12 09:13:30 +0700 | [diff] [blame] | 219 | struct commit *commit = alloc_commit_node(repo); |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 220 | |
René Scharfe | a257165 | 2016-08-13 14:16:04 +0200 | [diff] [blame] | 221 | set_merge_remote_desc(commit, comment, (struct object *)commit); |
Nguyễn Thái Ngọc Duy | a133c40 | 2019-04-16 16:33:18 +0700 | [diff] [blame] | 222 | set_commit_tree(commit, tree); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 223 | commit->object.parsed = 1; |
| 224 | return commit; |
| 225 | } |
| 226 | |
Elijah Newren | 25c3936 | 2010-09-20 02:28:53 -0600 | [diff] [blame] | 227 | enum rename_type { |
| 228 | RENAME_NORMAL = 0, |
Elijah Newren | 5455c33 | 2018-06-09 21:16:14 -0700 | [diff] [blame] | 229 | RENAME_VIA_DIR, |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 230 | RENAME_ADD, |
Elijah Newren | 25c3936 | 2010-09-20 02:28:53 -0600 | [diff] [blame] | 231 | RENAME_DELETE, |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 232 | RENAME_ONE_FILE_TO_ONE, |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 233 | RENAME_ONE_FILE_TO_TWO, |
| 234 | RENAME_TWO_FILES_TO_ONE |
Elijah Newren | 25c3936 | 2010-09-20 02:28:53 -0600 | [diff] [blame] | 235 | }; |
| 236 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 237 | /* |
| 238 | * Since we want to write the index eventually, we cannot reuse the index |
| 239 | * for these (temporary) data. |
| 240 | */ |
Jonathan Nieder | 9cba13c | 2011-03-16 02:08:34 -0500 | [diff] [blame] | 241 | struct stage_data { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 242 | struct diff_filespec stages[4]; /* mostly for oid & mode; maybe path */ |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 243 | struct rename_conflict_info *rename_conflict_info; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 244 | unsigned processed:1; |
| 245 | }; |
| 246 | |
Elijah Newren | 967d6be | 2019-04-05 08:00:17 -0700 | [diff] [blame] | 247 | struct rename { |
Elijah Newren | 6d169fd | 2019-04-05 08:00:24 -0700 | [diff] [blame] | 248 | unsigned processed:1; |
Elijah Newren | 967d6be | 2019-04-05 08:00:17 -0700 | [diff] [blame] | 249 | struct diff_filepair *pair; |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 250 | const char *branch; /* branch that the rename occurred on */ |
Elijah Newren | 967d6be | 2019-04-05 08:00:17 -0700 | [diff] [blame] | 251 | /* |
Elijah Newren | 6d169fd | 2019-04-05 08:00:24 -0700 | [diff] [blame] | 252 | * 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 Newren | 967d6be | 2019-04-05 08:00:17 -0700 | [diff] [blame] | 259 | * 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 Newren | 967d6be | 2019-04-05 08:00:17 -0700 | [diff] [blame] | 279 | }; |
| 280 | |
| 281 | struct rename_conflict_info { |
| 282 | enum rename_type rename_type; |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 283 | struct rename *ren1; |
| 284 | struct rename *ren2; |
Elijah Newren | 967d6be | 2019-04-05 08:00:17 -0700 | [diff] [blame] | 285 | }; |
| 286 | |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 287 | static inline void setup_rename_conflict_info(enum rename_type rename_type, |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 288 | struct merge_options *opt, |
| 289 | struct rename *ren1, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 290 | struct rename *ren2) |
Elijah Newren | 25c3936 | 2010-09-20 02:28:53 -0600 | [diff] [blame] | 291 | { |
Elijah Newren | 4f44545 | 2018-10-16 13:19:48 -0700 | [diff] [blame] | 292 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 298 | * ensure that branch1 == opt->branch1. So, simply flip arguments |
Elijah Newren | 4f44545 | 2018-10-16 13:19:48 -0700 | [diff] [blame] | 299 | * around if we don't have that. |
| 300 | */ |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 301 | if (ren2 && ren1->branch != opt->branch1) { |
| 302 | setup_rename_conflict_info(rename_type, opt, ren2, ren1); |
Elijah Newren | 4f44545 | 2018-10-16 13:19:48 -0700 | [diff] [blame] | 303 | return; |
| 304 | } |
| 305 | |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 306 | CALLOC_ARRAY(ci, 1); |
Elijah Newren | 25c3936 | 2010-09-20 02:28:53 -0600 | [diff] [blame] | 307 | ci->rename_type = rename_type; |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 308 | ci->ren1 = ren1; |
| 309 | ci->ren2 = ren2; |
Elijah Newren | 25c3936 | 2010-09-20 02:28:53 -0600 | [diff] [blame] | 310 | |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 311 | ci->ren1->dst_entry->processed = 0; |
| 312 | ci->ren1->dst_entry->rename_conflict_info = ci; |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 313 | if (ren2) { |
| 314 | ci->ren2->dst_entry->rename_conflict_info = ci; |
Elijah Newren | 25c3936 | 2010-09-20 02:28:53 -0600 | [diff] [blame] | 315 | } |
| 316 | } |
| 317 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 318 | static int show(struct merge_options *opt, int v) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 319 | { |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 320 | return (!opt->priv->call_depth && opt->verbosity >= v) || |
| 321 | opt->verbosity >= 5; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 322 | } |
| 323 | |
Tarmigan Casebolt | 28bea9e | 2009-11-14 13:33:13 -0800 | [diff] [blame] | 324 | __attribute__((format (printf, 3, 4))) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 325 | static void output(struct merge_options *opt, int v, const char *fmt, ...) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 326 | { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 327 | va_list ap; |
| 328 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 329 | if (!show(opt, v)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 330 | return; |
| 331 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 332 | strbuf_addchars(&opt->obuf, ' ', opt->priv->call_depth * 2); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 333 | |
| 334 | va_start(ap, fmt); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 335 | strbuf_vaddf(&opt->obuf, fmt, ap); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 336 | va_end(ap); |
| 337 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 338 | strbuf_addch(&opt->obuf, '\n'); |
| 339 | if (!opt->buffer_output) |
| 340 | flush_output(opt); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 341 | } |
| 342 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 343 | static void output_commit_title(struct merge_options *opt, struct commit *commit) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 344 | { |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 345 | struct merge_remote_desc *desc; |
| 346 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 347 | strbuf_addchars(&opt->obuf, ' ', opt->priv->call_depth * 2); |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 348 | desc = merge_remote_util(commit); |
| 349 | if (desc) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 350 | strbuf_addf(&opt->obuf, "virtual %s\n", desc->name); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 351 | else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 352 | strbuf_add_unique_abbrev(&opt->obuf, &commit->object.oid, |
René Scharfe | a94bb68 | 2016-10-08 17:38:47 +0200 | [diff] [blame] | 353 | DEFAULT_ABBREV); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 354 | strbuf_addch(&opt->obuf, ' '); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 355 | if (parse_commit(commit) != 0) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 356 | strbuf_addstr(&opt->obuf, _("(bad commit)\n")); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 357 | else { |
Christian Couder | 49b7120 | 2010-07-22 15:18:34 +0200 | [diff] [blame] | 358 | const char *title; |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 359 | const char *msg = get_commit_buffer(commit, NULL); |
Jeff King | bc6b8fc | 2014-06-10 17:41:51 -0400 | [diff] [blame] | 360 | int len = find_commit_subject(msg, &title); |
Christian Couder | 49b7120 | 2010-07-22 15:18:34 +0200 | [diff] [blame] | 361 | if (len) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 362 | strbuf_addf(&opt->obuf, "%.*s\n", len, title); |
Jeff King | bc6b8fc | 2014-06-10 17:41:51 -0400 | [diff] [blame] | 363 | unuse_commit_buffer(commit, msg); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 364 | } |
| 365 | } |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 366 | flush_output(opt); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 367 | } |
| 368 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 369 | static int add_cacheinfo(struct merge_options *opt, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 370 | const struct diff_filespec *blob, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 371 | const char *path, int stage, int refresh, int options) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 372 | { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 373 | struct index_state *istate = opt->repo->index; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 374 | struct cache_entry *ce; |
Junio C Hamano | 1335d76 | 2016-07-08 10:59:15 -0700 | [diff] [blame] | 375 | int ret; |
| 376 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 377 | ce = make_cache_entry(istate, blob->mode, &blob->oid, path, stage, 0); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 378 | if (!ce) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 379 | return err(opt, _("add_cacheinfo failed for path '%s'; merge aborting."), path); |
Junio C Hamano | 1335d76 | 2016-07-08 10:59:15 -0700 | [diff] [blame] | 380 | |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 381 | ret = add_index_entry(istate, ce, options); |
Junio C Hamano | 1335d76 | 2016-07-08 10:59:15 -0700 | [diff] [blame] | 382 | if (refresh) { |
| 383 | struct cache_entry *nce; |
| 384 | |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 385 | nce = refresh_cache_entry(istate, ce, |
| 386 | CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); |
Johannes Schindelin | 55e9f0e | 2016-11-26 13:48:06 +0100 | [diff] [blame] | 387 | if (!nce) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 388 | return err(opt, _("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); |
Junio C Hamano | 1335d76 | 2016-07-08 10:59:15 -0700 | [diff] [blame] | 389 | if (nce != ce) |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 390 | ret = add_index_entry(istate, nce, options); |
Junio C Hamano | 1335d76 | 2016-07-08 10:59:15 -0700 | [diff] [blame] | 391 | } |
| 392 | return ret; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 393 | } |
| 394 | |
Elijah Newren | 7c0a6c8 | 2019-08-17 11:41:37 -0700 | [diff] [blame] | 395 | static inline int merge_detect_rename(struct merge_options *opt) |
| 396 | { |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 397 | return (opt->detect_renames >= 0) ? opt->detect_renames : 1; |
Elijah Newren | 7c0a6c8 | 2019-08-17 11:41:37 -0700 | [diff] [blame] | 398 | } |
| 399 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 400 | static 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 406 | static int unpack_trees_start(struct merge_options *opt, |
Elijah Newren | 3f1c1c3 | 2018-05-20 12:17:35 +0200 | [diff] [blame] | 407 | struct tree *common, |
| 408 | struct tree *head, |
| 409 | struct tree *merge) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 410 | { |
| 411 | int rc; |
| 412 | struct tree_desc t[3]; |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 413 | struct index_state tmp_index = { NULL }; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 414 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 415 | 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 418 | else |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 419 | 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 427 | |
| 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 Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 432 | rc = unpack_trees(3, t, &opt->priv->unpack_opts); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 433 | cache_tree_free(&opt->repo->index->cache_tree); |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 434 | |
| 435 | /* |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 436 | * 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 Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 440 | */ |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 441 | opt->priv->orig_index = *opt->repo->index; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 442 | *opt->repo->index = tmp_index; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 443 | opt->priv->unpack_opts.src_index = &opt->priv->orig_index; |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 444 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 445 | return rc; |
| 446 | } |
| 447 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 448 | static void unpack_trees_finish(struct merge_options *opt) |
Elijah Newren | 3f1c1c3 | 2018-05-20 12:17:35 +0200 | [diff] [blame] | 449 | { |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 450 | discard_index(&opt->priv->orig_index); |
| 451 | clear_unpack_trees_porcelain(&opt->priv->unpack_opts); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 452 | } |
| 453 | |
brian m. carlson | df46d77 | 2018-03-12 02:27:26 +0000 | [diff] [blame] | 454 | static int save_files_dirs(const struct object_id *oid, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 455 | struct strbuf *base, const char *path, |
Ævar Arnfjörð Bjarmason | 4795748 | 2021-03-20 23:37:51 +0100 | [diff] [blame] | 456 | unsigned int mode, void *context) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 457 | { |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 458 | struct path_hashmap_entry *entry; |
Nguyễn Thái Ngọc Duy | 6a0b0b6 | 2014-11-30 16:05:00 +0700 | [diff] [blame] | 459 | int baselen = base->len; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 460 | struct merge_options *opt = context; |
Miklos Vajna | 696ee23 | 2008-09-03 19:08:56 +0200 | [diff] [blame] | 461 | |
Nguyễn Thái Ngọc Duy | 6a0b0b6 | 2014-11-30 16:05:00 +0700 | [diff] [blame] | 462 | strbuf_addstr(base, path); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 463 | |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 464 | FLEX_ALLOC_MEM(entry, path, base->buf, base->len); |
Eric Wong | d22245a | 2019-10-06 23:30:27 +0000 | [diff] [blame] | 465 | hashmap_entry_init(&entry->e, path_hash(entry->path)); |
Junio C Hamano | 5efabc7 | 2019-10-15 13:48:01 +0900 | [diff] [blame] | 466 | hashmap_add(&opt->priv->current_file_dir_set, &entry->e); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 467 | |
Nguyễn Thái Ngọc Duy | 6a0b0b6 | 2014-11-30 16:05:00 +0700 | [diff] [blame] | 468 | strbuf_setlen(base, baselen); |
Lars Hjemli | d3bee16 | 2009-01-25 01:52:05 +0100 | [diff] [blame] | 469 | return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 470 | } |
| 471 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 472 | static void get_files_dirs(struct merge_options *opt, struct tree *tree) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 473 | { |
Nguyễn Thái Ngọc Duy | f0096c0 | 2011-03-25 16:34:19 +0700 | [diff] [blame] | 474 | struct pathspec match_all; |
Nguyễn Thái Ngọc Duy | 9a08727 | 2013-07-14 15:35:59 +0700 | [diff] [blame] | 475 | memset(&match_all, 0, sizeof(match_all)); |
Ævar Arnfjörð Bjarmason | 4795748 | 2021-03-20 23:37:51 +0100 | [diff] [blame] | 476 | read_tree(opt->repo, tree, |
| 477 | &match_all, save_files_dirs, opt); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 478 | } |
| 479 | |
Nguyễn Thái Ngọc Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 480 | static int get_tree_entry_if_blob(struct repository *r, |
| 481 | const struct object_id *tree, |
Elijah Newren | 5b047ac | 2018-04-19 10:58:09 -0700 | [diff] [blame] | 482 | const char *path, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 483 | struct diff_filespec *dfs) |
Elijah Newren | 5b047ac | 2018-04-19 10:58:09 -0700 | [diff] [blame] | 484 | { |
| 485 | int ret; |
| 486 | |
Nguyễn Thái Ngọc Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 487 | ret = get_tree_entry(r, tree, path, &dfs->oid, &dfs->mode); |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 488 | if (S_ISDIR(dfs->mode)) { |
brian m. carlson | 1422844 | 2021-04-26 01:02:56 +0000 | [diff] [blame] | 489 | oidcpy(&dfs->oid, null_oid()); |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 490 | dfs->mode = 0; |
Elijah Newren | 5b047ac | 2018-04-19 10:58:09 -0700 | [diff] [blame] | 491 | } |
| 492 | return ret; |
| 493 | } |
| 494 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 495 | /* |
| 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 Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 499 | static struct stage_data *insert_stage_data(struct repository *r, |
| 500 | const char *path, |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 501 | 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 Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 506 | 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 Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 509 | item = string_list_insert(entries, path); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 510 | 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 Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 518 | static struct string_list *get_unmerged(struct index_state *istate) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 519 | { |
| 520 | struct string_list *unmerged = xcalloc(1, sizeof(struct string_list)); |
| 521 | int i; |
| 522 | |
| 523 | unmerged->strdup_strings = 1; |
| 524 | |
Derrick Stolee | f7ef64b | 2021-04-01 01:49:56 +0000 | [diff] [blame] | 525 | /* TODO: audit for interaction with sparse-index. */ |
| 526 | ensure_full_index(istate); |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 527 | for (i = 0; i < istate->cache_nr; i++) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 528 | struct string_list_item *item; |
| 529 | struct stage_data *e; |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 530 | const struct cache_entry *ce = istate->cache[i]; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 531 | if (!ce_stage(ce)) |
| 532 | continue; |
| 533 | |
Julian Phillips | e8c8b71 | 2010-06-26 00:41:37 +0100 | [diff] [blame] | 534 | item = string_list_lookup(unmerged, ce->name); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 535 | if (!item) { |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 536 | item = string_list_insert(unmerged, ce->name); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 537 | 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. carlson | 99d1a98 | 2016-09-05 20:07:52 +0000 | [diff] [blame] | 541 | oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 542 | } |
| 543 | |
| 544 | return unmerged; |
| 545 | } |
| 546 | |
Nguyễn Thái Ngọc Duy | fa6ca11 | 2016-11-24 18:45:36 +0700 | [diff] [blame] | 547 | static int string_list_df_name_compare(const char *one, const char *two) |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 548 | { |
Nguyễn Thái Ngọc Duy | fa6ca11 | 2016-11-24 18:45:36 +0700 | [diff] [blame] | 549 | int onelen = strlen(one); |
| 550 | int twolen = strlen(two); |
Elijah Newren | f0fd4d0 | 2011-08-11 23:19:56 -0600 | [diff] [blame] | 551 | /* |
| 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 Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 556 | * |
Elijah Newren | f0fd4d0 | 2011-08-11 23:19:56 -0600 | [diff] [blame] | 557 | * 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 Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 562 | */ |
Nguyễn Thái Ngọc Duy | fa6ca11 | 2016-11-24 18:45:36 +0700 | [diff] [blame] | 563 | int cmp = df_name_compare(one, onelen, S_IFDIR, |
| 564 | two, twolen, S_IFDIR); |
Elijah Newren | f0fd4d0 | 2011-08-11 23:19:56 -0600 | [diff] [blame] | 565 | /* |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 574 | static void record_df_conflict_files(struct merge_options *opt, |
Elijah Newren | 70cc3d3 | 2011-08-11 23:19:58 -0600 | [diff] [blame] | 575 | struct string_list *entries) |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 576 | { |
Elijah Newren | 70cc3d3 | 2011-08-11 23:19:58 -0600 | [diff] [blame] | 577 | /* If there is a D/F conflict and the file for such a conflict |
Elijah Newren | 2d6bad9 | 2018-06-09 21:16:11 -0700 | [diff] [blame] | 578 | * currently exists in the working tree, we want to allow it to be |
Elijah Newren | edd2faf | 2011-08-11 23:20:07 -0600 | [diff] [blame] | 579 | * 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 Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 589 | */ |
René Scharfe | af4941d | 2016-08-05 22:42:12 +0200 | [diff] [blame] | 590 | struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 591 | const char *last_file = NULL; |
Junio C Hamano | c851650 | 2010-10-21 07:34:33 -0700 | [diff] [blame] | 592 | int last_len = 0; |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 593 | int i; |
| 594 | |
Elijah Newren | 0b30e81 | 2011-08-11 23:19:54 -0600 | [diff] [blame] | 595 | /* |
| 596 | * If we're merging merge-bases, we don't want to bother with |
| 597 | * any working directory changes. |
| 598 | */ |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 599 | if (opt->priv->call_depth) |
Elijah Newren | 0b30e81 | 2011-08-11 23:19:54 -0600 | [diff] [blame] | 600 | return; |
| 601 | |
Elijah Newren | f0fd4d0 | 2011-08-11 23:19:56 -0600 | [diff] [blame] | 602 | /* Ensure D/F conflicts are adjacent in the entries list. */ |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 603 | for (i = 0; i < entries->nr; i++) { |
Elijah Newren | f701aae | 2011-08-12 20:23:51 -0600 | [diff] [blame] | 604 | 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 Duy | fa6ca11 | 2016-11-24 18:45:36 +0700 | [diff] [blame] | 608 | df_sorted_entries.cmp = string_list_df_name_compare; |
| 609 | string_list_sort(&df_sorted_entries); |
Elijah Newren | f0fd4d0 | 2011-08-11 23:19:56 -0600 | [diff] [blame] | 610 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 611 | string_list_clear(&opt->priv->df_conflict_file_set, 1); |
Elijah Newren | f701aae | 2011-08-12 20:23:51 -0600 | [diff] [blame] | 612 | for (i = 0; i < df_sorted_entries.nr; i++) { |
| 613 | const char *path = df_sorted_entries.items[i].string; |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 614 | int len = strlen(path); |
Elijah Newren | f701aae | 2011-08-12 20:23:51 -0600 | [diff] [blame] | 615 | struct stage_data *e = df_sorted_entries.items[i].util; |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 616 | |
| 617 | /* |
| 618 | * Check if last_file & path correspond to a D/F conflict; |
| 619 | * i.e. whether path is last_file+'/'+<something>. |
Elijah Newren | 70cc3d3 | 2011-08-11 23:19:58 -0600 | [diff] [blame] | 620 | * If so, record that it's okay to remove last_file to make |
| 621 | * room for path and friends if needed. |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 622 | */ |
| 623 | if (last_file && |
| 624 | len > last_len && |
| 625 | memcmp(path, last_file, last_len) == 0 && |
| 626 | path[last_len] == '/') { |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 627 | string_list_insert(&opt->priv->df_conflict_file_set, last_file); |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 628 | } |
| 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 Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 639 | } else { |
| 640 | last_file = NULL; |
| 641 | } |
| 642 | } |
Elijah Newren | f701aae | 2011-08-12 20:23:51 -0600 | [diff] [blame] | 643 | string_list_clear(&df_sorted_entries, 0); |
Elijah Newren | ef02b31 | 2010-09-20 02:29:09 -0600 | [diff] [blame] | 644 | } |
| 645 | |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 646 | static int update_stages(struct merge_options *opt, const char *path, |
| 647 | const struct diff_filespec *o, |
Elijah Newren | 650467c | 2011-08-11 23:19:52 -0600 | [diff] [blame] | 648 | const struct diff_filespec *a, |
| 649 | const struct diff_filespec *b) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 650 | { |
Elijah Newren | f53d397 | 2011-08-11 23:20:25 -0600 | [diff] [blame] | 651 | |
| 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 Newren | 650467c | 2011-08-11 23:19:52 -0600 | [diff] [blame] | 660 | int clear = 1; |
| 661 | int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 662 | if (clear) |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 663 | if (remove_file_from_index(opt->repo->index, path)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 664 | return -1; |
| 665 | if (o) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 666 | if (add_cacheinfo(opt, o, path, 1, 0, options)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 667 | return -1; |
| 668 | if (a) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 669 | if (add_cacheinfo(opt, a, path, 2, 0, options)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 670 | return -1; |
| 671 | if (b) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 672 | if (add_cacheinfo(opt, b, path, 3, 0, options)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 673 | return -1; |
| 674 | return 0; |
| 675 | } |
| 676 | |
Elijah Newren | b8ddf16 | 2011-08-11 23:20:02 -0600 | [diff] [blame] | 677 | static void update_entry(struct stage_data *entry, |
| 678 | struct diff_filespec *o, |
| 679 | struct diff_filespec *a, |
| 680 | struct diff_filespec *b) |
Elijah Newren | 2ff739f | 2010-09-20 02:28:54 -0600 | [diff] [blame] | 681 | { |
Elijah Newren | 2ff739f | 2010-09-20 02:28:54 -0600 | [diff] [blame] | 682 | 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. carlson | fd429e9 | 2016-06-24 23:09:25 +0000 | [diff] [blame] | 686 | oidcpy(&entry->stages[1].oid, &o->oid); |
| 687 | oidcpy(&entry->stages[2].oid, &a->oid); |
| 688 | oidcpy(&entry->stages[3].oid, &b->oid); |
Elijah Newren | 2ff739f | 2010-09-20 02:28:54 -0600 | [diff] [blame] | 689 | } |
| 690 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 691 | static int remove_file(struct merge_options *opt, int clean, |
Miklos Vajna | b7fa51d | 2008-09-02 23:53:47 +0200 | [diff] [blame] | 692 | const char *path, int no_wd) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 693 | { |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 694 | int update_cache = opt->priv->call_depth || clean; |
| 695 | int update_working_directory = !opt->priv->call_depth && !no_wd; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 696 | |
| 697 | if (update_cache) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 698 | if (remove_file_from_index(opt->repo->index, path)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 699 | return -1; |
| 700 | } |
| 701 | if (update_working_directory) { |
David Turner | ae352c7 | 2014-05-01 20:21:09 -0400 | [diff] [blame] | 702 | if (ignore_case) { |
| 703 | struct cache_entry *ce; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 704 | ce = index_file_exists(opt->repo->index, path, strlen(path), |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 705 | ignore_case); |
Elijah Newren | 4cba2b0 | 2017-11-24 11:59:01 -0800 | [diff] [blame] | 706 | if (ce && ce_stage(ce) == 0 && strcmp(path, ce->name)) |
David Turner | ae352c7 | 2014-05-01 20:21:09 -0400 | [diff] [blame] | 707 | return 0; |
| 708 | } |
Peter Collingbourne | 25755e8 | 2010-03-26 15:25:35 +0000 | [diff] [blame] | 709 | if (remove_path(path)) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 710 | return -1; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 711 | } |
| 712 | return 0; |
| 713 | } |
| 714 | |
Jeff King | 45bc131 | 2014-06-19 17:30:26 -0400 | [diff] [blame] | 715 | /* add a string to a strbuf, but converting "/" to "_" */ |
| 716 | static 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 Newren | 4d7101e | 2019-08-17 11:41:33 -0700 | [diff] [blame] | 725 | static char *unique_path(struct merge_options *opt, |
| 726 | const char *path, |
| 727 | const char *branch) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 728 | { |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 729 | struct path_hashmap_entry *entry; |
Jeff King | 45bc131 | 2014-06-19 17:30:26 -0400 | [diff] [blame] | 730 | struct strbuf newpath = STRBUF_INIT; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 731 | int suffix = 0; |
Jeff King | 45bc131 | 2014-06-19 17:30:26 -0400 | [diff] [blame] | 732 | size_t base_len; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 733 | |
Jeff King | 45bc131 | 2014-06-19 17:30:26 -0400 | [diff] [blame] | 734 | strbuf_addf(&newpath, "%s~", path); |
| 735 | add_flattened_path(&newpath, branch); |
| 736 | |
| 737 | base_len = newpath.len; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 738 | while (hashmap_get_from_hash(&opt->priv->current_file_dir_set, |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 739 | path_hash(newpath.buf), newpath.buf) || |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 740 | (!opt->priv->call_depth && file_exists(newpath.buf))) { |
Jeff King | 45bc131 | 2014-06-19 17:30:26 -0400 | [diff] [blame] | 741 | strbuf_setlen(&newpath, base_len); |
| 742 | strbuf_addf(&newpath, "_%d", suffix++); |
| 743 | } |
| 744 | |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 745 | FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); |
Eric Wong | d22245a | 2019-10-06 23:30:27 +0000 | [diff] [blame] | 746 | hashmap_entry_init(&entry->e, path_hash(entry->path)); |
Junio C Hamano | 5efabc7 | 2019-10-15 13:48:01 +0900 | [diff] [blame] | 747 | hashmap_add(&opt->priv->current_file_dir_set, &entry->e); |
Jeff King | 45bc131 | 2014-06-19 17:30:26 -0400 | [diff] [blame] | 748 | return strbuf_detach(&newpath, NULL); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 749 | } |
| 750 | |
David Turner | 5423d2e | 2016-11-07 13:31:31 -0500 | [diff] [blame] | 751 | /** |
| 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 Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 757 | static int dir_in_way(struct index_state *istate, const char *path, |
| 758 | int check_working_copy, int empty_ok) |
Elijah Newren | f2507b4 | 2011-08-11 23:19:57 -0600 | [diff] [blame] | 759 | { |
Jeff King | b4600fb | 2015-09-24 17:07:43 -0400 | [diff] [blame] | 760 | int pos; |
| 761 | struct strbuf dirpath = STRBUF_INIT; |
Elijah Newren | f2507b4 | 2011-08-11 23:19:57 -0600 | [diff] [blame] | 762 | struct stat st; |
| 763 | |
Jeff King | b4600fb | 2015-09-24 17:07:43 -0400 | [diff] [blame] | 764 | strbuf_addstr(&dirpath, path); |
| 765 | strbuf_addch(&dirpath, '/'); |
Elijah Newren | f2507b4 | 2011-08-11 23:19:57 -0600 | [diff] [blame] | 766 | |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 767 | pos = index_name_pos(istate, dirpath.buf, dirpath.len); |
Elijah Newren | f2507b4 | 2011-08-11 23:19:57 -0600 | [diff] [blame] | 768 | |
| 769 | if (pos < 0) |
| 770 | pos = -1 - pos; |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 771 | if (pos < istate->cache_nr && |
| 772 | !strncmp(dirpath.buf, istate->cache[pos]->name, dirpath.len)) { |
Jeff King | b4600fb | 2015-09-24 17:07:43 -0400 | [diff] [blame] | 773 | strbuf_release(&dirpath); |
Elijah Newren | f2507b4 | 2011-08-11 23:19:57 -0600 | [diff] [blame] | 774 | return 1; |
| 775 | } |
| 776 | |
Jeff King | b4600fb | 2015-09-24 17:07:43 -0400 | [diff] [blame] | 777 | strbuf_release(&dirpath); |
David Turner | 5423d2e | 2016-11-07 13:31:31 -0500 | [diff] [blame] | 778 | return check_working_copy && !lstat(path, &st) && S_ISDIR(st.st_mode) && |
Jonathan Tan | 83e3ad3 | 2019-09-18 13:27:38 -0700 | [diff] [blame] | 779 | !(empty_ok && is_empty_dir(path)) && |
| 780 | !has_symlink_leading_path(path, strlen(path)); |
Elijah Newren | f2507b4 | 2011-08-11 23:19:57 -0600 | [diff] [blame] | 781 | } |
| 782 | |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 783 | /* |
Elijah Newren | 1de70db | 2018-04-19 10:58:23 -0700 | [diff] [blame] | 784 | * Returns whether path was tracked in the index before the merge started, |
| 785 | * and its oid and mode match the specified values |
| 786 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 787 | static int was_tracked_and_matches(struct merge_options *opt, const char *path, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 788 | const struct diff_filespec *blob) |
Junio C Hamano | 60c9118 | 2008-12-15 02:41:24 -0800 | [diff] [blame] | 789 | { |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 790 | int pos = index_name_pos(&opt->priv->orig_index, path, strlen(path)); |
Elijah Newren | 1de70db | 2018-04-19 10:58:23 -0700 | [diff] [blame] | 791 | 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 Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 798 | ce = opt->priv->orig_index.cache[pos]; |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 799 | return (oideq(&ce->oid, &blob->oid) && ce->ce_mode == blob->mode); |
Elijah Newren | 1de70db | 2018-04-19 10:58:23 -0700 | [diff] [blame] | 800 | } |
| 801 | |
| 802 | /* |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 803 | * Returns whether path was tracked in the index before the merge started |
| 804 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 805 | static int was_tracked(struct merge_options *opt, const char *path) |
Junio C Hamano | 60c9118 | 2008-12-15 02:41:24 -0800 | [diff] [blame] | 806 | { |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 807 | int pos = index_name_pos(&opt->priv->orig_index, path, strlen(path)); |
Junio C Hamano | 60c9118 | 2008-12-15 02:41:24 -0800 | [diff] [blame] | 808 | |
Johannes Schindelin | f8d83fb | 2016-07-26 18:05:57 +0200 | [diff] [blame] | 809 | if (0 <= pos) |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 810 | /* we were tracking this path before the merge */ |
Johannes Schindelin | f8d83fb | 2016-07-26 18:05:57 +0200 | [diff] [blame] | 811 | return 1; |
| 812 | |
Elijah Newren | aacb82d | 2011-08-11 23:19:59 -0600 | [diff] [blame] | 813 | return 0; |
Junio C Hamano | 60c9118 | 2008-12-15 02:41:24 -0800 | [diff] [blame] | 814 | } |
| 815 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 816 | static int would_lose_untracked(struct merge_options *opt, const char *path) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 817 | { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 818 | struct index_state *istate = opt->repo->index; |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 819 | |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 820 | /* |
| 821 | * This may look like it can be simplified to: |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 822 | * return !was_tracked(opt, path) && file_exists(path) |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 823 | * 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 Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 837 | int pos = index_name_pos(istate, path, strlen(path)); |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 838 | |
| 839 | if (pos < 0) |
| 840 | pos = -1 - pos; |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 841 | while (pos < istate->cache_nr && |
| 842 | !strcmp(path, istate->cache[pos]->name)) { |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 843 | /* |
| 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 Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 849 | switch (ce_stage(istate->cache[pos])) { |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 850 | case 0: |
| 851 | case 2: |
| 852 | return 0; |
| 853 | } |
| 854 | pos++; |
| 855 | } |
| 856 | return file_exists(path); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 857 | } |
| 858 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 859 | static int was_dirty(struct merge_options *opt, const char *path) |
Elijah Newren | 64b1abe | 2018-04-19 10:58:12 -0700 | [diff] [blame] | 860 | { |
| 861 | struct cache_entry *ce; |
| 862 | int dirty = 1; |
| 863 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 864 | if (opt->priv->call_depth || !was_tracked(opt, path)) |
Elijah Newren | 64b1abe | 2018-04-19 10:58:12 -0700 | [diff] [blame] | 865 | return !dirty; |
| 866 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 867 | ce = index_file_exists(opt->priv->unpack_opts.src_index, |
Elijah Newren | 277292d | 2018-04-19 10:58:21 -0700 | [diff] [blame] | 868 | path, strlen(path), ignore_case); |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 869 | dirty = verify_uptodate(ce, &opt->priv->unpack_opts) != 0; |
Elijah Newren | 64b1abe | 2018-04-19 10:58:12 -0700 | [diff] [blame] | 870 | return dirty; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 871 | } |
| 872 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 873 | static int make_room_for_path(struct merge_options *opt, const char *path) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 874 | { |
Elijah Newren | ed0148a | 2011-08-11 23:20:01 -0600 | [diff] [blame] | 875 | int status, i; |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 876 | const char *msg = _("failed to create path '%s'%s"); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 877 | |
Elijah Newren | ed0148a | 2011-08-11 23:20:01 -0600 | [diff] [blame] | 878 | /* Unlink any D/F conflict files that are in the way */ |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 879 | 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 Newren | ed0148a | 2011-08-11 23:20:01 -0600 | [diff] [blame] | 881 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 886 | output(opt, 3, |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 887 | _("Removing %s to make room for subdirectory\n"), |
Elijah Newren | ed0148a | 2011-08-11 23:20:01 -0600 | [diff] [blame] | 888 | df_path); |
| 889 | unlink(df_path); |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 890 | unsorted_string_list_delete_item(&opt->priv->df_conflict_file_set, |
Elijah Newren | ed0148a | 2011-08-11 23:20:01 -0600 | [diff] [blame] | 891 | i, 0); |
| 892 | break; |
| 893 | } |
| 894 | } |
| 895 | |
| 896 | /* Make sure leading directories are created */ |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 897 | status = safe_create_leading_directories_const(path); |
| 898 | if (status) { |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 899 | if (status == SCLD_EXISTS) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 900 | /* something else exists */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 901 | return err(opt, msg, path, _(": perhaps a D/F conflict?")); |
| 902 | return err(opt, msg, path, ""); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 903 | } |
| 904 | |
Junio C Hamano | 60c9118 | 2008-12-15 02:41:24 -0800 | [diff] [blame] | 905 | /* |
| 906 | * Do not unlink a file in the work tree if we are not |
| 907 | * tracking it. |
| 908 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 909 | if (would_lose_untracked(opt, path)) |
| 910 | return err(opt, _("refusing to lose untracked file at '%s'"), |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 911 | path); |
Junio C Hamano | 60c9118 | 2008-12-15 02:41:24 -0800 | [diff] [blame] | 912 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 913 | /* 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 920 | return err(opt, msg, path, _(": perhaps a D/F conflict?")); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 921 | } |
| 922 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 923 | static int update_file_flags(struct merge_options *opt, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 924 | const struct diff_filespec *contents, |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 925 | const char *path, |
| 926 | int update_cache, |
| 927 | int update_wd) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 928 | { |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 929 | int ret = 0; |
| 930 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 931 | if (opt->priv->call_depth) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 932 | update_wd = 0; |
| 933 | |
| 934 | if (update_wd) { |
| 935 | enum object_type type; |
| 936 | void *buf; |
| 937 | unsigned long size; |
| 938 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 939 | if (S_ISGITLINK(contents->mode)) { |
Junio C Hamano | 0c44c94 | 2009-04-29 11:08:18 -0700 | [diff] [blame] | 940 | /* |
| 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 Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 945 | update_wd = 0; |
Junio C Hamano | 0c44c94 | 2009-04-29 11:08:18 -0700 | [diff] [blame] | 946 | goto update_index; |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 947 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 948 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 949 | buf = read_object_file(&contents->oid, &type, &size); |
Elijah Newren | f836bf3 | 2019-08-17 11:41:26 -0700 | [diff] [blame] | 950 | if (!buf) { |
| 951 | ret = err(opt, _("cannot read object %s '%s'"), |
| 952 | oid_to_hex(&contents->oid), path); |
| 953 | goto free_buf; |
| 954 | } |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 955 | if (type != OBJ_BLOB) { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 956 | ret = err(opt, _("blob expected for %s '%s'"), |
| 957 | oid_to_hex(&contents->oid), path); |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 958 | goto free_buf; |
| 959 | } |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 960 | if (S_ISREG(contents->mode)) { |
Brandon Casey | f285a2d | 2008-10-09 14:12:12 -0500 | [diff] [blame] | 961 | struct strbuf strbuf = STRBUF_INIT; |
Elijah Newren | 4d7101e | 2019-08-17 11:41:33 -0700 | [diff] [blame] | 962 | if (convert_to_working_tree(opt->repo->index, |
brian m. carlson | ab90eca | 2020-03-16 18:05:02 +0000 | [diff] [blame] | 963 | path, buf, size, &strbuf, NULL)) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 964 | free(buf); |
| 965 | size = strbuf.len; |
| 966 | buf = strbuf_detach(&strbuf, NULL); |
| 967 | } |
| 968 | } |
| 969 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 970 | if (make_room_for_path(opt, path) < 0) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 971 | update_wd = 0; |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 972 | goto free_buf; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 973 | } |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 974 | if (S_ISREG(contents->mode) || |
| 975 | (!has_symlinks && S_ISLNK(contents->mode))) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 976 | int fd; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 977 | int mode = (contents->mode & 0100 ? 0777 : 0666); |
| 978 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 979 | fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 980 | if (fd < 0) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 981 | ret = err(opt, _("failed to open '%s': %s"), |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 982 | path, strerror(errno)); |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 983 | goto free_buf; |
| 984 | } |
Thomas Rast | f633ea2 | 2012-08-03 14:16:25 +0200 | [diff] [blame] | 985 | write_in_full(fd, buf, size); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 986 | close(fd); |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 987 | } else if (S_ISLNK(contents->mode)) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 988 | char *lnk = xmemdupz(buf, size); |
| 989 | safe_create_leading_directories_const(path); |
| 990 | unlink(path); |
Alex Riesen | 304dcf2 | 2008-12-05 01:39:14 +0100 | [diff] [blame] | 991 | if (symlink(lnk, path)) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 992 | ret = err(opt, _("failed to symlink '%s': %s"), |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 993 | path, strerror(errno)); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 994 | free(lnk); |
| 995 | } else |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 996 | ret = err(opt, |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 997 | _("do not know what to do with %06o %s '%s'"), |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 998 | contents->mode, oid_to_hex(&contents->oid), path); |
Elijah Newren | 9366536 | 2018-06-09 21:16:13 -0700 | [diff] [blame] | 999 | free_buf: |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1000 | free(buf); |
| 1001 | } |
Elijah Newren | 9366536 | 2018-06-09 21:16:13 -0700 | [diff] [blame] | 1002 | update_index: |
Elijah Newren | fb1c18f | 2020-02-19 17:04:07 +0000 | [diff] [blame] | 1003 | 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 Newren | fd53b7ff | 2018-04-19 10:58:16 -0700 | [diff] [blame] | 1007 | ADD_CACHE_OK_TO_ADD)) |
| 1008 | return -1; |
Elijah Newren | fb1c18f | 2020-02-19 17:04:07 +0000 | [diff] [blame] | 1009 | } |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 1010 | return ret; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1011 | } |
| 1012 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1013 | static int update_file(struct merge_options *opt, |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1014 | int clean, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1015 | const struct diff_filespec *contents, |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1016 | const char *path) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1017 | { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1018 | return update_file_flags(opt, contents, path, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1019 | opt->priv->call_depth || clean, !opt->priv->call_depth); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1020 | } |
| 1021 | |
| 1022 | /* Low level file merging, update and removal */ |
| 1023 | |
Jonathan Nieder | 9cba13c | 2011-03-16 02:08:34 -0500 | [diff] [blame] | 1024 | struct merge_file_info { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1025 | struct diff_filespec blob; /* mostly use oid & mode; sometimes path */ |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1026 | unsigned clean:1, |
| 1027 | merge:1; |
| 1028 | }; |
| 1029 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1030 | static int merge_3way(struct merge_options *opt, |
Miklos Vajna | b7fa51d | 2008-09-02 23:53:47 +0200 | [diff] [blame] | 1031 | mmbuffer_t *result_buf, |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1032 | const struct diff_filespec *o, |
Elijah Newren | 0c05942 | 2011-08-11 23:19:51 -0600 | [diff] [blame] | 1033 | const struct diff_filespec *a, |
| 1034 | const struct diff_filespec *b, |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1035 | const char *branch1, |
Elijah Newren | b2a7942 | 2018-11-07 20:40:24 -0800 | [diff] [blame] | 1036 | const char *branch2, |
| 1037 | const int extra_marker_size) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1038 | { |
| 1039 | mmfile_t orig, src1, src2; |
Jonathan Nieder | 712516b | 2010-08-26 00:49:53 -0500 | [diff] [blame] | 1040 | struct ll_merge_options ll_opts = {0}; |
Elijah Newren | 139ef37 | 2019-08-15 14:40:32 -0700 | [diff] [blame] | 1041 | char *base, *name1, *name2; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1042 | int merge_status; |
Avery Pennarun | 8cc5b29 | 2009-11-25 21:23:55 -0500 | [diff] [blame] | 1043 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1044 | ll_opts.renormalize = opt->renormalize; |
Elijah Newren | b2a7942 | 2018-11-07 20:40:24 -0800 | [diff] [blame] | 1045 | ll_opts.extra_marker_size = extra_marker_size; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1046 | ll_opts.xdl_opts = opt->xdl_opts; |
Jonathan Nieder | 712516b | 2010-08-26 00:49:53 -0500 | [diff] [blame] | 1047 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1048 | if (opt->priv->call_depth) { |
Jonathan Nieder | 712516b | 2010-08-26 00:49:53 -0500 | [diff] [blame] | 1049 | ll_opts.virtual_ancestor = 1; |
| 1050 | ll_opts.variant = 0; |
| 1051 | } else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1052 | switch (opt->recursive_variant) { |
Elijah Newren | f3081da | 2019-08-17 11:41:42 -0700 | [diff] [blame] | 1053 | case MERGE_VARIANT_OURS: |
Jonathan Nieder | 712516b | 2010-08-26 00:49:53 -0500 | [diff] [blame] | 1054 | ll_opts.variant = XDL_MERGE_FAVOR_OURS; |
Avery Pennarun | 8cc5b29 | 2009-11-25 21:23:55 -0500 | [diff] [blame] | 1055 | break; |
Elijah Newren | f3081da | 2019-08-17 11:41:42 -0700 | [diff] [blame] | 1056 | case MERGE_VARIANT_THEIRS: |
Jonathan Nieder | 712516b | 2010-08-26 00:49:53 -0500 | [diff] [blame] | 1057 | ll_opts.variant = XDL_MERGE_FAVOR_THEIRS; |
Avery Pennarun | 8cc5b29 | 2009-11-25 21:23:55 -0500 | [diff] [blame] | 1058 | break; |
| 1059 | default: |
Jonathan Nieder | 712516b | 2010-08-26 00:49:53 -0500 | [diff] [blame] | 1060 | ll_opts.variant = 0; |
Avery Pennarun | 8cc5b29 | 2009-11-25 21:23:55 -0500 | [diff] [blame] | 1061 | break; |
| 1062 | } |
| 1063 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1064 | |
Elijah Newren | 139ef37 | 2019-08-15 14:40:32 -0700 | [diff] [blame] | 1065 | 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 Jones | 4e2d094 | 2012-09-04 18:31:14 +0100 | [diff] [blame] | 1068 | name1 = mkpathdup("%s:%s", branch1, a->path); |
| 1069 | name2 = mkpathdup("%s:%s", branch2, b->path); |
Martin Renold | 606475f | 2009-07-01 22:18:04 +0200 | [diff] [blame] | 1070 | } else { |
Elijah Newren | 139ef37 | 2019-08-15 14:40:32 -0700 | [diff] [blame] | 1071 | base = mkpathdup("%s", opt->ancestor); |
Ramsay Jones | 4e2d094 | 2012-09-04 18:31:14 +0100 | [diff] [blame] | 1072 | name1 = mkpathdup("%s", branch1); |
| 1073 | name2 = mkpathdup("%s", branch2); |
Martin Renold | 606475f | 2009-07-01 22:18:04 +0200 | [diff] [blame] | 1074 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1075 | |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1076 | read_mmblob(&orig, &o->oid); |
brian m. carlson | d449347 | 2016-09-05 20:08:02 +0000 | [diff] [blame] | 1077 | read_mmblob(&src1, &a->oid); |
| 1078 | read_mmblob(&src2, &b->oid); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1079 | |
Elijah Newren | 816147e | 2021-03-20 00:03:53 +0000 | [diff] [blame] | 1080 | /* |
| 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 Newren | 139ef37 | 2019-08-15 14:40:32 -0700 | [diff] [blame] | 1085 | merge_status = ll_merge(result_buf, a->path, &orig, base, |
Nguyễn Thái Ngọc Duy | 32eaa46 | 2018-09-21 17:57:27 +0200 | [diff] [blame] | 1086 | &src1, name1, &src2, name2, |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1087 | opt->repo->index, &ll_opts); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1088 | |
Elijah Newren | 139ef37 | 2019-08-15 14:40:32 -0700 | [diff] [blame] | 1089 | free(base); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1090 | 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 Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 1098 | static int find_first_merges(struct repository *repo, |
| 1099 | struct object_array *result, const char *path, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 1100 | struct commit *a, struct commit *b) |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1101 | { |
| 1102 | int i, j; |
| 1103 | struct object_array merges = OBJECT_ARRAY_INIT; |
| 1104 | struct commit *commit; |
| 1105 | int contains_another; |
| 1106 | |
brian m. carlson | db1ba2a | 2019-02-19 00:04:59 +0000 | [diff] [blame] | 1107 | char merged_revision[GIT_MAX_HEXSZ + 2]; |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1108 | 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 Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 1118 | oid_to_hex(&a->object.oid)); |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 1119 | repo_init_revisions(repo, &revs, NULL); |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1120 | 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 | |
| 1159 | static 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 Newren | 816147e | 2021-03-20 00:03:53 +0000 | [diff] [blame] | 1164 | /* FIXME: Merge this with output_commit_title() */ |
| 1165 | assert(!merge_remote_util(commit)); |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1166 | format_commit_message(commit, " %h: %m %s", &sb, &ctx); |
| 1167 | fprintf(stderr, "%s\n", sb.buf); |
| 1168 | strbuf_release(&sb); |
| 1169 | } |
| 1170 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1171 | static int is_valid(const struct diff_filespec *dfs) |
| 1172 | { |
| 1173 | return dfs->mode != 0 && !is_null_oid(&dfs->oid); |
| 1174 | } |
| 1175 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1176 | static int merge_submodule(struct merge_options *opt, |
Stefan Beller | 325f3a8 | 2018-05-15 13:00:29 -0700 | [diff] [blame] | 1177 | struct object_id *result, const char *path, |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1178 | const struct object_id *base, const struct object_id *a, |
Stefan Beller | 325f3a8 | 2018-05-15 13:00:29 -0700 | [diff] [blame] | 1179 | const struct object_id *b) |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1180 | { |
| 1181 | struct commit *commit_base, *commit_a, *commit_b; |
| 1182 | int parent_count; |
| 1183 | struct object_array merges; |
| 1184 | |
| 1185 | int i; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1186 | int search = !opt->priv->call_depth; |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1187 | |
| 1188 | /* store a in result in case we fail */ |
Elijah Newren | 816147e | 2021-03-20 00:03:53 +0000 | [diff] [blame] | 1189 | /* 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 Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1194 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1205 | output(opt, 1, _("Failed to merge submodule %s (not checked out)"), path); |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1206 | return 0; |
| 1207 | } |
| 1208 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1209 | 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 Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1213 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1219 | output(opt, 1, _("Failed to merge submodule %s (commits don't follow merge-base)"), path); |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1220 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1226 | 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 Middelschulte | 76f4212 | 2018-05-17 11:40:08 -0700 | [diff] [blame] | 1231 | else |
| 1232 | ; /* no output */ |
| 1233 | |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1234 | return 1; |
| 1235 | } |
| 1236 | if (in_merge_bases(commit_b, commit_a)) { |
| 1237 | oidcpy(result, a); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1238 | 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 Middelschulte | 76f4212 | 2018-05-17 11:40:08 -0700 | [diff] [blame] | 1243 | else |
| 1244 | ; /* no output */ |
| 1245 | |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1246 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1261 | parent_count = find_first_merges(opt->repo, &merges, path, |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 1262 | commit_a, commit_b); |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1263 | switch (parent_count) { |
| 1264 | case 0: |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1265 | output(opt, 1, _("Failed to merge submodule %s (merge following commits not found)"), path); |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1266 | break; |
| 1267 | |
| 1268 | case 1: |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1269 | 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 Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1271 | print_commit((struct commit *) merges.objects[0].item); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1272 | output(opt, 2, _( |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 1273 | "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 Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1279 | break; |
| 1280 | |
| 1281 | default: |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1282 | output(opt, 1, _("Failed to merge submodule %s (multiple merges found)"), path); |
Stefan Beller | 18cfc08 | 2018-05-15 13:00:28 -0700 | [diff] [blame] | 1283 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1291 | static int merge_mode_and_contents(struct merge_options *opt, |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1292 | const struct diff_filespec *o, |
Elijah Newren | d957355 | 2018-09-19 09:14:34 -0700 | [diff] [blame] | 1293 | const struct diff_filespec *a, |
| 1294 | const struct diff_filespec *b, |
| 1295 | const char *filename, |
| 1296 | const char *branch1, |
| 1297 | const char *branch2, |
Elijah Newren | b2a7942 | 2018-11-07 20:40:24 -0800 | [diff] [blame] | 1298 | const int extra_marker_size, |
Elijah Newren | d957355 | 2018-09-19 09:14:34 -0700 | [diff] [blame] | 1299 | struct merge_file_info *result) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1300 | { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1301 | if (opt->branch1 != branch1) { |
Elijah Newren | 4f44545 | 2018-10-16 13:19:48 -0700 | [diff] [blame] | 1302 | /* |
| 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 Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1307 | return merge_mode_and_contents(opt, o, b, a, |
Elijah Newren | 4f44545 | 2018-10-16 13:19:48 -0700 | [diff] [blame] | 1308 | filename, |
Elijah Newren | b2a7942 | 2018-11-07 20:40:24 -0800 | [diff] [blame] | 1309 | branch2, branch1, |
| 1310 | extra_marker_size, result); |
Elijah Newren | 4f44545 | 2018-10-16 13:19:48 -0700 | [diff] [blame] | 1311 | } |
| 1312 | |
Johannes Schindelin | 3c8a51e | 2016-07-26 18:06:10 +0200 | [diff] [blame] | 1313 | result->merge = 0; |
| 1314 | result->clean = 1; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1315 | |
| 1316 | if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) { |
Johannes Schindelin | 3c8a51e | 2016-07-26 18:06:10 +0200 | [diff] [blame] | 1317 | result->clean = 0; |
Elijah Newren | 816147e | 2021-03-20 00:03:53 +0000 | [diff] [blame] | 1318 | /* |
| 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1325 | if (S_ISREG(a->mode)) { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1326 | result->blob.mode = a->mode; |
| 1327 | oidcpy(&result->blob.oid, &a->oid); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1328 | } else { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1329 | result->blob.mode = b->mode; |
| 1330 | oidcpy(&result->blob.oid, &b->oid); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1331 | } |
| 1332 | } else { |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 1333 | if (!oideq(&a->oid, &o->oid) && !oideq(&b->oid, &o->oid)) |
Johannes Schindelin | 3c8a51e | 2016-07-26 18:06:10 +0200 | [diff] [blame] | 1334 | result->merge = 1; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1335 | |
| 1336 | /* |
| 1337 | * Merge modes |
| 1338 | */ |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1339 | if (a->mode == b->mode || a->mode == o->mode) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1340 | result->blob.mode = b->mode; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1341 | else { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1342 | result->blob.mode = a->mode; |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1343 | if (b->mode != o->mode) { |
Johannes Schindelin | 3c8a51e | 2016-07-26 18:06:10 +0200 | [diff] [blame] | 1344 | result->clean = 0; |
| 1345 | result->merge = 1; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1346 | } |
| 1347 | } |
| 1348 | |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 1349 | if (oideq(&a->oid, &b->oid) || oideq(&a->oid, &o->oid)) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1350 | oidcpy(&result->blob.oid, &b->oid); |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 1351 | else if (oideq(&b->oid, &o->oid)) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1352 | oidcpy(&result->blob.oid, &a->oid); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1353 | else if (S_ISREG(a->mode)) { |
| 1354 | mmbuffer_t result_buf; |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 1355 | int ret = 0, merge_status; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1356 | |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1357 | merge_status = merge_3way(opt, &result_buf, o, a, b, |
Elijah Newren | b2a7942 | 2018-11-07 20:40:24 -0800 | [diff] [blame] | 1358 | branch1, branch2, |
| 1359 | extra_marker_size); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1360 | |
| 1361 | if ((merge_status < 0) || !result_buf.ptr) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1362 | ret = err(opt, _("Failed to execute internal merge")); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1363 | |
Patryk Obara | a09c985 | 2018-01-28 01:13:19 +0100 | [diff] [blame] | 1364 | if (!ret && |
| 1365 | write_object_file(result_buf.ptr, result_buf.size, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1366 | blob_type, &result->blob.oid)) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1367 | ret = err(opt, _("Unable to add %s to database"), |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 1368 | a->path); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1369 | |
| 1370 | free(result_buf.ptr); |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 1371 | if (ret) |
| 1372 | return ret; |
Elijah Newren | 816147e | 2021-03-20 00:03:53 +0000 | [diff] [blame] | 1373 | /* FIXME: bug, what if modes didn't match? */ |
Johannes Schindelin | 3c8a51e | 2016-07-26 18:06:10 +0200 | [diff] [blame] | 1374 | result->clean = (merge_status == 0); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1375 | } else if (S_ISGITLINK(a->mode)) { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1376 | result->clean = merge_submodule(opt, &result->blob.oid, |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1377 | o->path, |
| 1378 | &o->oid, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 1379 | &a->oid, |
| 1380 | &b->oid); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1381 | } else if (S_ISLNK(a->mode)) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1382 | switch (opt->recursive_variant) { |
Elijah Newren | f3081da | 2019-08-17 11:41:42 -0700 | [diff] [blame] | 1383 | case MERGE_VARIANT_NORMAL: |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1384 | oidcpy(&result->blob.oid, &a->oid); |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 1385 | if (!oideq(&a->oid, &b->oid)) |
Junio C Hamano | fd48b46 | 2017-09-26 11:40:42 +0900 | [diff] [blame] | 1386 | result->clean = 0; |
| 1387 | break; |
Elijah Newren | f3081da | 2019-08-17 11:41:42 -0700 | [diff] [blame] | 1388 | case MERGE_VARIANT_OURS: |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1389 | oidcpy(&result->blob.oid, &a->oid); |
Junio C Hamano | fd48b46 | 2017-09-26 11:40:42 +0900 | [diff] [blame] | 1390 | break; |
Elijah Newren | f3081da | 2019-08-17 11:41:42 -0700 | [diff] [blame] | 1391 | case MERGE_VARIANT_THEIRS: |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1392 | oidcpy(&result->blob.oid, &b->oid); |
Junio C Hamano | fd48b46 | 2017-09-26 11:40:42 +0900 | [diff] [blame] | 1393 | break; |
| 1394 | } |
Johannes Schindelin | ef1177d1 | 2016-07-26 18:05:50 +0200 | [diff] [blame] | 1395 | } else |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 1396 | BUG("unsupported object type in the tree"); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1397 | } |
| 1398 | |
Elijah Newren | 05cf21e | 2018-04-19 10:58:22 -0700 | [diff] [blame] | 1399 | if (result->merge) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1400 | output(opt, 2, _("Auto-merging %s"), filename); |
Elijah Newren | 05cf21e | 2018-04-19 10:58:22 -0700 | [diff] [blame] | 1401 | |
Johannes Schindelin | 3c8a51e | 2016-07-26 18:06:10 +0200 | [diff] [blame] | 1402 | return 0; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1403 | } |
| 1404 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1405 | static int handle_rename_via_dir(struct merge_options *opt, |
Elijah Newren | e2d563d | 2019-04-05 08:00:21 -0700 | [diff] [blame] | 1406 | struct rename_conflict_info *ci) |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 1407 | { |
Elijah Newren | 5455c33 | 2018-06-09 21:16:14 -0700 | [diff] [blame] | 1408 | /* |
| 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 Newren | e2d563d | 2019-04-05 08:00:21 -0700 | [diff] [blame] | 1414 | const struct rename *ren = ci->ren1; |
| 1415 | const struct diff_filespec *dest = ren->pair->two; |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 1416 | char *file_path = dest->path; |
Derrick Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 1417 | int mark_conflicted = (opt->detect_directory_renames == |
| 1418 | MERGE_DIRECTORY_RENAMES_CONFLICT); |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 1419 | assert(ren->dir_rename_original_dest); |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 1420 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1421 | if (!opt->priv->call_depth && would_lose_untracked(opt, dest->path)) { |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 1422 | mark_conflicted = 1; |
| 1423 | file_path = unique_path(opt, dest->path, ren->branch); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1424 | output(opt, 1, _("Error: Refusing to lose untracked file at %s; " |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 1425 | "writing to %s instead."), |
| 1426 | dest->path, file_path); |
Elijah Newren | 79c4759 | 2018-04-19 10:58:11 -0700 | [diff] [blame] | 1427 | } |
| 1428 | |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 1429 | 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 Newren | 6bdaead | 2011-08-11 23:20:12 -0600 | [diff] [blame] | 1450 | } |
| 1451 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1452 | static int handle_change_delete(struct merge_options *opt, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 1453 | const char *path, const char *old_path, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1454 | const struct diff_filespec *o, |
| 1455 | const struct diff_filespec *changed, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 1456 | const char *change_branch, |
| 1457 | const char *delete_branch, |
| 1458 | const char *change, const char *change_past) |
Elijah Newren | b703325 | 2011-08-11 23:20:19 -0600 | [diff] [blame] | 1459 | { |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1460 | char *alt_path = NULL; |
| 1461 | const char *update_path = path; |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1462 | int ret = 0; |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1463 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1464 | if (dir_in_way(opt->repo->index, path, !opt->priv->call_depth, 0) || |
| 1465 | (!opt->priv->call_depth && would_lose_untracked(opt, path))) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1466 | update_path = alt_path = unique_path(opt, path, change_branch); |
Elijah Newren | b703325 | 2011-08-11 23:20:19 -0600 | [diff] [blame] | 1467 | } |
| 1468 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1469 | if (opt->priv->call_depth) { |
Elijah Newren | b703325 | 2011-08-11 23:20:19 -0600 | [diff] [blame] | 1470 | /* |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1475 | ret = remove_file_from_index(opt->repo->index, path); |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1476 | if (!ret) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1477 | ret = update_file(opt, 0, o, update_path); |
Elijah Newren | b703325 | 2011-08-11 23:20:19 -0600 | [diff] [blame] | 1478 | } else { |
Elijah Newren | 5b26c3c | 2018-06-09 21:16:16 -0700 | [diff] [blame] | 1479 | /* |
| 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 McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1494 | if (!alt_path) { |
| 1495 | if (!old_path) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1496 | output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s " |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1497 | "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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1501 | output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s " |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1502 | "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 Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 1506 | } else { |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1507 | if (!old_path) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1508 | output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s " |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1509 | "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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1513 | output(opt, 1, _("CONFLICT (%s/delete): %s deleted in %s " |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1514 | "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 Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 1518 | } |
Elijah Newren | 35a74ab | 2011-08-11 23:20:27 -0600 | [diff] [blame] | 1519 | /* |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1520 | * No need to call update_file() on path when change_branch == |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1521 | * opt->branch1 && !alt_path, since that would needlessly touch |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1522 | * path. We could call update_file_flags() with update_cache=0 |
| 1523 | * and update_wd=0, but that's a no-op. |
Elijah Newren | 35a74ab | 2011-08-11 23:20:27 -0600 | [diff] [blame] | 1524 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1525 | if (change_branch != opt->branch1 || alt_path) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1526 | ret = update_file(opt, 0, changed, update_path); |
Elijah Newren | b703325 | 2011-08-11 23:20:19 -0600 | [diff] [blame] | 1527 | } |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1528 | free(alt_path); |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1529 | |
| 1530 | return ret; |
Elijah Newren | b703325 | 2011-08-11 23:20:19 -0600 | [diff] [blame] | 1531 | } |
| 1532 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1533 | static int handle_rename_delete(struct merge_options *opt, |
Elijah Newren | e2d563d | 2019-04-05 08:00:21 -0700 | [diff] [blame] | 1534 | struct rename_conflict_info *ci) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1535 | { |
Elijah Newren | e2d563d | 2019-04-05 08:00:21 -0700 | [diff] [blame] | 1536 | 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 Newren | e03acb8 | 2011-08-11 23:20:20 -0600 | [diff] [blame] | 1542 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1543 | if (handle_change_delete(opt, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1544 | opt->priv->call_depth ? orig->path : dest->path, |
| 1545 | opt->priv->call_depth ? NULL : orig->path, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1546 | orig, dest, |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 1547 | rename_branch, delete_branch, |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1548 | _("rename"), _("renamed"))) |
| 1549 | return -1; |
Elijah Newren | f53d397 | 2011-08-11 23:20:25 -0600 | [diff] [blame] | 1550 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1551 | if (opt->priv->call_depth) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1552 | return remove_file_from_index(opt->repo->index, dest->path); |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1553 | else |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1554 | return update_stages(opt, dest->path, NULL, |
| 1555 | rename_branch == opt->branch1 ? dest : NULL, |
| 1556 | rename_branch == opt->branch1 ? NULL : dest); |
Elijah Newren | 6ef2cb0 | 2010-09-20 02:28:50 -0600 | [diff] [blame] | 1557 | } |
| 1558 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1559 | static int handle_file_collision(struct merge_options *opt, |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1560 | const char *collide_path, |
| 1561 | const char *prev_path1, |
| 1562 | const char *prev_path2, |
| 1563 | const char *branch1, const char *branch2, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1564 | struct diff_filespec *a, |
| 1565 | struct diff_filespec *b) |
Elijah Newren | 3672c97 | 2011-08-11 23:20:22 -0600 | [diff] [blame] | 1566 | { |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1567 | struct merge_file_info mfi; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1568 | struct diff_filespec null; |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1569 | char *alt_path = NULL; |
| 1570 | const char *update_path = collide_path; |
Elijah Newren | 3672c97 | 2011-08-11 23:20:22 -0600 | [diff] [blame] | 1571 | |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1572 | /* |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1573 | * 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1575 | * branch if we just ensure that branch1 == opt->branch1. So, simply |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1576 | * flip arguments around if we don't have that. |
| 1577 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1578 | if (branch1 != opt->branch1) { |
| 1579 | return handle_file_collision(opt, collide_path, |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1580 | prev_path2, prev_path1, |
| 1581 | branch2, branch1, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1582 | b, a); |
Elijah Newren | 3672c97 | 2011-08-11 23:20:22 -0600 | [diff] [blame] | 1583 | } |
| 1584 | |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1585 | /* Remove rename sources if rename/add or rename/rename(2to1) */ |
| 1586 | if (prev_path1) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1587 | remove_file(opt, 1, prev_path1, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1588 | opt->priv->call_depth || would_lose_untracked(opt, prev_path1)); |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1589 | if (prev_path2) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1590 | remove_file(opt, 1, prev_path2, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1591 | opt->priv->call_depth || would_lose_untracked(opt, prev_path2)); |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1592 | |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1598 | if (was_dirty(opt, collide_path)) { |
| 1599 | output(opt, 1, _("Refusing to lose dirty file at %s"), |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1600 | collide_path); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1601 | update_path = alt_path = unique_path(opt, collide_path, "merged"); |
| 1602 | } else if (would_lose_untracked(opt, collide_path)) { |
Elijah Newren | 18797a3 | 2018-04-19 10:58:13 -0700 | [diff] [blame] | 1603 | /* |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1604 | * 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 Newren | 18797a3 | 2018-04-19 10:58:13 -0700 | [diff] [blame] | 1608 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1609 | output(opt, 1, _("Refusing to lose untracked file at " |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1610 | "%s, even though it's in the way."), |
| 1611 | collide_path); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1612 | update_path = alt_path = unique_path(opt, collide_path, "merged"); |
Elijah Newren | 3672c97 | 2011-08-11 23:20:22 -0600 | [diff] [blame] | 1613 | } else { |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1614 | /* |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1624 | remove_file(opt, 0, collide_path, 0); |
Elijah Newren | 3672c97 | 2011-08-11 23:20:22 -0600 | [diff] [blame] | 1625 | } |
Elijah Newren | 3672c97 | 2011-08-11 23:20:22 -0600 | [diff] [blame] | 1626 | |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1627 | /* Store things in diff_filespecs for functions that need it */ |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1628 | null.path = (char *)collide_path; |
brian m. carlson | 1422844 | 2021-04-26 01:02:56 +0000 | [diff] [blame] | 1629 | oidcpy(&null.oid, null_oid()); |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1630 | null.mode = 0; |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1631 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1632 | if (merge_mode_and_contents(opt, &null, a, b, collide_path, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1633 | branch1, branch2, opt->priv->call_depth * 2, &mfi)) |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1634 | return -1; |
| 1635 | mfi.clean &= !alt_path; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1636 | if (update_file(opt, mfi.clean, &mfi.blob, update_path)) |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1637 | return -1; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1638 | if (!mfi.clean && !opt->priv->call_depth && |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1639 | update_stages(opt, collide_path, NULL, a, b)) |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1640 | 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 Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1651 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1652 | static int handle_rename_add(struct merge_options *opt, |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1653 | struct rename_conflict_info *ci) |
| 1654 | { |
| 1655 | /* a was renamed to c, and a separate c was added. */ |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 1656 | struct diff_filespec *a = ci->ren1->pair->one; |
| 1657 | struct diff_filespec *c = ci->ren1->pair->two; |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1658 | char *path = c->path; |
| 1659 | char *prev_path_desc; |
| 1660 | struct merge_file_info mfi; |
| 1661 | |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 1662 | 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 Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1666 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1667 | output(opt, 1, _("CONFLICT (rename/add): " |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1668 | "Rename %s->%s in %s. Added %s in %s"), |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 1669 | a->path, c->path, rename_branch, |
| 1670 | c->path, add_branch); |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1671 | |
| 1672 | prev_path_desc = xstrfmt("version of %s from %s", path, a->path); |
Elijah Newren | 481de8a | 2019-06-04 13:27:50 -0700 | [diff] [blame] | 1673 | ci->ren1->src_entry->stages[other_stage].path = a->path; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1674 | if (merge_mode_and_contents(opt, a, c, |
| 1675 | &ci->ren1->src_entry->stages[other_stage], |
Elijah Newren | 3f9c92e | 2019-04-05 08:00:19 -0700 | [diff] [blame] | 1676 | prev_path_desc, |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1677 | opt->branch1, opt->branch2, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1678 | 1 + opt->priv->call_depth * 2, &mfi)) |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1679 | return -1; |
| 1680 | free(prev_path_desc); |
| 1681 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1682 | ci->ren1->dst_entry->stages[other_stage].path = mfi.blob.path = c->path; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1683 | return handle_file_collision(opt, |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1684 | c->path, a->path, NULL, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 1685 | rename_branch, add_branch, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1686 | &mfi.blob, |
| 1687 | &ci->ren1->dst_entry->stages[other_stage]); |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 1688 | } |
Elijah Newren | 37b65ce | 2018-11-07 20:40:25 -0800 | [diff] [blame] | 1689 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1690 | static char *find_path_for_conflict(struct merge_options *opt, |
Derrick Stolee | 80cee6e | 2018-11-07 20:40:31 -0800 | [diff] [blame] | 1691 | const char *path, |
| 1692 | const char *branch1, |
| 1693 | const char *branch2) |
| 1694 | { |
| 1695 | char *new_path = NULL; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1696 | if (dir_in_way(opt->repo->index, path, !opt->priv->call_depth, 0)) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1697 | new_path = unique_path(opt, path, branch1); |
| 1698 | output(opt, 1, _("%s is a directory in %s adding " |
Derrick Stolee | 80cee6e | 2018-11-07 20:40:31 -0800 | [diff] [blame] | 1699 | "as %s instead"), |
| 1700 | path, branch2, new_path); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1701 | } 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 Stolee | 80cee6e | 2018-11-07 20:40:31 -0800 | [diff] [blame] | 1704 | " at %s; adding as %s instead"), |
| 1705 | path, new_path); |
| 1706 | } |
| 1707 | |
| 1708 | return new_path; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1709 | } |
| 1710 | |
Jeff King | ee79874 | 2020-01-25 00:37:23 -0500 | [diff] [blame] | 1711 | /* |
Junio C Hamano | 4c616c2 | 2020-01-25 18:57:45 -0500 | [diff] [blame] | 1712 | * Toggle the stage number between "ours" and "theirs" (2 and 3). |
Jeff King | ee79874 | 2020-01-25 00:37:23 -0500 | [diff] [blame] | 1713 | */ |
| 1714 | static inline int flip_stage(int stage) |
| 1715 | { |
Junio C Hamano | 4c616c2 | 2020-01-25 18:57:45 -0500 | [diff] [blame] | 1716 | return (2 + 3) - stage; |
Jeff King | ee79874 | 2020-01-25 00:37:23 -0500 | [diff] [blame] | 1717 | } |
| 1718 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1719 | static int handle_rename_rename_1to2(struct merge_options *opt, |
Elijah Newren | 8ebe7b0 | 2018-06-09 21:16:15 -0700 | [diff] [blame] | 1720 | struct rename_conflict_info *ci) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1721 | { |
Elijah Newren | 09c01f8 | 2010-09-20 02:28:48 -0600 | [diff] [blame] | 1722 | /* One file was renamed in both branches, but to different names. */ |
Elijah Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1723 | struct merge_file_info mfi; |
Elijah Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1724 | struct diff_filespec *add; |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 1725 | 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 Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1728 | char *path_desc; |
Elijah Newren | 07413c5 | 2010-09-20 02:29:00 -0600 | [diff] [blame] | 1729 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1730 | output(opt, 1, _("CONFLICT (rename/rename): " |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 1731 | "Rename \"%s\"->\"%s\" in branch \"%s\" " |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 1732 | "rename \"%s\"->\"%s\" in \"%s\"%s"), |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 1733 | o->path, a->path, ci->ren1->branch, |
| 1734 | o->path, b->path, ci->ren2->branch, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1735 | opt->priv->call_depth ? _(" (left unresolved)") : ""); |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1736 | |
Elijah Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1737 | path_desc = xstrfmt("%s and %s, both renamed from %s", |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 1738 | a->path, b->path, o->path); |
| 1739 | if (merge_mode_and_contents(opt, o, a, b, path_desc, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 1740 | ci->ren1->branch, ci->ren2->branch, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1741 | opt->priv->call_depth * 2, &mfi)) |
Elijah Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1742 | return -1; |
| 1743 | free(path_desc); |
| 1744 | |
Elijah Newren | 8020504 | 2020-02-27 00:05:05 +0000 | [diff] [blame] | 1745 | 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 Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1761 | return -1; |
Elijah Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1762 | } else { |
Elijah Newren | 8020504 | 2020-02-27 00:05:05 +0000 | [diff] [blame] | 1763 | 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 Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1774 | |
Elijah Newren | 95983da | 2020-05-13 23:56:32 +0000 | [diff] [blame] | 1775 | 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 Newren | 8020504 | 2020-02-27 00:05:05 +0000 | [diff] [blame] | 1787 | 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 Newren | 48c9cb9 | 2018-11-07 20:40:29 -0800 | [diff] [blame] | 1807 | } |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1808 | |
| 1809 | return 0; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1810 | } |
| 1811 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1812 | static int handle_rename_rename_2to1(struct merge_options *opt, |
Elijah Newren | 8ebe7b0 | 2018-06-09 21:16:15 -0700 | [diff] [blame] | 1813 | struct rename_conflict_info *ci) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1814 | { |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 1815 | /* Two files, a & b, were renamed to the same thing, c. */ |
Elijah Newren | e9cd1b5 | 2019-04-05 08:00:18 -0700 | [diff] [blame] | 1816 | 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 Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 1820 | char *path = c1->path; /* == c2->path */ |
Elijah Newren | 05cf21e | 2018-04-19 10:58:22 -0700 | [diff] [blame] | 1821 | char *path_side_1_desc; |
| 1822 | char *path_side_2_desc; |
Elijah Newren | 434b852 | 2011-08-11 23:20:18 -0600 | [diff] [blame] | 1823 | struct merge_file_info mfi_c1; |
| 1824 | struct merge_file_info mfi_c2; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1825 | int ostage1, ostage2; |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 1826 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1827 | output(opt, 1, _("CONFLICT (rename/rename): " |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 1828 | "Rename %s->%s in %s. " |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 1829 | "Rename %s->%s in %s"), |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 1830 | a->path, c1->path, ci->ren1->branch, |
| 1831 | b->path, c2->path, ci->ren2->branch); |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 1832 | |
Elijah Newren | 2b168ef | 2018-10-16 13:19:47 -0700 | [diff] [blame] | 1833 | 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 Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1835 | ostage1 = ci->ren1->branch == opt->branch1 ? 3 : 2; |
Jeff King | ee79874 | 2020-01-25 00:37:23 -0500 | [diff] [blame] | 1836 | ostage2 = flip_stage(ostage1); |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1837 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1842 | opt->branch1, opt->branch2, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1843 | 1 + opt->priv->call_depth * 2, &mfi_c1) || |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1844 | merge_mode_and_contents(opt, b, |
| 1845 | &ci->ren2->src_entry->stages[ostage2], |
| 1846 | c2, path_side_2_desc, |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1847 | opt->branch1, opt->branch2, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1848 | 1 + opt->priv->call_depth * 2, &mfi_c2)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 1849 | return -1; |
Elijah Newren | 05cf21e | 2018-04-19 10:58:22 -0700 | [diff] [blame] | 1850 | free(path_side_1_desc); |
| 1851 | free(path_side_2_desc); |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1852 | mfi_c1.blob.path = path; |
| 1853 | mfi_c2.blob.path = path; |
Elijah Newren | 434b852 | 2011-08-11 23:20:18 -0600 | [diff] [blame] | 1854 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1855 | return handle_file_collision(opt, path, a->path, b->path, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 1856 | ci->ren1->branch, ci->ren2->branch, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 1857 | &mfi_c1.blob, &mfi_c2.blob); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 1858 | } |
| 1859 | |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 1860 | /* |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 1861 | * Get the diff_filepairs changed between o_tree and tree. |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 1862 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1863 | static struct diff_queue_struct *get_diffpairs(struct merge_options *opt, |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 1864 | struct tree *o_tree, |
| 1865 | struct tree *tree) |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 1866 | { |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 1867 | struct diff_queue_struct *ret; |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 1868 | struct diff_options opts; |
| 1869 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1870 | repo_diff_setup(opt->repo, &opts); |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 1871 | opts.flags.recursive = 1; |
| 1872 | opts.flags.rename_empty = 0; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1873 | opts.detect_rename = merge_detect_rename(opt); |
Ben Peart | 85b4603 | 2018-05-02 16:01:14 +0000 | [diff] [blame] | 1874 | /* |
| 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 Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 1882 | opts.rename_limit = (opt->rename_limit >= 0) ? opt->rename_limit : 1000; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 1883 | opts.rename_score = opt->rename_score; |
| 1884 | opts.show_rename_progress = opt->show_rename_progress; |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 1885 | 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 Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 1889 | if (opts.needed_rename_limit > opt->priv->needed_rename_limit) |
| 1890 | opt->priv->needed_rename_limit = opts.needed_rename_limit; |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 1891 | |
| 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 Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 1902 | static int tree_has_path(struct repository *r, struct tree *tree, |
| 1903 | const char *path) |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 1904 | { |
| 1905 | struct object_id hashy; |
Elijah Newren | 5ec1e72 | 2019-04-05 08:00:12 -0700 | [diff] [blame] | 1906 | unsigned short mode_o; |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 1907 | |
Nguyễn Thái Ngọc Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 1908 | return !get_tree_entry(r, |
Nguyễn Thái Ngọc Duy | 50ddb08 | 2019-06-27 16:28:49 +0700 | [diff] [blame] | 1909 | &tree->object.oid, path, |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 1910 | &hashy, &mode_o); |
| 1911 | } |
| 1912 | |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 1913 | /* |
| 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 | */ |
| 1920 | static 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 Newren | 49b8133a | 2019-10-22 21:22:50 +0000 | [diff] [blame] | 1930 | 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 Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 1940 | 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 1948 | static 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 1952 | |
Elijah Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 1953 | /* Default return values: NULL, meaning no rename */ |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 1954 | *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 Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 1964 | */ |
| 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 1969 | */ |
| 1970 | end_of_old = strrchr(old_path, '/'); |
| 1971 | end_of_new = strrchr(new_path, '/'); |
| 1972 | |
Elijah Newren | 49b8133a | 2019-10-22 21:22:50 +0000 | [diff] [blame] | 1973 | /* |
| 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 1990 | return; |
Elijah Newren | 49b8133a | 2019-10-22 21:22:50 +0000 | [diff] [blame] | 1991 | } |
Elijah Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 1992 | |
| 1993 | /* Find the first non-matching character traversing backwards */ |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 1994 | 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 Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 1998 | |
| 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 Newren | 49b8133a | 2019-10-22 21:22:50 +0000 | [diff] [blame] | 2005 | 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 Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 2024 | |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2025 | /* |
| 2026 | * We've found the first non-matching character in the directory |
Elijah Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 2027 | * 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2042 | */ |
Elijah Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 2043 | end_of_old = strchr(++end_of_old, '/'); |
| 2044 | end_of_new = strchr(++end_of_new, '/'); |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2045 | |
Elijah Newren | d3eebaa | 2019-10-22 21:22:49 +0000 | [diff] [blame] | 2046 | /* 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2049 | } |
| 2050 | |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2051 | static 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 Wong | 28ee794 | 2019-10-06 23:30:31 +0000 | [diff] [blame] | 2059 | hashmap_remove(dir_renames, &entry->ent, NULL); |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2060 | } |
| 2061 | string_list_clear(items_to_remove, 0); |
| 2062 | } |
| 2063 | |
| 2064 | /* |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2065 | * 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2069 | static char *handle_path_level_conflicts(struct merge_options *opt, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2070 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2090 | output(opt, 1, _("CONFLICT (directory rename split): " |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2091 | "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 Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 2118 | } else if (tree_has_path(opt->repo, tree, new_path)) { |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2119 | collision_ent->reported_already = 1; |
| 2120 | strbuf_add_separated_string_list(&collision_paths, ", ", |
| 2121 | &collision_ent->source_files); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2122 | output(opt, 1, _("CONFLICT (implicit dir rename): Existing " |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2123 | "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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2132 | output(opt, 1, _("CONFLICT (implicit dir rename): Cannot map " |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2133 | "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 Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2150 | * 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2169 | static void handle_directory_level_conflicts(struct merge_options *opt, |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2170 | 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 Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2182 | hashmap_for_each_entry(dir_re_head, &iter, head_ent, |
Eric Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2183 | ent /* member name */) { |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2184 | 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 Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 2196 | } else if (tree_has_path(opt->repo, head, head_ent->dir)) { |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2197 | /* 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 Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2207 | hashmap_for_each_entry(dir_re_merge, &iter, merge_ent, |
Eric Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2208 | ent /* member name */) { |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2209 | head_ent = dir_rename_find_entry(dir_re_head, merge_ent->dir); |
Nguyễn Thái Ngọc Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 2210 | if (tree_has_path(opt->repo, merge, merge_ent->dir)) { |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2211 | /* 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2224 | output(opt, 1, _("CONFLICT (rename/rename): " |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2225 | "Rename directory %s->%s in %s. " |
| 2226 | "Rename directory %s->%s in %s"), |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2227 | head_ent->dir, head_ent->new_dir.buf, opt->branch1, |
| 2228 | head_ent->dir, merge_ent->new_dir.buf, opt->branch2); |
Elijah Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2229 | 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 King | b53c502 | 2019-02-14 00:50:02 -0500 | [diff] [blame] | 2242 | static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs) |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2243 | { |
| 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 Wong | 26b455f | 2019-10-06 23:30:32 +0000 | [diff] [blame] | 2287 | hashmap_put(dir_renames, &entry->ent); |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2288 | } 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 Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2312 | hashmap_for_each_entry(dir_renames, &iter, entry, |
Eric Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2313 | ent /* member name */) { |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2314 | 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 Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2349 | static struct dir_rename_entry *check_dir_renamed(const char *path, |
| 2350 | struct hashmap *dir_renames) |
| 2351 | { |
René Scharfe | 9da2d03 | 2018-06-10 12:56:31 +0200 | [diff] [blame] | 2352 | char *temp = xstrdup(path); |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2353 | char *end; |
Elijah Newren | c3b9bc9 | 2018-09-05 10:03:07 -0700 | [diff] [blame] | 2354 | struct dir_rename_entry *entry = NULL; |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2355 | |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2356 | while ((end = strrchr(temp, '/'))) { |
| 2357 | *end = '\0'; |
| 2358 | entry = dir_rename_find_entry(dir_renames, temp); |
| 2359 | if (entry) |
René Scharfe | 9da2d03 | 2018-06-10 12:56:31 +0200 | [diff] [blame] | 2360 | break; |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2361 | } |
René Scharfe | 9da2d03 | 2018-06-10 12:56:31 +0200 | [diff] [blame] | 2362 | free(temp); |
| 2363 | return entry; |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2364 | } |
| 2365 | |
| 2366 | static 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 Newren | 6e7e027 | 2018-04-19 10:58:15 -0700 | [diff] [blame] | 2396 | if (pair->status != 'A' && pair->status != 'R') |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2397 | 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é Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 2414 | CALLOC_ARRAY(collision_ent, 1); |
Eric Wong | d22245a | 2019-10-06 23:30:27 +0000 | [diff] [blame] | 2415 | hashmap_entry_init(&collision_ent->ent, |
| 2416 | strhash(new_path)); |
Eric Wong | 26b455f | 2019-10-06 23:30:32 +0000 | [diff] [blame] | 2417 | hashmap_put(collisions, &collision_ent->ent); |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2418 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2427 | static char *check_for_directory_rename(struct merge_options *opt, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2428 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2468 | output(opt, 1, _("WARNING: Avoiding applying %s -> %s rename " |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2469 | "to %s, because %s itself was renamed."), |
| 2470 | entry->dir, entry->new_dir.buf, path, entry->new_dir.buf); |
| 2471 | } else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2472 | new_path = handle_path_level_conflicts(opt, path, entry, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2473 | collisions, tree); |
| 2474 | *clean_merge &= (new_path != NULL); |
| 2475 | } |
| 2476 | |
| 2477 | return new_path; |
| 2478 | } |
| 2479 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2480 | static void apply_directory_rename_modifications(struct merge_options *opt, |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2481 | 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 King | b53c502 | 2019-02-14 00:50:02 -0500 | [diff] [blame] | 2488 | struct string_list *entries) |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2489 | { |
| 2490 | struct string_list_item *item; |
| 2491 | int stage = (tree == a_tree ? 2 : 3); |
Elijah Newren | 18797a3 | 2018-04-19 10:58:13 -0700 | [diff] [blame] | 2492 | int update_wd; |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2493 | |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2503 | update_wd = !was_dirty(opt, pair->two->path); |
Elijah Newren | 18797a3 | 2018-04-19 10:58:13 -0700 | [diff] [blame] | 2504 | if (!update_wd) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2505 | output(opt, 1, _("Refusing to lose dirty file at %s"), |
Elijah Newren | 18797a3 | 2018-04-19 10:58:13 -0700 | [diff] [blame] | 2506 | pair->two->path); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2507 | remove_file(opt, 1, pair->two->path, !update_wd); |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2508 | |
| 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 Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 2539 | re->dst_entry = insert_stage_data(opt->repo, new_path, |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2540 | 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 Newren | 8ebe7b0 | 2018-06-09 21:16:15 -0700 | [diff] [blame] | 2559 | * the various handle_rename_*() functions update the index |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2560 | * explicitly rather than relying on unpack_trees() to have done it. |
| 2561 | */ |
Nguyễn Thái Ngọc Duy | 50ddb08 | 2019-06-27 16:28:49 +0700 | [diff] [blame] | 2562 | get_tree_entry(opt->repo, |
| 2563 | &tree->object.oid, |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2564 | pair->two->path, |
| 2565 | &re->dst_entry->stages[stage].oid, |
| 2566 | &re->dst_entry->stages[stage].mode); |
| 2567 | |
Elijah Newren | 6d169fd | 2019-04-05 08:00:24 -0700 | [diff] [blame] | 2568 | /* |
| 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 Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2580 | /* |
| 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 Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2592 | /* |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2599 | static struct string_list *get_renames(struct merge_options *opt, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2600 | const char *branch, |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2601 | struct diff_queue_struct *pairs, |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2602 | struct hashmap *dir_renames, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2603 | struct hashmap *dir_rename_exclusions, |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2604 | struct tree *tree, |
| 2605 | struct tree *o_tree, |
| 2606 | struct tree *a_tree, |
| 2607 | struct tree *b_tree, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2608 | struct string_list *entries, |
| 2609 | int *clean_merge) |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2610 | { |
| 2611 | int i; |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2612 | struct hashmap collisions; |
| 2613 | struct hashmap_iter iter; |
| 2614 | struct collision_entry *e; |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2615 | struct string_list *renames; |
| 2616 | |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2617 | compute_collisions(&collisions, dir_renames, pairs); |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 2618 | CALLOC_ARRAY(renames, 1); |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2619 | |
| 2620 | for (i = 0; i < pairs->nr; ++i) { |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2621 | struct string_list_item *item; |
| 2622 | struct rename *re; |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2623 | struct diff_filepair *pair = pairs->queue[i]; |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2624 | char *new_path; /* non-NULL only with directory renames */ |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2625 | |
Elijah Newren | 6e7e027 | 2018-04-19 10:58:15 -0700 | [diff] [blame] | 2626 | if (pair->status != 'A' && pair->status != 'R') { |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2627 | diff_free_filepair(pair); |
| 2628 | continue; |
| 2629 | } |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2630 | new_path = check_for_directory_rename(opt, pair->two->path, tree, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2631 | 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 Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2640 | re = xmalloc(sizeof(*re)); |
| 2641 | re->processed = 0; |
| 2642 | re->pair = pair; |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2643 | re->branch = branch; |
Elijah Newren | 6d169fd | 2019-04-05 08:00:24 -0700 | [diff] [blame] | 2644 | re->dir_rename_original_type = '\0'; |
| 2645 | re->dir_rename_original_dest = NULL; |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2646 | item = string_list_lookup(entries, re->pair->one->path); |
| 2647 | if (!item) |
Nguyễn Thái Ngọc Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 2648 | re->src_entry = insert_stage_data(opt->repo, |
| 2649 | re->pair->one->path, |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2650 | 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 Duy | 34e7771 | 2019-06-27 16:28:52 +0700 | [diff] [blame] | 2656 | re->dst_entry = insert_stage_data(opt->repo, |
| 2657 | re->pair->two->path, |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2658 | 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 Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2663 | if (new_path) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2664 | apply_directory_rename_modifications(opt, pair, new_path, |
Elijah Newren | 9c0743f | 2018-04-19 10:58:10 -0700 | [diff] [blame] | 2665 | re, tree, o_tree, |
| 2666 | a_tree, b_tree, |
Jeff King | b53c502 | 2019-02-14 00:50:02 -0500 | [diff] [blame] | 2667 | entries); |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2668 | } |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2669 | |
Eric Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2670 | hashmap_for_each_entry(&collisions, &iter, e, |
Eric Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2671 | ent /* member name */) { |
Elijah Newren | e95ab70 | 2018-04-19 10:58:07 -0700 | [diff] [blame] | 2672 | free(e->target_file); |
| 2673 | string_list_clear(&e->source_files, 0); |
| 2674 | } |
Elijah Newren | 6da1a25 | 2020-11-02 18:55:05 +0000 | [diff] [blame] | 2675 | hashmap_clear_and_free(&collisions, struct collision_entry, ent); |
Elijah Newren | 9ba9155 | 2018-04-19 10:57:59 -0700 | [diff] [blame] | 2676 | return renames; |
| 2677 | } |
| 2678 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2679 | static int process_renames(struct merge_options *opt, |
Miklos Vajna | 8a2fce1 | 2008-08-25 16:25:57 +0200 | [diff] [blame] | 2680 | struct string_list *a_renames, |
| 2681 | struct string_list *b_renames) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2682 | { |
| 2683 | int clean_merge = 1, i, j; |
Thiago Farina | 183113a | 2010-07-04 16:46:19 -0300 | [diff] [blame] | 2684 | struct string_list a_by_dst = STRING_LIST_INIT_NODUP; |
| 2685 | struct string_list b_by_dst = STRING_LIST_INIT_NODUP; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2686 | const struct rename *sre; |
| 2687 | |
Elijah Newren | 816147e | 2021-03-20 00:03:53 +0000 | [diff] [blame] | 2688 | /* |
| 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2696 | for (i = 0; i < a_renames->nr; i++) { |
| 2697 | sre = a_renames->items[i].util; |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 2698 | string_list_insert(&a_by_dst, sre->pair->two->path)->util |
Elijah Newren | 0a6b871 | 2011-08-11 23:20:04 -0600 | [diff] [blame] | 2699 | = (void *)sre; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2700 | } |
| 2701 | for (i = 0; i < b_renames->nr; i++) { |
| 2702 | sre = b_renames->items[i].util; |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 2703 | string_list_insert(&b_by_dst, sre->pair->two->path)->util |
Elijah Newren | 0a6b871 | 2011-08-11 23:20:04 -0600 | [diff] [blame] | 2704 | = (void *)sre; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2705 | } |
| 2706 | |
| 2707 | for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) { |
Benjamin Kramer | 8e24cba | 2009-03-15 22:01:20 +0100 | [diff] [blame] | 2708 | struct string_list *renames1, *renames2Dst; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2709 | struct rename *ren1 = NULL, *ren2 = NULL; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2710 | const char *ren1_src, *ren1_dst; |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 2711 | struct string_list_item *lookup; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2712 | |
| 2713 | if (i >= a_renames->nr) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2714 | ren2 = b_renames->items[j++].util; |
| 2715 | } else if (j >= b_renames->nr) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2716 | ren1 = a_renames->items[i++].util; |
| 2717 | } else { |
Benjamin Kramer | 8e24cba | 2009-03-15 22:01:20 +0100 | [diff] [blame] | 2718 | int compare = strcmp(a_renames->items[i].string, |
| 2719 | b_renames->items[j].string); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2720 | 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2729 | renames2Dst = &b_by_dst; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2730 | } else { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2731 | renames1 = b_renames; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2732 | renames2Dst = &a_by_dst; |
René Scharfe | 35d803b | 2017-01-28 22:40:58 +0100 | [diff] [blame] | 2733 | SWAP(ren2, ren1); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2734 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2735 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2736 | if (ren1->processed) |
| 2737 | continue; |
| 2738 | ren1->processed = 1; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2739 | ren1->dst_entry->processed = 1; |
Elijah Newren | 7769a75 | 2011-08-11 23:20:05 -0600 | [diff] [blame] | 2740 | /* BUG: We should only mark src_entry as processed if we |
| 2741 | * are not dealing with a rename + add-source case. |
| 2742 | */ |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2743 | ren1->src_entry->processed = 1; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2744 | |
| 2745 | ren1_src = ren1->pair->one->path; |
| 2746 | ren1_dst = ren1->pair->two->path; |
| 2747 | |
| 2748 | if (ren2) { |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 2749 | /* One file renamed on both sides */ |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2750 | const char *ren2_src = ren2->pair->one->path; |
| 2751 | const char *ren2_dst = ren2->pair->two->path; |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 2752 | enum rename_type rename_type; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2753 | if (strcmp(ren1_src, ren2_src) != 0) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 2754 | BUG("ren1_src != ren2_src"); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2755 | ren2->dst_entry->processed = 1; |
| 2756 | ren2->processed = 1; |
| 2757 | if (strcmp(ren1_dst, ren2_dst) != 0) { |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 2758 | rename_type = RENAME_ONE_FILE_TO_TWO; |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 2759 | clean_merge = 0; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2760 | } else { |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 2761 | rename_type = RENAME_ONE_FILE_TO_ONE; |
Elijah Newren | 7769a75 | 2011-08-11 23:20:05 -0600 | [diff] [blame] | 2762 | /* BUG: We should only remove ren1_src in |
| 2763 | * the base stage (think of rename + |
| 2764 | * add-source cases). |
| 2765 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2766 | remove_file(opt, 1, ren1_src, 1); |
Elijah Newren | b8ddf16 | 2011-08-11 23:20:02 -0600 | [diff] [blame] | 2767 | update_entry(ren1->dst_entry, |
| 2768 | ren1->pair->one, |
| 2769 | ren1->pair->two, |
| 2770 | ren2->pair->two); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2771 | } |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2772 | setup_rename_conflict_info(rename_type, opt, ren1, ren2); |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 2773 | } 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 Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 2779 | BUG("ren1_dst != ren2_dst"); |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 2780 | |
| 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 Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2791 | opt, ren1, ren2); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2792 | } else { |
| 2793 | /* Renamed in 1, maybe changed in 2 */ |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2794 | /* we only use sha1 and mode of these */ |
| 2795 | struct diff_filespec src_other, dst_other; |
Elijah Newren | 41d70bd | 2010-09-20 02:28:47 -0600 | [diff] [blame] | 2796 | int try_merge; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2797 | |
Elijah Newren | 41d70bd | 2010-09-20 02:28:47 -0600 | [diff] [blame] | 2798 | /* |
| 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2806 | |
Elijah Newren | 7769a75 | 2011-08-11 23:20:05 -0600 | [diff] [blame] | 2807 | /* 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2811 | remove_file(opt, 1, ren1_src, |
| 2812 | renamed_stage == 2 || !was_tracked(opt, ren1_src)); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2813 | |
brian m. carlson | fd429e9 | 2016-06-24 23:09:25 +0000 | [diff] [blame] | 2814 | oidcpy(&src_other.oid, |
| 2815 | &ren1->src_entry->stages[other_stage].oid); |
Elijah Newren | 41d70bd | 2010-09-20 02:28:47 -0600 | [diff] [blame] | 2816 | src_other.mode = ren1->src_entry->stages[other_stage].mode; |
brian m. carlson | fd429e9 | 2016-06-24 23:09:25 +0000 | [diff] [blame] | 2817 | oidcpy(&dst_other.oid, |
| 2818 | &ren1->dst_entry->stages[other_stage].oid); |
Elijah Newren | 41d70bd | 2010-09-20 02:28:47 -0600 | [diff] [blame] | 2819 | dst_other.mode = ren1->dst_entry->stages[other_stage].mode; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2820 | try_merge = 0; |
| 2821 | |
brian m. carlson | 1422844 | 2021-04-26 01:02:56 +0000 | [diff] [blame] | 2822 | if (oideq(&src_other.oid, null_oid()) && |
Elijah Newren | 6d169fd | 2019-04-05 08:00:24 -0700 | [diff] [blame] | 2823 | ren1->dir_rename_original_type == 'A') { |
Elijah Newren | 5455c33 | 2018-06-09 21:16:14 -0700 | [diff] [blame] | 2824 | setup_rename_conflict_info(RENAME_VIA_DIR, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2825 | opt, ren1, NULL); |
brian m. carlson | 1422844 | 2021-04-26 01:02:56 +0000 | [diff] [blame] | 2826 | } else if (oideq(&src_other.oid, null_oid())) { |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 2827 | setup_rename_conflict_info(RENAME_DELETE, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2828 | opt, ren1, NULL); |
Schalk, Ken | d5af510 | 2010-09-01 13:15:32 -0700 | [diff] [blame] | 2829 | } else if ((dst_other.mode == ren1->pair->two->mode) && |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 2830 | oideq(&dst_other.oid, &ren1->pair->two->oid)) { |
Elijah Newren | 35a74ab | 2011-08-11 23:20:27 -0600 | [diff] [blame] | 2831 | /* |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2839 | if (update_file_flags(opt, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 2840 | ren1->pair->two, |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 2841 | ren1_dst, |
| 2842 | 1, /* update_cache */ |
| 2843 | 0 /* update_wd */)) |
| 2844 | clean_merge = -1; |
brian m. carlson | 1422844 | 2021-04-26 01:02:56 +0000 | [diff] [blame] | 2845 | } else if (!oideq(&dst_other.oid, null_oid())) { |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 2846 | /* |
| 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 Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2854 | opt, ren1, NULL); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2855 | } else |
| 2856 | try_merge = 1; |
| 2857 | |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 2858 | if (clean_merge < 0) |
| 2859 | goto cleanup_and_return; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2860 | if (try_merge) { |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 2861 | struct diff_filespec *o, *a, *b; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2862 | src_other.path = (char *)ren1_src; |
| 2863 | |
Elijah Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 2864 | o = ren1->pair->one; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2865 | 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 Newren | e3de888 | 2019-04-05 08:00:14 -0700 | [diff] [blame] | 2872 | update_entry(ren1->dst_entry, o, a, b); |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 2873 | setup_rename_conflict_info(RENAME_NORMAL, |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2874 | opt, ren1, NULL); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2875 | } |
| 2876 | } |
| 2877 | } |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 2878 | cleanup_and_return: |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 2879 | string_list_clear(&a_by_dst, 0); |
| 2880 | string_list_clear(&b_by_dst, 0); |
| 2881 | |
| 2882 | return clean_merge; |
| 2883 | } |
| 2884 | |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 2885 | struct rename_info { |
| 2886 | struct string_list *head_renames; |
| 2887 | struct string_list *merge_renames; |
| 2888 | }; |
| 2889 | |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2890 | static void initial_cleanup_rename(struct diff_queue_struct *pairs, |
| 2891 | struct hashmap *dir_renames) |
Elijah Newren | ffc16c4 | 2018-04-19 10:58:04 -0700 | [diff] [blame] | 2892 | { |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2893 | struct hashmap_iter iter; |
| 2894 | struct dir_rename_entry *e; |
| 2895 | |
Eric Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2896 | hashmap_for_each_entry(dir_renames, &iter, e, |
Eric Wong | 87571c3 | 2019-10-06 23:30:38 +0000 | [diff] [blame] | 2897 | ent /* member name */) { |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2898 | free(e->dir); |
| 2899 | strbuf_release(&e->new_dir); |
| 2900 | /* possible_new_dirs already cleared in get_directory_renames */ |
| 2901 | } |
Elijah Newren | 6da1a25 | 2020-11-02 18:55:05 +0000 | [diff] [blame] | 2902 | hashmap_clear_and_free(dir_renames, struct dir_rename_entry, ent); |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2903 | free(dir_renames); |
| 2904 | |
Elijah Newren | ffc16c4 | 2018-04-19 10:58:04 -0700 | [diff] [blame] | 2905 | free(pairs->queue); |
| 2906 | free(pairs); |
| 2907 | } |
| 2908 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2909 | static int detect_and_process_renames(struct merge_options *opt, |
Elijah Newren | 8ebe7b0 | 2018-06-09 21:16:15 -0700 | [diff] [blame] | 2910 | struct tree *common, |
| 2911 | struct tree *head, |
| 2912 | struct tree *merge, |
| 2913 | struct string_list *entries, |
| 2914 | struct rename_info *ri) |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 2915 | { |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2916 | struct diff_queue_struct *head_pairs, *merge_pairs; |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2917 | struct hashmap *dir_re_head, *dir_re_merge; |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2918 | int clean = 1; |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2919 | |
Elijah Newren | 3992ff0 | 2018-04-19 10:58:02 -0700 | [diff] [blame] | 2920 | ri->head_renames = NULL; |
| 2921 | ri->merge_renames = NULL; |
| 2922 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2923 | if (!merge_detect_rename(opt)) |
Elijah Newren | 3992ff0 | 2018-04-19 10:58:02 -0700 | [diff] [blame] | 2924 | return 1; |
| 2925 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2926 | head_pairs = get_diffpairs(opt, common, head); |
| 2927 | merge_pairs = get_diffpairs(opt, common, merge); |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2928 | |
Derrick Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 2929 | if ((opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_TRUE) || |
| 2930 | (opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_CONFLICT && |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 2931 | !opt->priv->call_depth)) { |
Jeff King | b53c502 | 2019-02-14 00:50:02 -0500 | [diff] [blame] | 2932 | dir_re_head = get_directory_renames(head_pairs); |
| 2933 | dir_re_merge = get_directory_renames(merge_pairs); |
Elijah Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2934 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2935 | handle_directory_level_conflicts(opt, |
Elijah Newren | 5fdddd9 | 2018-08-29 00:06:12 -0700 | [diff] [blame] | 2936 | 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 Newren | 96e7ffb | 2018-04-19 10:58:06 -0700 | [diff] [blame] | 2944 | |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2945 | ri->head_renames = get_renames(opt, opt->branch1, head_pairs, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2946 | dir_re_merge, dir_re_head, head, |
| 2947 | common, head, merge, entries, |
| 2948 | &clean); |
| 2949 | if (clean < 0) |
| 2950 | goto cleanup; |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 2951 | ri->merge_renames = get_renames(opt, opt->branch2, merge_pairs, |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2952 | dir_re_head, dir_re_merge, merge, |
| 2953 | common, head, merge, entries, |
| 2954 | &clean); |
| 2955 | if (clean < 0) |
| 2956 | goto cleanup; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2957 | clean &= process_renames(opt, ri->head_renames, ri->merge_renames); |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2958 | |
Elijah Newren | f6f7755 | 2018-04-19 10:58:08 -0700 | [diff] [blame] | 2959 | cleanup: |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2960 | /* |
| 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 Newren | 7fe40b8 | 2018-04-19 10:58:05 -0700 | [diff] [blame] | 2965 | initial_cleanup_rename(head_pairs, dir_re_head); |
| 2966 | initial_cleanup_rename(merge_pairs, dir_re_merge); |
Elijah Newren | e5257b2 | 2018-04-19 10:58:03 -0700 | [diff] [blame] | 2967 | |
| 2968 | return clean; |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 2969 | } |
| 2970 | |
Elijah Newren | ffc16c4 | 2018-04-19 10:58:04 -0700 | [diff] [blame] | 2971 | static void final_cleanup_rename(struct string_list *rename) |
Elijah Newren | 9cfee25 | 2018-04-19 10:58:01 -0700 | [diff] [blame] | 2972 | { |
| 2973 | const struct rename *re; |
| 2974 | int i; |
| 2975 | |
Elijah Newren | 3992ff0 | 2018-04-19 10:58:02 -0700 | [diff] [blame] | 2976 | if (rename == NULL) |
| 2977 | return; |
| 2978 | |
Elijah Newren | 9cfee25 | 2018-04-19 10:58:01 -0700 | [diff] [blame] | 2979 | 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 Newren | ffc16c4 | 2018-04-19 10:58:04 -0700 | [diff] [blame] | 2987 | static void final_cleanup_renames(struct rename_info *re_info) |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 2988 | { |
Elijah Newren | ffc16c4 | 2018-04-19 10:58:04 -0700 | [diff] [blame] | 2989 | final_cleanup_rename(re_info->head_renames); |
| 2990 | final_cleanup_rename(re_info->merge_renames); |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 2991 | } |
| 2992 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 2993 | static int read_oid_strbuf(struct merge_options *opt, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 2994 | const struct object_id *oid, |
| 2995 | struct strbuf *dst) |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 2996 | { |
| 2997 | void *buf; |
| 2998 | enum object_type type; |
| 2999 | unsigned long size; |
brian m. carlson | b4f5aca | 2018-03-12 02:27:53 +0000 | [diff] [blame] | 3000 | buf = read_object_file(oid, &type, &size); |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3001 | if (!buf) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3002 | return err(opt, _("cannot read object %s"), oid_to_hex(oid)); |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3003 | if (type != OBJ_BLOB) { |
| 3004 | free(buf); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3005 | return err(opt, _("object %s is not a blob"), oid_to_hex(oid)); |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3006 | } |
| 3007 | strbuf_attach(dst, buf, size, size + 1); |
| 3008 | return 0; |
| 3009 | } |
| 3010 | |
Johannes Schindelin | bc9204d | 2016-08-01 13:44:37 +0200 | [diff] [blame] | 3011 | static int blob_unchanged(struct merge_options *opt, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3012 | const struct diff_filespec *o, |
| 3013 | const struct diff_filespec *a, |
Jonathan Nieder | 3e7589b | 2010-08-05 06:13:49 -0500 | [diff] [blame] | 3014 | int renormalize, const char *path) |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3015 | { |
Elijah Newren | 93a02c5 | 2019-04-05 08:00:15 -0700 | [diff] [blame] | 3016 | struct strbuf obuf = STRBUF_INIT; |
| 3017 | struct strbuf abuf = STRBUF_INIT; |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3018 | int ret = 0; /* assume changed for safety */ |
Derrick Stolee | 847a9e5 | 2021-04-01 01:49:39 +0000 | [diff] [blame] | 3019 | struct index_state *idx = opt->repo->index; |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3020 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3021 | if (a->mode != o->mode) |
Jeff King | 72fac66 | 2015-10-26 17:39:39 -0400 | [diff] [blame] | 3022 | return 0; |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 3023 | if (oideq(&o->oid, &a->oid)) |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3024 | return 1; |
Jonathan Nieder | 3e7589b | 2010-08-05 06:13:49 -0500 | [diff] [blame] | 3025 | if (!renormalize) |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3026 | return 0; |
| 3027 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3028 | if (read_oid_strbuf(opt, &o->oid, &obuf) || |
| 3029 | read_oid_strbuf(opt, &a->oid, &abuf)) |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3030 | 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 Newren | 93a02c5 | 2019-04-05 08:00:15 -0700 | [diff] [blame] | 3036 | 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 Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3039 | |
| 3040 | error_return: |
Elijah Newren | 93a02c5 | 2019-04-05 08:00:15 -0700 | [diff] [blame] | 3041 | strbuf_release(&obuf); |
| 3042 | strbuf_release(&abuf); |
Eyvind Bernhardsen | 331a183 | 2010-07-02 21:20:48 +0200 | [diff] [blame] | 3043 | return ret; |
| 3044 | } |
| 3045 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3046 | static int handle_modify_delete(struct merge_options *opt, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 3047 | const char *path, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3048 | const struct diff_filespec *o, |
| 3049 | const struct diff_filespec *a, |
| 3050 | const struct diff_filespec *b) |
Elijah Newren | 5e3ce66 | 2010-09-20 02:28:51 -0600 | [diff] [blame] | 3051 | { |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 3052 | const char *modify_branch, *delete_branch; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3053 | const struct diff_filespec *changed; |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 3054 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3055 | if (is_valid(a)) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3056 | modify_branch = opt->branch1; |
| 3057 | delete_branch = opt->branch2; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3058 | changed = a; |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 3059 | } else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3060 | modify_branch = opt->branch2; |
| 3061 | delete_branch = opt->branch1; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3062 | changed = b; |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 3063 | } |
| 3064 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3065 | return handle_change_delete(opt, |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 3066 | path, NULL, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3067 | o, changed, |
Matt McCutchen | b26d87f | 2017-01-28 15:37:01 -0500 | [diff] [blame] | 3068 | modify_branch, delete_branch, |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3069 | _("modify"), _("modified")); |
Elijah Newren | 5e3ce66 | 2010-09-20 02:28:51 -0600 | [diff] [blame] | 3070 | } |
| 3071 | |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3072 | static int handle_content_merge(struct merge_file_info *mfi, |
| 3073 | struct merge_options *opt, |
Elijah Newren | d957355 | 2018-09-19 09:14:34 -0700 | [diff] [blame] | 3074 | const char *path, |
| 3075 | int is_dirty, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3076 | const struct diff_filespec *o, |
| 3077 | const struct diff_filespec *a, |
| 3078 | const struct diff_filespec *b, |
Elijah Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3079 | struct rename_conflict_info *ci) |
Elijah Newren | 0c4918d | 2010-09-20 02:28:52 -0600 | [diff] [blame] | 3080 | { |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 3081 | const char *reason = _("content"); |
Elijah Newren | 4ab9a15 | 2010-09-20 02:29:07 -0600 | [diff] [blame] | 3082 | unsigned df_conflict_remains = 0; |
Elijah Newren | 0c4918d | 2010-09-20 02:28:52 -0600 | [diff] [blame] | 3083 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3084 | if (!is_valid(o)) |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 3085 | reason = _("add/add"); |
Elijah Newren | 0c4918d | 2010-09-20 02:28:52 -0600 | [diff] [blame] | 3086 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3087 | assert(o->path && a->path && b->path); |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3088 | if (ci && dir_in_way(opt->repo->index, path, !opt->priv->call_depth, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3089 | S_ISGITLINK(ci->ren1->pair->two->mode))) |
| 3090 | df_conflict_remains = 1; |
Elijah Newren | 3c217c0 | 2011-08-11 23:20:09 -0600 | [diff] [blame] | 3091 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3092 | if (merge_mode_and_contents(opt, o, a, b, path, |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3093 | opt->branch1, opt->branch2, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3094 | opt->priv->call_depth * 2, mfi)) |
Johannes Schindelin | 3c8a51e | 2016-07-26 18:06:10 +0200 | [diff] [blame] | 3095 | return -1; |
Elijah Newren | 4ab9a15 | 2010-09-20 02:29:07 -0600 | [diff] [blame] | 3096 | |
Elijah Newren | 1de70db | 2018-04-19 10:58:23 -0700 | [diff] [blame] | 3097 | /* |
| 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 Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3103 | if (mfi->clean && was_tracked_and_matches(opt, path, &mfi->blob) && |
Elijah Newren | 1de70db | 2018-04-19 10:58:23 -0700 | [diff] [blame] | 3104 | !df_conflict_remains) { |
Elijah Newren | 2b75fb6 | 2018-07-27 12:59:44 +0000 | [diff] [blame] | 3105 | int pos; |
| 3106 | struct cache_entry *ce; |
| 3107 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3108 | output(opt, 3, _("Skipped %s (merged same as existing)"), path); |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3109 | if (add_cacheinfo(opt, &mfi->blob, path, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3110 | 0, (!opt->priv->call_depth && !is_dirty), 0)) |
Elijah Newren | 1de70db | 2018-04-19 10:58:23 -0700 | [diff] [blame] | 3111 | return -1; |
Elijah Newren | 2b75fb6 | 2018-07-27 12:59:44 +0000 | [diff] [blame] | 3112 | /* |
| 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 Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3118 | pos = index_name_pos(&opt->priv->orig_index, path, strlen(path)); |
| 3119 | ce = opt->priv->orig_index.cache[pos]; |
Elijah Newren | 2b75fb6 | 2018-07-27 12:59:44 +0000 | [diff] [blame] | 3120 | if (ce_skip_worktree(ce)) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3121 | pos = index_name_pos(opt->repo->index, path, strlen(path)); |
| 3122 | ce = opt->repo->index->cache[pos]; |
Elijah Newren | 2b75fb6 | 2018-07-27 12:59:44 +0000 | [diff] [blame] | 3123 | ce->ce_flags |= CE_SKIP_WORKTREE; |
| 3124 | } |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3125 | return mfi->clean; |
Elijah Newren | 05cf21e | 2018-04-19 10:58:22 -0700 | [diff] [blame] | 3126 | } |
Elijah Newren | 0c4918d | 2010-09-20 02:28:52 -0600 | [diff] [blame] | 3127 | |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3128 | if (!mfi->clean) { |
| 3129 | if (S_ISGITLINK(mfi->blob.mode)) |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 3130 | reason = _("submodule"); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3131 | output(opt, 1, _("CONFLICT (%s): Merge conflict in %s"), |
Elijah Newren | 0c4918d | 2010-09-20 02:28:52 -0600 | [diff] [blame] | 3132 | reason, path); |
Elijah Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3133 | if (ci && !df_conflict_remains) |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3134 | if (update_stages(opt, path, o, a, b)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3135 | return -1; |
Elijah Newren | 0c4918d | 2010-09-20 02:28:52 -0600 | [diff] [blame] | 3136 | } |
| 3137 | |
Elijah Newren | bd42380 | 2018-04-19 10:58:17 -0700 | [diff] [blame] | 3138 | if (df_conflict_remains || is_dirty) { |
Elijah Newren | 3d6b8e8 | 2011-08-11 23:19:53 -0600 | [diff] [blame] | 3139 | char *new_path; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3140 | if (opt->priv->call_depth) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3141 | remove_file_from_index(opt->repo->index, path); |
Elijah Newren | 51931bf | 2011-08-11 23:20:06 -0600 | [diff] [blame] | 3142 | } else { |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3143 | if (!mfi->clean) { |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3144 | if (update_stages(opt, path, o, a, b)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3145 | return -1; |
| 3146 | } else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3147 | int file_from_stage2 = was_tracked(opt, path); |
Elijah Newren | 51931bf | 2011-08-11 23:20:06 -0600 | [diff] [blame] | 3148 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3149 | if (update_stages(opt, path, NULL, |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3150 | file_from_stage2 ? &mfi->blob : NULL, |
| 3151 | file_from_stage2 ? NULL : &mfi->blob)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3152 | return -1; |
Elijah Newren | 51931bf | 2011-08-11 23:20:06 -0600 | [diff] [blame] | 3153 | } |
| 3154 | |
| 3155 | } |
Elijah Newren | c336ab8 | 2019-04-05 08:00:20 -0700 | [diff] [blame] | 3156 | new_path = unique_path(opt, path, ci->ren1->branch); |
Elijah Newren | bd42380 | 2018-04-19 10:58:17 -0700 | [diff] [blame] | 3157 | if (is_dirty) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3158 | output(opt, 1, _("Refusing to lose dirty file at %s"), |
Elijah Newren | bd42380 | 2018-04-19 10:58:17 -0700 | [diff] [blame] | 3159 | path); |
| 3160 | } |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3161 | output(opt, 1, _("Adding as %s instead"), new_path); |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3162 | if (update_file(opt, 0, &mfi->blob, new_path)) { |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3163 | free(new_path); |
| 3164 | return -1; |
| 3165 | } |
Elijah Newren | 3d6b8e8 | 2011-08-11 23:19:53 -0600 | [diff] [blame] | 3166 | free(new_path); |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3167 | mfi->clean = 0; |
| 3168 | } else if (update_file(opt, mfi->clean, &mfi->blob, path)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3169 | return -1; |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3170 | return !is_dirty && mfi->clean; |
Elijah Newren | 0c4918d | 2010-09-20 02:28:52 -0600 | [diff] [blame] | 3171 | } |
| 3172 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3173 | static int handle_rename_normal(struct merge_options *opt, |
Elijah Newren | 8ebe7b0 | 2018-06-09 21:16:15 -0700 | [diff] [blame] | 3174 | const char *path, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3175 | const struct diff_filespec *o, |
| 3176 | const struct diff_filespec *a, |
| 3177 | const struct diff_filespec *b, |
Elijah Newren | 8ebe7b0 | 2018-06-09 21:16:15 -0700 | [diff] [blame] | 3178 | struct rename_conflict_info *ci) |
Elijah Newren | 64b1abe | 2018-04-19 10:58:12 -0700 | [diff] [blame] | 3179 | { |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3180 | struct rename *ren = ci->ren1; |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3181 | struct merge_file_info mfi; |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3182 | int clean; |
| 3183 | int side = (ren->branch == opt->branch1 ? 2 : 3); |
| 3184 | |
Elijah Newren | 64b1abe | 2018-04-19 10:58:12 -0700 | [diff] [blame] | 3185 | /* Merge the content and write it out */ |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3186 | clean = handle_content_merge(&mfi, opt, path, was_dirty(opt, path), |
| 3187 | o, a, b, ci); |
| 3188 | |
Derrick Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 3189 | if (clean && |
| 3190 | opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_CONFLICT && |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3191 | 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 | |
| 3202 | static 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 | } |
| 3221 | static 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 Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 3235 | assert(opt->detect_directory_renames > MERGE_DIRECTORY_RENAMES_NONE); |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3236 | 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 Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 3240 | clean = (opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_TRUE); |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3241 | |
| 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3263 | } |
| 3264 | |
| 3265 | /* Per entry merge function */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3266 | static int process_entry(struct merge_options *opt, |
Miklos Vajna | 8a2fce1 | 2008-08-25 16:25:57 +0200 | [diff] [blame] | 3267 | const char *path, struct stage_data *entry) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3268 | { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3269 | int clean_merge = 1; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3270 | int normalize = opt->renormalize; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3271 | |
| 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3279 | |
Elijah Newren | 3734893 | 2010-07-09 07:10:53 -0600 | [diff] [blame] | 3280 | entry->processed = 1; |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 3281 | if (entry->rename_conflict_info) { |
Elijah Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3282 | struct rename_conflict_info *ci = entry->rename_conflict_info; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3283 | struct diff_filespec *temp; |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3284 | 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 Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3288 | |
| 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 Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3301 | switch (ci->rename_type) { |
Elijah Newren | 882fd11 | 2010-09-20 02:29:03 -0600 | [diff] [blame] | 3302 | case RENAME_NORMAL: |
Elijah Newren | 4f66dad | 2011-08-11 23:20:08 -0600 | [diff] [blame] | 3303 | case RENAME_ONE_FILE_TO_ONE: |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3304 | clean_merge = handle_rename_normal(opt, path, o, a, b, |
Elijah Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3305 | ci); |
Elijah Newren | 882fd11 | 2010-09-20 02:29:03 -0600 | [diff] [blame] | 3306 | break; |
Elijah Newren | 5455c33 | 2018-06-09 21:16:14 -0700 | [diff] [blame] | 3307 | case RENAME_VIA_DIR: |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3308 | clean_merge = handle_rename_via_dir(opt, ci); |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3309 | break; |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 3310 | 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 Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3317 | clean_merge = handle_rename_add(opt, ci); |
Elijah Newren | 7f86716 | 2018-11-07 20:40:26 -0800 | [diff] [blame] | 3318 | break; |
Elijah Newren | 3b130adf | 2010-09-20 02:29:02 -0600 | [diff] [blame] | 3319 | case RENAME_DELETE: |
| 3320 | clean_merge = 0; |
Elijah Newren | e2d563d | 2019-04-05 08:00:21 -0700 | [diff] [blame] | 3321 | if (handle_rename_delete(opt, ci)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3322 | clean_merge = -1; |
Elijah Newren | 3b130adf | 2010-09-20 02:29:02 -0600 | [diff] [blame] | 3323 | break; |
Elijah Newren | 07413c5 | 2010-09-20 02:29:00 -0600 | [diff] [blame] | 3324 | case RENAME_ONE_FILE_TO_TWO: |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3325 | /* |
| 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 Newren | 07413c5 | 2010-09-20 02:29:00 -0600 | [diff] [blame] | 3333 | clean_merge = 0; |
Elijah Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3334 | if (handle_rename_rename_1to2(opt, ci)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3335 | clean_merge = -1; |
Elijah Newren | 07413c5 | 2010-09-20 02:29:00 -0600 | [diff] [blame] | 3336 | break; |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 3337 | case RENAME_TWO_FILES_TO_ONE: |
Elijah Newren | bbafc9c | 2018-11-07 20:40:27 -0800 | [diff] [blame] | 3338 | /* |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3339 | * 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 Newren | bbafc9c | 2018-11-07 20:40:27 -0800 | [diff] [blame] | 3347 | * 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 Newren | 043622b | 2019-04-05 08:00:16 -0700 | [diff] [blame] | 3352 | clean_merge = handle_rename_rename_2to1(opt, ci); |
Elijah Newren | 461f504 | 2011-08-11 23:20:15 -0600 | [diff] [blame] | 3353 | break; |
Elijah Newren | 07413c5 | 2010-09-20 02:29:00 -0600 | [diff] [blame] | 3354 | default: |
| 3355 | entry->processed = 0; |
| 3356 | break; |
| 3357 | } |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3358 | if (path_clean < clean_merge) |
| 3359 | clean_merge = path_clean; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3360 | } else if (o_valid && (!a_valid || !b_valid)) { |
Elijah Newren | 3734893 | 2010-07-09 07:10:53 -0600 | [diff] [blame] | 3361 | /* Case A: Deleted in one */ |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3362 | 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 Newren | 3734893 | 2010-07-09 07:10:53 -0600 | [diff] [blame] | 3365 | /* Deleted in both or deleted in one and |
| 3366 | * unchanged in the other */ |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3367 | if (a_valid) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3368 | output(opt, 2, _("Removing %s"), path); |
Elijah Newren | 3734893 | 2010-07-09 07:10:53 -0600 | [diff] [blame] | 3369 | /* do not touch working file if it did not exist */ |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3370 | remove_file(opt, 1, path, !a_valid); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3371 | } else { |
Elijah Newren | edd2faf | 2011-08-11 23:20:07 -0600 | [diff] [blame] | 3372 | /* Modify/delete; deleted side may have put a directory in the way */ |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3373 | clean_merge = 0; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3374 | if (handle_modify_delete(opt, path, o, a, b)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3375 | clean_merge = -1; |
Miklos Vajna | 8a2fce1 | 2008-08-25 16:25:57 +0200 | [diff] [blame] | 3376 | } |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3377 | } else if ((!o_valid && a_valid && !b_valid) || |
| 3378 | (!o_valid && !a_valid && b_valid)) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3379 | /* Case B: Added in one. */ |
Elijah Newren | edd2faf | 2011-08-11 23:20:07 -0600 | [diff] [blame] | 3380 | /* [nothing|directory] -> ([nothing|directory], file) */ |
Miklos Vajna | 8a2fce1 | 2008-08-25 16:25:57 +0200 | [diff] [blame] | 3381 | |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3382 | const char *add_branch; |
| 3383 | const char *other_branch; |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3384 | const char *conf; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3385 | const struct diff_filespec *contents; |
Elijah Newren | 3734893 | 2010-07-09 07:10:53 -0600 | [diff] [blame] | 3386 | |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3387 | if (a_valid) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3388 | add_branch = opt->branch1; |
| 3389 | other_branch = opt->branch2; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3390 | contents = a; |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 3391 | conf = _("file/directory"); |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3392 | } else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3393 | add_branch = opt->branch2; |
| 3394 | other_branch = opt->branch1; |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3395 | contents = b; |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 3396 | conf = _("directory/file"); |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3397 | } |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3398 | if (dir_in_way(opt->repo->index, path, |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3399 | !opt->priv->call_depth && !S_ISGITLINK(a->mode), |
Elijah Newren | c641ca6 | 2017-11-14 09:31:24 -0800 | [diff] [blame] | 3400 | 0)) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3401 | char *new_path = unique_path(opt, path, add_branch); |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3402 | clean_merge = 0; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3403 | output(opt, 1, _("CONFLICT (%s): There is a directory with name %s in %s. " |
Jiang Xin | 55653a6 | 2012-07-25 22:53:13 +0800 | [diff] [blame] | 3404 | "Adding %s as %s"), |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3405 | conf, path, other_branch, path, new_path); |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3406 | if (update_file(opt, 0, contents, new_path)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3407 | clean_merge = -1; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3408 | else if (opt->priv->call_depth) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3409 | remove_file_from_index(opt->repo->index, path); |
Elijah Newren | 3d6b8e8 | 2011-08-11 23:19:53 -0600 | [diff] [blame] | 3410 | free(new_path); |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3411 | } else { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3412 | output(opt, 2, _("Adding %s"), path); |
Elijah Newren | 35a74ab | 2011-08-11 23:20:27 -0600 | [diff] [blame] | 3413 | /* do not overwrite file if already present */ |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3414 | if (update_file_flags(opt, contents, path, 1, !a_valid)) |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3415 | clean_merge = -1; |
Elijah Newren | 9c0bbb5 | 2010-09-20 02:28:56 -0600 | [diff] [blame] | 3416 | } |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3417 | } else if (a_valid && b_valid) { |
| 3418 | if (!o_valid) { |
Elijah Newren | dcf2815 | 2018-11-07 20:40:28 -0800 | [diff] [blame] | 3419 | /* Case C: Added in both (check for same permissions) */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3420 | output(opt, 1, |
Elijah Newren | dcf2815 | 2018-11-07 20:40:28 -0800 | [diff] [blame] | 3421 | _("CONFLICT (add/add): Merge conflict in %s"), |
| 3422 | path); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3423 | clean_merge = handle_file_collision(opt, |
Elijah Newren | dcf2815 | 2018-11-07 20:40:28 -0800 | [diff] [blame] | 3424 | path, NULL, NULL, |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3425 | opt->branch1, |
| 3426 | opt->branch2, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3427 | a, b); |
Elijah Newren | dcf2815 | 2018-11-07 20:40:28 -0800 | [diff] [blame] | 3428 | } else { |
| 3429 | /* case D: Modified in both, but differently. */ |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3430 | struct merge_file_info mfi; |
Elijah Newren | dcf2815 | 2018-11-07 20:40:28 -0800 | [diff] [blame] | 3431 | int is_dirty = 0; /* unpack_trees would have bailed if dirty */ |
Elijah Newren | e62d112 | 2019-04-05 08:00:25 -0700 | [diff] [blame] | 3432 | clean_merge = handle_content_merge(&mfi, opt, path, |
Elijah Newren | dcf2815 | 2018-11-07 20:40:28 -0800 | [diff] [blame] | 3433 | is_dirty, |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3434 | o, a, b, NULL); |
Elijah Newren | dcf2815 | 2018-11-07 20:40:28 -0800 | [diff] [blame] | 3435 | } |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3436 | } else if (!o_valid && !a_valid && !b_valid) { |
Elijah Newren | edd2faf | 2011-08-11 23:20:07 -0600 | [diff] [blame] | 3437 | /* |
| 3438 | * this entry was deleted altogether. a_mode == 0 means |
| 3439 | * we had that path and want to actively remove it. |
| 3440 | */ |
Elijah Newren | 8daec1d | 2019-04-05 08:00:22 -0700 | [diff] [blame] | 3441 | remove_file(opt, 1, path, !a->mode); |
Elijah Newren | edd2faf | 2011-08-11 23:20:07 -0600 | [diff] [blame] | 3442 | } else |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 3443 | BUG("fatal merge failure, shouldn't happen."); |
Elijah Newren | 3734893 | 2010-07-09 07:10:53 -0600 | [diff] [blame] | 3444 | |
| 3445 | return clean_merge; |
| 3446 | } |
| 3447 | |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3448 | static int merge_trees_internal(struct merge_options *opt, |
| 3449 | struct tree *head, |
| 3450 | struct tree *merge, |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3451 | struct tree *merge_base, |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3452 | struct tree **result) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3453 | { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3454 | struct index_state *istate = opt->repo->index; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3455 | int code, clean; |
| 3456 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3457 | if (opt->subtree_shift) { |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3458 | 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3462 | } |
| 3463 | |
Elijah Newren | 763a59e | 2020-01-01 05:20:57 +0000 | [diff] [blame] | 3464 | if (oideq(&merge_base->object.oid, &merge->object.oid)) { |
Eric Sunshine | 80cde95 | 2021-05-02 01:14:22 -0400 | [diff] [blame] | 3465 | output(opt, 0, _("Already up to date.")); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3466 | *result = head; |
| 3467 | return 1; |
| 3468 | } |
| 3469 | |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3470 | code = unpack_trees_start(opt, merge_base, head, merge); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3471 | |
Junio C Hamano | fadd069 | 2009-09-07 22:43:11 -0700 | [diff] [blame] | 3472 | if (code != 0) { |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3473 | if (show(opt, 4) || opt->priv->call_depth) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3474 | err(opt, _("merging of trees %s and %s failed"), |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 3475 | oid_to_hex(&head->object.oid), |
| 3476 | oid_to_hex(&merge->object.oid)); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3477 | unpack_trees_finish(opt); |
Johannes Schindelin | 6003303 | 2016-07-26 18:06:26 +0200 | [diff] [blame] | 3478 | return -1; |
Junio C Hamano | fadd069 | 2009-09-07 22:43:11 -0700 | [diff] [blame] | 3479 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3480 | |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 3481 | if (unmerged_index(istate)) { |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 3482 | struct string_list *entries; |
| 3483 | struct rename_info re_info; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3484 | int i; |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 3485 | /* |
| 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 Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3492 | hashmap_init(&opt->priv->current_file_dir_set, path_hashmap_cmp, |
Elijah Newren | 4d7101e | 2019-08-17 11:41:33 -0700 | [diff] [blame] | 3493 | NULL, 512); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3494 | get_files_dirs(opt, head); |
| 3495 | get_files_dirs(opt, merge); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3496 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3497 | entries = get_unmerged(opt->repo->index); |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3498 | clean = detect_and_process_renames(opt, merge_base, head, merge, |
Elijah Newren | 8ebe7b0 | 2018-06-09 21:16:15 -0700 | [diff] [blame] | 3499 | entries, &re_info); |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3500 | record_df_conflict_files(opt, entries); |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3501 | if (clean < 0) |
Kevin Willford | e336bdc | 2017-08-28 14:28:27 -0600 | [diff] [blame] | 3502 | goto cleanup; |
Elijah Newren | edd2faf | 2011-08-11 23:20:07 -0600 | [diff] [blame] | 3503 | for (i = entries->nr-1; 0 <= i; i--) { |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3504 | const char *path = entries->items[i].string; |
| 3505 | struct stage_data *e = entries->items[i].util; |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3506 | if (!e->processed) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3507 | int ret = process_entry(opt, path, e); |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3508 | if (!ret) |
| 3509 | clean = 0; |
Kevin Willford | e336bdc | 2017-08-28 14:28:27 -0600 | [diff] [blame] | 3510 | else if (ret < 0) { |
| 3511 | clean = ret; |
| 3512 | goto cleanup; |
| 3513 | } |
Johannes Schindelin | 75456f9 | 2016-07-26 18:06:21 +0200 | [diff] [blame] | 3514 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3515 | } |
Elijah Newren | 3734893 | 2010-07-09 07:10:53 -0600 | [diff] [blame] | 3516 | for (i = 0; i < entries->nr; i++) { |
Junio C Hamano | 7edba4c | 2010-09-20 02:28:35 -0600 | [diff] [blame] | 3517 | struct stage_data *e = entries->items[i].util; |
| 3518 | if (!e->processed) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 3519 | BUG("unprocessed path??? %s", |
Junio C Hamano | 7edba4c | 2010-09-20 02:28:35 -0600 | [diff] [blame] | 3520 | entries->items[i].string); |
| 3521 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3522 | |
Elijah Newren | 9366536 | 2018-06-09 21:16:13 -0700 | [diff] [blame] | 3523 | cleanup: |
Elijah Newren | ffc16c4 | 2018-04-19 10:58:04 -0700 | [diff] [blame] | 3524 | final_cleanup_renames(&re_info); |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 3525 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3526 | string_list_clear(entries, 1); |
Elijah Newren | f172589 | 2018-04-19 10:58:00 -0700 | [diff] [blame] | 3527 | free(entries); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3528 | |
Elijah Newren | 6da1a25 | 2020-11-02 18:55:05 +0000 | [diff] [blame] | 3529 | hashmap_clear_and_free(&opt->priv->current_file_dir_set, |
Eric Wong | c8e424c | 2019-10-06 23:30:40 +0000 | [diff] [blame] | 3530 | struct path_hashmap_entry, e); |
Kevin Willford | fc65b00 | 2017-09-07 10:25:56 -0600 | [diff] [blame] | 3531 | |
Elijah Newren | 3f1c1c3 | 2018-05-20 12:17:35 +0200 | [diff] [blame] | 3532 | if (clean < 0) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3533 | unpack_trees_finish(opt); |
Kevin Willford | e336bdc | 2017-08-28 14:28:27 -0600 | [diff] [blame] | 3534 | return clean; |
Elijah Newren | 3f1c1c3 | 2018-05-20 12:17:35 +0200 | [diff] [blame] | 3535 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3536 | } |
| 3537 | else |
| 3538 | clean = 1; |
| 3539 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3540 | unpack_trees_finish(opt); |
Elijah Newren | a35edc8 | 2018-04-19 10:58:20 -0700 | [diff] [blame] | 3541 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3542 | if (opt->priv->call_depth && |
Elijah Newren | 724dd76 | 2019-08-17 11:41:32 -0700 | [diff] [blame] | 3543 | !(*result = write_in_core_index_as_tree(opt->repo))) |
Johannes Schindelin | fbc87eb | 2016-07-26 18:06:17 +0200 | [diff] [blame] | 3544 | return -1; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3545 | |
| 3546 | return clean; |
| 3547 | } |
| 3548 | |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3549 | /* |
Elijah Newren | 56e7434 | 2020-08-02 03:14:27 +0000 | [diff] [blame] | 3550 | * 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3553 | */ |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3554 | static int merge_recursive_internal(struct merge_options *opt, |
| 3555 | struct commit *h1, |
| 3556 | struct commit *h2, |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3557 | struct commit_list *merge_bases, |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3558 | struct commit **result) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3559 | { |
| 3560 | struct commit_list *iter; |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3561 | struct commit *merged_merge_bases; |
Elijah Newren | bab5687 | 2019-08-17 11:41:35 -0700 | [diff] [blame] | 3562 | struct tree *result_tree; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3563 | int clean; |
Elijah Newren | 743474c | 2019-08-17 11:41:24 -0700 | [diff] [blame] | 3564 | const char *ancestor_name; |
| 3565 | struct strbuf merge_base_abbrev = STRBUF_INIT; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3566 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3567 | if (show(opt, 4)) { |
| 3568 | output(opt, 4, _("Merging:")); |
| 3569 | output_commit_title(opt, h1); |
| 3570 | output_commit_title(opt, h2); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3571 | } |
| 3572 | |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3573 | if (!merge_bases) { |
| 3574 | merge_bases = get_merge_bases(h1, h2); |
| 3575 | merge_bases = reverse_commit_list(merge_bases); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3576 | } |
| 3577 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3578 | if (show(opt, 5)) { |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3579 | unsigned cnt = commit_list_count(merge_bases); |
Ralf Thielow | e0453cd | 2012-08-05 19:56:38 +0200 | [diff] [blame] | 3580 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3581 | output(opt, 5, Q_("found %u common ancestor:", |
Ralf Thielow | e0453cd | 2012-08-05 19:56:38 +0200 | [diff] [blame] | 3582 | "found %u common ancestors:", cnt), cnt); |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3583 | for (iter = merge_bases; iter; iter = iter->next) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3584 | output_commit_title(opt, iter->item); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3585 | } |
| 3586 | |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3587 | merged_merge_bases = pop_commit(&merge_bases); |
| 3588 | if (merged_merge_bases == NULL) { |
Jonathan Nieder | 03f622c | 2011-08-16 13:27:39 -0500 | [diff] [blame] | 3589 | /* if there is no common ancestor, use an empty tree */ |
| 3590 | struct tree *tree; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3591 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3592 | tree = lookup_tree(opt->repo, opt->repo->hash_algo->empty_tree); |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3593 | merged_merge_bases = make_virtual_commit(opt->repo, tree, |
| 3594 | "ancestor"); |
Elijah Newren | 743474c | 2019-08-17 11:41:24 -0700 | [diff] [blame] | 3595 | ancestor_name = "empty tree"; |
Elijah Newren | b657047 | 2019-10-07 08:52:11 -0700 | [diff] [blame] | 3596 | } else if (opt->ancestor && !opt->priv->call_depth) { |
Elijah Newren | 8e4ec33 | 2019-10-01 11:17:27 -0700 | [diff] [blame] | 3597 | ancestor_name = opt->ancestor; |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3598 | } else if (merge_bases) { |
Elijah Newren | 743474c | 2019-08-17 11:41:24 -0700 | [diff] [blame] | 3599 | ancestor_name = "merged common ancestors"; |
| 3600 | } else { |
| 3601 | strbuf_add_unique_abbrev(&merge_base_abbrev, |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3602 | &merged_merge_bases->object.oid, |
Elijah Newren | 743474c | 2019-08-17 11:41:24 -0700 | [diff] [blame] | 3603 | DEFAULT_ABBREV); |
| 3604 | ancestor_name = merge_base_abbrev.buf; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3605 | } |
| 3606 | |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3607 | for (iter = merge_bases; iter; iter = iter->next) { |
Miklos Vajna | 8a2fce1 | 2008-08-25 16:25:57 +0200 | [diff] [blame] | 3608 | const char *saved_b1, *saved_b2; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3609 | opt->priv->call_depth++; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3610 | /* |
| 3611 | * When the merge fails, the result contains files |
| 3612 | * with conflict markers. The cleanness flag is |
Johannes Schindelin | de8946d | 2016-07-26 18:06:07 +0200 | [diff] [blame] | 3613 | * 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 Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3617 | */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3618 | 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 Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3623 | if (merge_recursive_internal(opt, merged_merge_bases, iter->item, |
| 3624 | NULL, &merged_merge_bases) < 0) |
Johannes Schindelin | de8946d | 2016-07-26 18:06:07 +0200 | [diff] [blame] | 3625 | return -1; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3626 | opt->branch1 = saved_b1; |
| 3627 | opt->branch2 = saved_b2; |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3628 | opt->priv->call_depth--; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3629 | |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3630 | if (!merged_merge_bases) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3631 | return err(opt, _("merge returned no commit")); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3632 | } |
| 3633 | |
Elijah Newren | 816147e | 2021-03-20 00:03:53 +0000 | [diff] [blame] | 3634 | /* |
| 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3643 | discard_index(opt->repo->index); |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3644 | if (!opt->priv->call_depth) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3645 | repo_read_index(opt->repo); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3646 | |
Elijah Newren | 743474c | 2019-08-17 11:41:24 -0700 | [diff] [blame] | 3647 | opt->ancestor = ancestor_name; |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3648 | 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 Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3652 | merged_merge_bases), |
Elijah Newren | bab5687 | 2019-08-17 11:41:35 -0700 | [diff] [blame] | 3653 | &result_tree); |
Elijah Newren | 743474c | 2019-08-17 11:41:24 -0700 | [diff] [blame] | 3654 | strbuf_release(&merge_base_abbrev); |
Elijah Newren | b657047 | 2019-10-07 08:52:11 -0700 | [diff] [blame] | 3655 | opt->ancestor = NULL; /* avoid accidental re-use of opt->ancestor */ |
Johannes Schindelin | 6999bc7 | 2016-08-01 13:44:57 +0200 | [diff] [blame] | 3656 | if (clean < 0) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3657 | flush_output(opt); |
Johannes Schindelin | de8946d | 2016-07-26 18:06:07 +0200 | [diff] [blame] | 3658 | return clean; |
Johannes Schindelin | 6999bc7 | 2016-08-01 13:44:57 +0200 | [diff] [blame] | 3659 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3660 | |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3661 | if (opt->priv->call_depth) { |
Elijah Newren | bab5687 | 2019-08-17 11:41:35 -0700 | [diff] [blame] | 3662 | *result = make_virtual_commit(opt->repo, result_tree, |
| 3663 | "merged tree"); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3664 | commit_list_insert(h1, &(*result)->parents); |
| 3665 | commit_list_insert(h2, &(*result)->parents->next); |
| 3666 | } |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3667 | return clean; |
| 3668 | } |
| 3669 | |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3670 | static int merge_start(struct merge_options *opt, struct tree *head) |
| 3671 | { |
| 3672 | struct strbuf sb = STRBUF_INIT; |
| 3673 | |
Elijah Newren | 45ef16f | 2019-08-17 11:41:43 -0700 | [diff] [blame] | 3674 | /* 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 Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3698 | 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é Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 3705 | CALLOC_ARRAY(opt->priv, 1); |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3706 | string_list_init(&opt->priv->df_conflict_file_set, 1); |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3707 | return 0; |
| 3708 | } |
| 3709 | |
| 3710 | static void merge_finalize(struct merge_options *opt) |
| 3711 | { |
Elijah Newren | e95e481 | 2019-08-17 11:41:40 -0700 | [diff] [blame] | 3712 | flush_output(opt); |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3713 | if (!opt->priv->call_depth && opt->buffer_output < 2) |
Elijah Newren | e95e481 | 2019-08-17 11:41:40 -0700 | [diff] [blame] | 3714 | strbuf_release(&opt->obuf); |
Elijah Newren | 345480d | 2019-08-17 11:41:31 -0700 | [diff] [blame] | 3715 | if (show(opt, 2)) |
| 3716 | diff_warn_rename_limit("merge.renamelimit", |
Elijah Newren | 5bf7e57 | 2019-08-17 11:41:41 -0700 | [diff] [blame] | 3717 | opt->priv->needed_rename_limit, 0); |
| 3718 | FREE_AND_NULL(opt->priv); |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3719 | } |
| 3720 | |
| 3721 | int merge_trees(struct merge_options *opt, |
| 3722 | struct tree *head, |
| 3723 | struct tree *merge, |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3724 | struct tree *merge_base) |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3725 | { |
| 3726 | int clean; |
Elijah Newren | b4db8a2 | 2019-08-17 11:41:30 -0700 | [diff] [blame] | 3727 | struct tree *ignored; |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3728 | |
| 3729 | assert(opt->ancestor != NULL); |
| 3730 | |
| 3731 | if (merge_start(opt, head)) |
| 3732 | return -1; |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3733 | clean = merge_trees_internal(opt, head, merge, merge_base, &ignored); |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3734 | merge_finalize(opt); |
| 3735 | |
| 3736 | return clean; |
| 3737 | } |
| 3738 | |
| 3739 | int merge_recursive(struct merge_options *opt, |
| 3740 | struct commit *h1, |
| 3741 | struct commit *h2, |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3742 | struct commit_list *merge_bases, |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3743 | struct commit **result) |
| 3744 | { |
| 3745 | int clean; |
| 3746 | |
Elijah Newren | 8e4ec33 | 2019-10-01 11:17:27 -0700 | [diff] [blame] | 3747 | assert(opt->ancestor == NULL || |
| 3748 | !strcmp(opt->ancestor, "constructed merge base")); |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3749 | |
| 3750 | if (merge_start(opt, repo_get_commit_tree(opt->repo, h1))) |
| 3751 | return -1; |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3752 | clean = merge_recursive_internal(opt, h1, h2, merge_bases, result); |
Elijah Newren | 98a1d3d | 2019-08-17 11:41:29 -0700 | [diff] [blame] | 3753 | merge_finalize(opt); |
| 3754 | |
| 3755 | return clean; |
| 3756 | } |
| 3757 | |
Elijah Newren | 4d7101e | 2019-08-17 11:41:33 -0700 | [diff] [blame] | 3758 | static struct commit *get_ref(struct repository *repo, |
| 3759 | const struct object_id *oid, |
Nguyễn Thái Ngọc Duy | d7cf3a9 | 2019-01-12 09:13:30 +0700 | [diff] [blame] | 3760 | const char *name) |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3761 | { |
| 3762 | struct object *object; |
| 3763 | |
Nguyễn Thái Ngọc Duy | d7cf3a9 | 2019-01-12 09:13:30 +0700 | [diff] [blame] | 3764 | object = deref_tag(repo, parse_object(repo, oid), |
| 3765 | name, strlen(name)); |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3766 | if (!object) |
| 3767 | return NULL; |
| 3768 | if (object->type == OBJ_TREE) |
Nguyễn Thái Ngọc Duy | d7cf3a9 | 2019-01-12 09:13:30 +0700 | [diff] [blame] | 3769 | return make_virtual_commit(repo, (struct tree*)object, name); |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3770 | 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 Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3777 | int merge_recursive_generic(struct merge_options *opt, |
brian m. carlson | 4e8161a | 2016-06-24 23:09:28 +0000 | [diff] [blame] | 3778 | const struct object_id *head, |
| 3779 | const struct object_id *merge, |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3780 | int num_merge_bases, |
| 3781 | const struct object_id **merge_bases, |
Miklos Vajna | 8a2fce1 | 2008-08-25 16:25:57 +0200 | [diff] [blame] | 3782 | struct commit **result) |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3783 | { |
Nguyễn Thái Ngọc Duy | 03b8664 | 2014-06-13 19:19:23 +0700 | [diff] [blame] | 3784 | int clean; |
Martin Ågren | 837e34e | 2017-10-05 22:32:04 +0200 | [diff] [blame] | 3785 | struct lock_file lock = LOCK_INIT; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3786 | struct commit *head_commit = get_ref(opt->repo, head, opt->branch1); |
| 3787 | struct commit *next_commit = get_ref(opt->repo, merge, opt->branch2); |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3788 | struct commit_list *ca = NULL; |
| 3789 | |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3790 | if (merge_bases) { |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3791 | int i; |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3792 | for (i = 0; i < num_merge_bases; ++i) { |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3793 | struct commit *base; |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3794 | if (!(base = get_ref(opt->repo, merge_bases[i], |
| 3795 | oid_to_hex(merge_bases[i])))) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3796 | return err(opt, _("Could not parse object '%s'"), |
Elijah Newren | ff1bfa2 | 2019-08-17 11:41:34 -0700 | [diff] [blame] | 3797 | oid_to_hex(merge_bases[i])); |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3798 | commit_list_insert(base, &ca); |
| 3799 | } |
Elijah Newren | 8e4ec33 | 2019-10-01 11:17:27 -0700 | [diff] [blame] | 3800 | if (num_merge_bases == 1) |
| 3801 | opt->ancestor = "constructed merge base"; |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3802 | } |
| 3803 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3804 | repo_hold_locked_index(opt->repo, &lock, LOCK_DIE_ON_ERROR); |
| 3805 | clean = merge_recursive(opt, head_commit, next_commit, ca, |
Elijah Newren | d90e759 | 2018-06-09 21:16:12 -0700 | [diff] [blame] | 3806 | result); |
Martin Ågren | 51d3f43 | 2018-02-28 20:07:56 +0100 | [diff] [blame] | 3807 | if (clean < 0) { |
| 3808 | rollback_lock_file(&lock); |
Johannes Schindelin | de8946d | 2016-07-26 18:06:07 +0200 | [diff] [blame] | 3809 | return clean; |
Martin Ågren | 51d3f43 | 2018-02-28 20:07:56 +0100 | [diff] [blame] | 3810 | } |
Johannes Schindelin | de8946d | 2016-07-26 18:06:07 +0200 | [diff] [blame] | 3811 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3812 | if (write_locked_index(opt->repo->index, &lock, |
Martin Ågren | 6100081 | 2018-03-01 21:40:20 +0100 | [diff] [blame] | 3813 | COMMIT_LOCK | SKIP_IF_UNCHANGED)) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3814 | return err(opt, _("Unable to write index.")); |
Stephan Beyer | 73118f8 | 2008-08-12 22:13:59 +0200 | [diff] [blame] | 3815 | |
| 3816 | return clean ? 0 : 1; |
| 3817 | } |
| 3818 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3819 | static void merge_recursive_config(struct merge_options *opt) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3820 | { |
Ben Peart | 85b4603 | 2018-05-02 16:01:14 +0000 | [diff] [blame] | 3821 | char *value = NULL; |
Elijah Newren | 8d55225 | 2020-08-03 18:41:19 +0000 | [diff] [blame] | 3822 | int renormalize = 0; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3823 | git_config_get_int("merge.verbosity", &opt->verbosity); |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 3824 | git_config_get_int("diff.renamelimit", &opt->rename_limit); |
| 3825 | git_config_get_int("merge.renamelimit", &opt->rename_limit); |
Elijah Newren | 8d55225 | 2020-08-03 18:41:19 +0000 | [diff] [blame] | 3826 | git_config_get_bool("merge.renormalize", &renormalize); |
| 3827 | opt->renormalize = renormalize; |
Ben Peart | 85b4603 | 2018-05-02 16:01:14 +0000 | [diff] [blame] | 3828 | if (!git_config_get_string("diff.renames", &value)) { |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 3829 | opt->detect_renames = git_config_rename("diff.renames", value); |
Ben Peart | 85b4603 | 2018-05-02 16:01:14 +0000 | [diff] [blame] | 3830 | free(value); |
| 3831 | } |
| 3832 | if (!git_config_get_string("merge.renames", &value)) { |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 3833 | opt->detect_renames = git_config_rename("merge.renames", value); |
Ben Peart | 85b4603 | 2018-05-02 16:01:14 +0000 | [diff] [blame] | 3834 | free(value); |
| 3835 | } |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3836 | if (!git_config_get_string("merge.directoryrenames", &value)) { |
| 3837 | int boolval = git_parse_maybe_bool(value); |
| 3838 | if (0 <= boolval) { |
Derrick Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 3839 | opt->detect_directory_renames = boolval ? |
| 3840 | MERGE_DIRECTORY_RENAMES_TRUE : |
| 3841 | MERGE_DIRECTORY_RENAMES_NONE; |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3842 | } else if (!strcasecmp(value, "conflict")) { |
Derrick Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 3843 | opt->detect_directory_renames = |
| 3844 | MERGE_DIRECTORY_RENAMES_CONFLICT; |
Elijah Newren | 8c8e5bd | 2019-04-05 08:00:26 -0700 | [diff] [blame] | 3845 | } /* avoid erroring on values from future versions of git */ |
Tanay Abhra | 0e7bcb1 | 2014-08-13 01:22:01 -0700 | [diff] [blame] | 3846 | free(value); |
| 3847 | } |
| 3848 | git_config(git_xmerge_config, NULL); |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3849 | } |
| 3850 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3851 | void init_merge_options(struct merge_options *opt, |
Nguyễn Thái Ngọc Duy | 0d6caa2 | 2019-01-12 09:13:29 +0700 | [diff] [blame] | 3852 | struct repository *repo) |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3853 | { |
Andrey Okoshkin | 8048622 | 2017-10-31 12:09:13 +0300 | [diff] [blame] | 3854 | const char *merge_verbosity; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3855 | memset(opt, 0, sizeof(struct merge_options)); |
Elijah Newren | a779fb8 | 2019-08-17 11:41:39 -0700 | [diff] [blame] | 3856 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3857 | opt->repo = repo; |
Elijah Newren | a779fb8 | 2019-08-17 11:41:39 -0700 | [diff] [blame] | 3858 | |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 3859 | opt->detect_renames = -1; |
Derrick Stolee | 8e01251 | 2019-08-17 11:41:25 -0700 | [diff] [blame] | 3860 | opt->detect_directory_renames = MERGE_DIRECTORY_RENAMES_CONFLICT; |
Elijah Newren | a779fb8 | 2019-08-17 11:41:39 -0700 | [diff] [blame] | 3861 | opt->rename_limit = -1; |
| 3862 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3863 | opt->verbosity = 2; |
| 3864 | opt->buffer_output = 1; |
Elijah Newren | a779fb8 | 2019-08-17 11:41:39 -0700 | [diff] [blame] | 3865 | strbuf_init(&opt->obuf, 0); |
| 3866 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3867 | opt->renormalize = 0; |
Elijah Newren | a779fb8 | 2019-08-17 11:41:39 -0700 | [diff] [blame] | 3868 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3869 | merge_recursive_config(opt); |
Andrey Okoshkin | 8048622 | 2017-10-31 12:09:13 +0300 | [diff] [blame] | 3870 | merge_verbosity = getenv("GIT_MERGE_VERBOSITY"); |
| 3871 | if (merge_verbosity) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3872 | opt->verbosity = strtol(merge_verbosity, NULL, 10); |
| 3873 | if (opt->verbosity >= 5) |
| 3874 | opt->buffer_output = 0; |
Miklos Vajna | 9047ebb | 2008-08-12 18:45:14 +0200 | [diff] [blame] | 3875 | } |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3876 | |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3877 | int parse_merge_opt(struct merge_options *opt, const char *s) |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3878 | { |
Jeff King | 95b567c | 2014-06-18 15:48:29 -0400 | [diff] [blame] | 3879 | const char *arg; |
| 3880 | |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3881 | if (!s || !*s) |
| 3882 | return -1; |
| 3883 | if (!strcmp(s, "ours")) |
Elijah Newren | f3081da | 2019-08-17 11:41:42 -0700 | [diff] [blame] | 3884 | opt->recursive_variant = MERGE_VARIANT_OURS; |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3885 | else if (!strcmp(s, "theirs")) |
Elijah Newren | f3081da | 2019-08-17 11:41:42 -0700 | [diff] [blame] | 3886 | opt->recursive_variant = MERGE_VARIANT_THEIRS; |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3887 | else if (!strcmp(s, "subtree")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3888 | opt->subtree_shift = ""; |
Jeff King | 95b567c | 2014-06-18 15:48:29 -0400 | [diff] [blame] | 3889 | else if (skip_prefix(s, "subtree=", &arg)) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3890 | opt->subtree_shift = arg; |
Justin Frankel | 58a1ece | 2010-08-26 00:50:45 -0500 | [diff] [blame] | 3891 | else if (!strcmp(s, "patience")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3892 | opt->xdl_opts = DIFF_WITH_ALG(opt, PATIENCE_DIFF); |
Tay Ray Chuan | 8c912ee | 2011-07-12 14:10:25 +0800 | [diff] [blame] | 3893 | else if (!strcmp(s, "histogram")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3894 | opt->xdl_opts = DIFF_WITH_ALG(opt, HISTOGRAM_DIFF); |
Jeff King | 95b567c | 2014-06-18 15:48:29 -0400 | [diff] [blame] | 3895 | else if (skip_prefix(s, "diff-algorithm=", &arg)) { |
| 3896 | long value = parse_algorithm_value(arg); |
Michal Privoznik | 07924d4 | 2013-01-16 08:51:58 +0100 | [diff] [blame] | 3897 | if (value < 0) |
| 3898 | return -1; |
| 3899 | /* clear out previous settings */ |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3900 | DIFF_XDL_CLR(opt, NEED_MINIMAL); |
| 3901 | opt->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK; |
| 3902 | opt->xdl_opts |= value; |
Michal Privoznik | 07924d4 | 2013-01-16 08:51:58 +0100 | [diff] [blame] | 3903 | } |
Justin Frankel | 4e5dd04 | 2010-08-26 00:51:47 -0500 | [diff] [blame] | 3904 | else if (!strcmp(s, "ignore-space-change")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3905 | DIFF_XDL_SET(opt, IGNORE_WHITESPACE_CHANGE); |
Justin Frankel | 4e5dd04 | 2010-08-26 00:51:47 -0500 | [diff] [blame] | 3906 | else if (!strcmp(s, "ignore-all-space")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3907 | DIFF_XDL_SET(opt, IGNORE_WHITESPACE); |
Justin Frankel | 4e5dd04 | 2010-08-26 00:51:47 -0500 | [diff] [blame] | 3908 | else if (!strcmp(s, "ignore-space-at-eol")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3909 | DIFF_XDL_SET(opt, IGNORE_WHITESPACE_AT_EOL); |
Junio C Hamano | e9282f0 | 2017-10-26 15:32:27 +0900 | [diff] [blame] | 3910 | else if (!strcmp(s, "ignore-cr-at-eol")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3911 | DIFF_XDL_SET(opt, IGNORE_CR_AT_EOL); |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3912 | else if (!strcmp(s, "renormalize")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3913 | opt->renormalize = 1; |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3914 | else if (!strcmp(s, "no-renormalize")) |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3915 | opt->renormalize = 0; |
Felipe Gonçalves Assis | d2b11ec | 2016-02-17 01:15:25 -0200 | [diff] [blame] | 3916 | else if (!strcmp(s, "no-renames")) |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 3917 | opt->detect_renames = 0; |
Felipe Gonçalves Assis | 87892f6 | 2016-02-21 19:59:05 -0300 | [diff] [blame] | 3918 | else if (!strcmp(s, "find-renames")) { |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 3919 | opt->detect_renames = 1; |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3920 | opt->rename_score = 0; |
Felipe Gonçalves Assis | 87892f6 | 2016-02-21 19:59:05 -0300 | [diff] [blame] | 3921 | } |
Felipe Gonçalves Assis | 1b47ad1 | 2016-02-17 01:15:26 -0200 | [diff] [blame] | 3922 | else if (skip_prefix(s, "find-renames=", &arg) || |
| 3923 | skip_prefix(s, "rename-threshold=", &arg)) { |
Elijah Newren | 259ccb6 | 2019-04-05 08:00:13 -0700 | [diff] [blame] | 3924 | if ((opt->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0) |
Kevin Ballard | 10ae752 | 2010-09-27 16:58:25 -0700 | [diff] [blame] | 3925 | return -1; |
Elijah Newren | 8599ab4 | 2019-08-17 11:41:38 -0700 | [diff] [blame] | 3926 | opt->detect_renames = 1; |
Kevin Ballard | 10ae752 | 2010-09-27 16:58:25 -0700 | [diff] [blame] | 3927 | } |
Nguyễn Thái Ngọc Duy | 5a59a23 | 2019-02-16 18:24:41 +0700 | [diff] [blame] | 3928 | /* |
| 3929 | * Please update $__git_merge_strategy_options in |
| 3930 | * git-completion.bash when you add new options |
| 3931 | */ |
Jonathan Nieder | 635a7bb | 2010-08-26 00:47:58 -0500 | [diff] [blame] | 3932 | else |
| 3933 | return -1; |
| 3934 | return 0; |
| 3935 | } |