#include "merge-recursive.h"
#include "dir.h"
#include "submodule.h"
+#include "revision.h"
struct path_hashmap_entry {
struct hashmap_entry e;
return ignore_case ? strihash(path) : strhash(path);
}
-static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap,
- char *dir)
-{
- struct dir_rename_entry key;
-
- if (dir == NULL)
- return NULL;
- hashmap_entry_init(&key, strhash(dir));
- key.dir = dir;
- return hashmap_get(hashmap, &key, NULL);
-}
-
-static int dir_rename_cmp(const void *unused_cmp_data,
- const void *entry,
- const void *entry_or_key,
- const void *unused_keydata)
-{
- const struct dir_rename_entry *e1 = entry;
- const struct dir_rename_entry *e2 = entry_or_key;
-
- return strcmp(e1->dir, e2->dir);
-}
-
-static void dir_rename_init(struct hashmap *map)
-{
- hashmap_init(map, dir_rename_cmp, NULL, 0);
-}
-
-static void dir_rename_entry_init(struct dir_rename_entry *entry,
- char *directory)
-{
- hashmap_entry_init(entry, strhash(directory));
- entry->dir = directory;
- entry->non_unique_new_dir = 0;
- strbuf_init(&entry->new_dir, 0);
- string_list_init(&entry->possible_new_dirs, 0);
-}
-
-static struct collision_entry *collision_find_entry(struct hashmap *hashmap,
- char *target_file)
-{
- struct collision_entry key;
-
- hashmap_entry_init(&key, strhash(target_file));
- key.target_file = target_file;
- return hashmap_get(hashmap, &key, NULL);
-}
-
-static int collision_cmp(void *unused_cmp_data,
- const struct collision_entry *e1,
- const struct collision_entry *e2,
- const void *unused_keydata)
-{
- return strcmp(e1->target_file, e2->target_file);
-}
-
-static void collision_init(struct hashmap *map)
-{
- hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL, 0);
-}
-
static void flush_output(struct merge_options *o)
{
if (o->buffer_output < 2 && o->obuf.len) {
enum rename_type {
RENAME_NORMAL = 0,
- RENAME_DIR,
RENAME_DELETE,
RENAME_ONE_FILE_TO_ONE,
RENAME_ONE_FILE_TO_TWO,
init_tree_desc(desc, tree->buffer, tree->size);
}
-static int git_merge_trees(struct merge_options *o,
+static int git_merge_trees(int index_only,
struct tree *common,
struct tree *head,
struct tree *merge)
{
int rc;
struct tree_desc t[3];
+ struct unpack_trees_options opts;
- memset(&o->unpack_opts, 0, sizeof(o->unpack_opts));
- if (o->call_depth)
- o->unpack_opts.index_only = 1;
+ memset(&opts, 0, sizeof(opts));
+ if (index_only)
+ opts.index_only = 1;
else
- o->unpack_opts.update = 1;
- o->unpack_opts.merge = 1;
- o->unpack_opts.head_idx = 2;
- o->unpack_opts.fn = threeway_merge;
- o->unpack_opts.src_index = &the_index;
- o->unpack_opts.dst_index = &the_index;
- setup_unpack_trees_porcelain(&o->unpack_opts, "merge");
+ opts.update = 1;
+ opts.merge = 1;
+ opts.head_idx = 2;
+ opts.fn = threeway_merge;
+ opts.src_index = &the_index;
+ opts.dst_index = &the_index;
+ setup_unpack_trees_porcelain(&opts, "merge");
init_tree_desc_from_tree(t+0, common);
init_tree_desc_from_tree(t+1, head);
init_tree_desc_from_tree(t+2, merge);
- rc = unpack_trees(3, t, &o->unpack_opts);
- /*
- * unpack_trees NULLifies src_index, but it's used in verify_uptodate,
- * so set to the new index which will usually have modification
- * timestamp info copied over.
- */
- o->unpack_opts.src_index = &the_index;
+ rc = unpack_trees(3, t, &opts);
cache_tree_free(&active_cache_tree);
return rc;
}
read_tree_recursive(tree, "", 0, 0, &match_all, save_files_dirs, o);
}
-static int get_tree_entry_if_blob(struct tree *tree,
- const char *path,
- struct object_id *hashy,
- unsigned int *mode_o)
-{
- int ret;
-
- ret = get_tree_entry(&tree->object.oid, path, hashy, mode_o);
- if (S_ISDIR(*mode_o)) {
- oidcpy(hashy, &null_oid);
- *mode_o = 0;
- }
- return ret;
-}
-
/*
* Returns an index_entry instance which doesn't have to correspond to
* a real cache entry in Git's index.
{
struct string_list_item *item;
struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
- get_tree_entry_if_blob(o, path,
- &e->stages[1].oid, &e->stages[1].mode);
- get_tree_entry_if_blob(a, path,
- &e->stages[2].oid, &e->stages[2].mode);
- get_tree_entry_if_blob(b, path,
- &e->stages[3].oid, &e->stages[3].mode);
+ get_tree_entry(&o->object.oid, path,
+ &e->stages[1].oid, &e->stages[1].mode);
+ get_tree_entry(&a->object.oid, path,
+ &e->stages[2].oid, &e->stages[2].mode);
+ get_tree_entry(&b->object.oid, path,
+ &e->stages[3].oid, &e->stages[3].mode);
item = string_list_insert(entries, path);
item->util = e;
return e;
*/
struct stage_data *src_entry;
struct stage_data *dst_entry;
- unsigned add_turned_into_rename:1;
unsigned processed:1;
};
+/*
+ * Get information of all renames which occurred between 'o_tree' and
+ * 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and
+ * 'b_tree') to be able to associate the correct cache entries with
+ * the rename information. 'tree' is always equal to either a_tree or b_tree.
+ */
+static struct string_list *get_renames(struct merge_options *o,
+ struct tree *tree,
+ struct tree *o_tree,
+ struct tree *a_tree,
+ struct tree *b_tree,
+ struct string_list *entries)
+{
+ int i;
+ struct string_list *renames;
+ struct diff_options opts;
+
+ renames = xcalloc(1, sizeof(struct string_list));
+ if (!o->detect_rename)
+ return renames;
+
+ diff_setup(&opts);
+ opts.flags.recursive = 1;
+ opts.flags.rename_empty = 0;
+ opts.detect_rename = DIFF_DETECT_RENAME;
+ opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :
+ o->diff_rename_limit >= 0 ? o->diff_rename_limit :
+ 1000;
+ opts.rename_score = o->rename_score;
+ opts.show_rename_progress = o->show_rename_progress;
+ opts.output_format = DIFF_FORMAT_NO_OUTPUT;
+ diff_setup_done(&opts);
+ diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);
+ diffcore_std(&opts);
+ if (opts.needed_rename_limit > o->needed_rename_limit)
+ o->needed_rename_limit = opts.needed_rename_limit;
+ for (i = 0; i < diff_queued_diff.nr; ++i) {
+ struct string_list_item *item;
+ struct rename *re;
+ struct diff_filepair *pair = diff_queued_diff.queue[i];
+ if (pair->status != 'R') {
+ diff_free_filepair(pair);
+ continue;
+ }
+ re = xmalloc(sizeof(*re));
+ re->processed = 0;
+ re->pair = pair;
+ item = string_list_lookup(entries, re->pair->one->path);
+ if (!item)
+ re->src_entry = insert_stage_data(re->pair->one->path,
+ o_tree, a_tree, b_tree, entries);
+ else
+ re->src_entry = item->util;
+
+ item = string_list_lookup(entries, re->pair->two->path);
+ if (!item)
+ re->dst_entry = insert_stage_data(re->pair->two->path,
+ o_tree, a_tree, b_tree, entries);
+ else
+ re->dst_entry = item->util;
+ item = string_list_insert(renames, pair->one->path);
+ item->util = re;
+ }
+ opts.output_format = DIFF_FORMAT_NO_OUTPUT;
+ diff_queued_diff.nr = 0;
+ diff_flush(&opts);
+ return renames;
+}
+
static int update_stages(struct merge_options *opt, const char *path,
const struct diff_filespec *o,
const struct diff_filespec *a,
return 0;
}
-static int update_stages_for_stage_data(struct merge_options *opt,
- const char *path,
- const struct stage_data *stage_data)
-{
- struct diff_filespec o, a, b;
-
- o.mode = stage_data->stages[1].mode;
- oidcpy(&o.oid, &stage_data->stages[1].oid);
-
- a.mode = stage_data->stages[2].mode;
- oidcpy(&a.oid, &stage_data->stages[2].oid);
-
- b.mode = stage_data->stages[3].mode;
- oidcpy(&b.oid, &stage_data->stages[3].oid);
-
- return update_stages(opt, path,
- is_null_oid(&o.oid) ? NULL : &o,
- is_null_oid(&a.oid) ? NULL : &a,
- is_null_oid(&b.oid) ? NULL : &b);
-}
-
static void update_entry(struct stage_data *entry,
struct diff_filespec *o,
struct diff_filespec *a,
return !was_tracked(path) && file_exists(path);
}
-static int was_dirty(struct merge_options *o, const char *path)
-{
- struct cache_entry *ce;
- int dirty = 1;
-
- if (o->call_depth || !was_tracked(path))
- return !dirty;
-
- ce = cache_file_exists(path, strlen(path), ignore_case);
- dirty = (ce->ce_stat_data.sd_mtime.sec > 0 &&
- verify_uptodate(ce, &o->unpack_opts) != 0);
- return dirty;
-}
-
static int make_room_for_path(struct merge_options *o, const char *path)
{
int status, i;
return merge_status;
}
+static int find_first_merges(struct object_array *result, const char *path,
+ struct commit *a, struct commit *b)
+{
+ int i, j;
+ struct object_array merges = OBJECT_ARRAY_INIT;
+ struct commit *commit;
+ int contains_another;
+
+ char merged_revision[42];
+ const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
+ "--all", merged_revision, NULL };
+ struct rev_info revs;
+ struct setup_revision_opt rev_opts;
+
+ memset(result, 0, sizeof(struct object_array));
+ memset(&rev_opts, 0, sizeof(rev_opts));
+
+ /* get all revisions that merge commit a */
+ xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
+ oid_to_hex(&a->object.oid));
+ init_revisions(&revs, NULL);
+ rev_opts.submodule = path;
+ /* FIXME: can't handle linked worktrees in submodules yet */
+ revs.single_worktree = path != NULL;
+ setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
+
+ /* save all revisions from the above list that contain b */
+ if (prepare_revision_walk(&revs))
+ die("revision walk setup failed");
+ while ((commit = get_revision(&revs)) != NULL) {
+ struct object *o = &(commit->object);
+ if (in_merge_bases(b, commit))
+ add_object_array(o, NULL, &merges);
+ }
+ reset_revision_walk();
+
+ /* Now we've got all merges that contain a and b. Prune all
+ * merges that contain another found merge and save them in
+ * result.
+ */
+ for (i = 0; i < merges.nr; i++) {
+ struct commit *m1 = (struct commit *) merges.objects[i].item;
+
+ contains_another = 0;
+ for (j = 0; j < merges.nr; j++) {
+ struct commit *m2 = (struct commit *) merges.objects[j].item;
+ if (i != j && in_merge_bases(m2, m1)) {
+ contains_another = 1;
+ break;
+ }
+ }
+
+ if (!contains_another)
+ add_object_array(merges.objects[i].item, NULL, result);
+ }
+
+ object_array_clear(&merges);
+ return result->nr;
+}
+
+static void print_commit(struct commit *commit)
+{
+ struct strbuf sb = STRBUF_INIT;
+ struct pretty_print_context ctx = {0};
+ ctx.date_mode.type = DATE_NORMAL;
+ format_commit_message(commit, " %h: %m %s", &sb, &ctx);
+ fprintf(stderr, "%s\n", sb.buf);
+ strbuf_release(&sb);
+}
+
+static int merge_submodule(struct merge_options *o,
+ struct object_id *result, const char *path,
+ const struct object_id *base, const struct object_id *a,
+ const struct object_id *b)
+{
+ struct commit *commit_base, *commit_a, *commit_b;
+ int parent_count;
+ struct object_array merges;
+
+ int i;
+ int search = !o->call_depth;
+
+ /* store a in result in case we fail */
+ oidcpy(result, a);
+
+ /* we can not handle deletion conflicts */
+ if (is_null_oid(base))
+ return 0;
+ if (is_null_oid(a))
+ return 0;
+ if (is_null_oid(b))
+ return 0;
+
+ if (add_submodule_odb(path)) {
+ output(o, 1, _("Failed to merge submodule %s (not checked out)"), path);
+ return 0;
+ }
+
+ if (!(commit_base = lookup_commit_reference(base)) ||
+ !(commit_a = lookup_commit_reference(a)) ||
+ !(commit_b = lookup_commit_reference(b))) {
+ output(o, 1, _("Failed to merge submodule %s (commits not present)"), path);
+ return 0;
+ }
+
+ /* check whether both changes are forward */
+ if (!in_merge_bases(commit_base, commit_a) ||
+ !in_merge_bases(commit_base, commit_b)) {
+ output(o, 1, _("Failed to merge submodule %s (commits don't follow merge-base)"), path);
+ return 0;
+ }
+
+ /* Case #1: a is contained in b or vice versa */
+ if (in_merge_bases(commit_a, commit_b)) {
+ oidcpy(result, b);
+ return 1;
+ }
+ if (in_merge_bases(commit_b, commit_a)) {
+ oidcpy(result, a);
+ return 1;
+ }
+
+ /*
+ * Case #2: There are one or more merges that contain a and b in
+ * the submodule. If there is only one, then present it as a
+ * suggestion to the user, but leave it marked unmerged so the
+ * user needs to confirm the resolution.
+ */
+
+ /* Skip the search if makes no sense to the calling context. */
+ if (!search)
+ return 0;
+
+ /* find commit which merges them */
+ parent_count = find_first_merges(&merges, path, commit_a, commit_b);
+ switch (parent_count) {
+ case 0:
+ output(o, 1, _("Failed to merge submodule %s (merge following commits not found)"), path);
+ break;
+
+ case 1:
+ output(o, 1, _("Failed to merge submodule %s (not fast-forward)"), path);
+ output(o, 2, _("Found a possible merge resolution for the submodule:\n"));
+ print_commit((struct commit *) merges.objects[0].item);
+ output(o, 2, _(
+ "If this is correct simply add it to the index "
+ "for example\n"
+ "by using:\n\n"
+ " git update-index --cacheinfo 160000 %s \"%s\"\n\n"
+ "which will accept this suggestion.\n"),
+ oid_to_hex(&merges.objects[0].item->oid), path);
+ break;
+
+ default:
+ output(o, 1, _("Failed to merge submodule %s (multiple merges found)"), path);
+ for (i = 0; i < merges.nr; i++)
+ print_commit((struct commit *) merges.objects[i].item);
+ }
+
+ object_array_clear(&merges);
+ return 0;
+}
+
static int merge_file_1(struct merge_options *o,
const struct diff_filespec *one,
const struct diff_filespec *a,
return ret;
result->clean = (merge_status == 0);
} else if (S_ISGITLINK(a->mode)) {
- result->clean = merge_submodule(&result->oid,
+ result->clean = merge_submodule(o, &result->oid,
one->path,
&one->oid,
&a->oid,
- &b->oid,
- !o->call_depth);
+ &b->oid);
} else if (S_ISLNK(a->mode)) {
switch (o->recursive_variant) {
case MERGE_RECURSIVE_NORMAL:
return merge_file_1(o, &one, &a, &b, branch1, branch2, mfi);
}
-static int conflict_rename_dir(struct merge_options *o,
- struct diff_filepair *pair,
- const char *rename_branch,
- const char *other_branch)
-{
- const struct diff_filespec *dest = pair->two;
-
- if (!o->call_depth && would_lose_untracked(dest->path)) {
- char *alt_path = unique_path(o, dest->path, rename_branch);
-
- output(o, 1, _("Error: Refusing to lose untracked file at %s; "
- "writing to %s instead."),
- dest->path, alt_path);
- /*
- * Write the file in worktree at alt_path, but not in the
- * index. Instead, write to dest->path for the index but
- * only at the higher appropriate stage.
- */
- if (update_file(o, 0, &dest->oid, dest->mode, alt_path))
- return -1;
- free(alt_path);
- return update_stages(o, dest->path, NULL,
- rename_branch == o->branch1 ? dest : NULL,
- rename_branch == o->branch1 ? NULL : dest);
- }
-
- /* Update dest->path both in index and in worktree */
- if (update_file(o, 1, &dest->oid, dest->mode, dest->path))
- return -1;
- return 0;
-}
-
static int handle_change_delete(struct merge_options *o,
const char *path, const char *old_path,
const struct object_id *o_oid, int o_mode,
const char *update_path = path;
int ret = 0;
- if (dir_in_way(path, !o->call_depth, 0) ||
- (!o->call_depth && would_lose_untracked(path))) {
+ if (dir_in_way(path, !o->call_depth, 0)) {
update_path = alt_path = unique_path(o, path, change_branch);
}
add = filespec_from_entry(&other, dst_entry, stage ^ 1);
if (add) {
- int ren_src_was_dirty = was_dirty(o, rename->path);
char *add_name = unique_path(o, rename->path, other_branch);
if (update_file(o, 0, &add->oid, add->mode, add_name))
return -1;
- if (ren_src_was_dirty) {
- output(o, 1, _("Refusing to lose dirty file at %s"),
- rename->path);
- }
- /*
- * Because the double negatives somehow keep confusing me...
- * 1) update_wd iff !ren_src_was_dirty.
- * 2) no_wd iff !update_wd
- * 3) so, no_wd == !!ren_src_was_dirty == ren_src_was_dirty
- */
- remove_file(o, 0, rename->path, ren_src_was_dirty);
+ remove_file(o, 0, rename->path, 0);
dst_name = unique_path(o, rename->path, cur_branch);
} else {
if (dir_in_way(rename->path, !o->call_depth, 0)) {
dst_name = unique_path(o, rename->path, cur_branch);
output(o, 1, _("%s is a directory in %s adding as %s instead"),
rename->path, other_branch, dst_name);
- } else if (!o->call_depth &&
- would_lose_untracked(rename->path)) {
- dst_name = unique_path(o, rename->path, cur_branch);
- output(o, 1, _("Refusing to lose untracked file at %s; "
- "adding as %s instead"),
- rename->path, dst_name);
}
}
if ((ret = update_file(o, 0, &rename->oid, rename->mode, dst_name)))
char *new_path2 = unique_path(o, path, ci->branch2);
output(o, 1, _("Renaming %s to %s and %s to %s instead"),
a->path, new_path1, b->path, new_path2);
- if (was_dirty(o, path))
- output(o, 1, _("Refusing to lose dirty file at %s"),
- path);
- else if (would_lose_untracked(path))
- /*
- * Only way we get here is if both renames were from
- * a directory rename AND user had an untracked file
- * at the location where both files end up after the
- * two directory renames. See testcase 10d of t6043.
- */
- output(o, 1, _("Refusing to lose untracked file at "
- "%s, even though it's in the way."),
- path);
- else
- remove_file(o, 0, path, 0);
+ remove_file(o, 0, path, 0);
ret = update_file(o, 0, &mfi_c1.oid, mfi_c1.mode, new_path1);
if (!ret)
ret = update_file(o, 0, &mfi_c2.oid, mfi_c2.mode,
new_path2);
- /*
- * unpack_trees() actually populates the index for us for
- * "normal" rename/rename(2to1) situtations so that the
- * correct entries are at the higher stages, which would
- * make the call below to update_stages_for_stage_data
- * unnecessary. However, if either of the renames came
- * from a directory rename, then unpack_trees() will not
- * have gotten the right data loaded into the index, so we
- * need to do so now. (While it'd be tempting to move this
- * call to update_stages_for_stage_data() to
- * apply_directory_rename_modifications(), that would break
- * our intermediate calls to would_lose_untracked() since
- * those rely on the current in-memory index. See also the
- * big "NOTE" in update_stages()).
- */
- if (update_stages_for_stage_data(o, path, ci->dst_entry1))
- ret = -1;
-
free(new_path2);
free(new_path1);
}
return ret;
}
-/*
- * Get the diff_filepairs changed between o_tree and tree.
- */
-static struct diff_queue_struct *get_diffpairs(struct merge_options *o,
- struct tree *o_tree,
- struct tree *tree)
-{
- struct diff_queue_struct *ret;
- struct diff_options opts;
-
- diff_setup(&opts);
- opts.flags.recursive = 1;
- opts.flags.rename_empty = 0;
- opts.detect_rename = DIFF_DETECT_RENAME;
- opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :
- o->diff_rename_limit >= 0 ? o->diff_rename_limit :
- 1000;
- opts.rename_score = o->rename_score;
- opts.show_rename_progress = o->show_rename_progress;
- opts.output_format = DIFF_FORMAT_NO_OUTPUT;
- diff_setup_done(&opts);
- diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);
- diffcore_std(&opts);
- if (opts.needed_rename_limit > o->needed_rename_limit)
- o->needed_rename_limit = opts.needed_rename_limit;
-
- ret = xmalloc(sizeof(*ret));
- *ret = diff_queued_diff;
-
- opts.output_format = DIFF_FORMAT_NO_OUTPUT;
- diff_queued_diff.nr = 0;
- diff_queued_diff.queue = NULL;
- diff_flush(&opts);
- return ret;
-}
-
-static int tree_has_path(struct tree *tree, const char *path)
-{
- struct object_id hashy;
- unsigned int mode_o;
-
- return !get_tree_entry(&tree->object.oid, path,
- &hashy, &mode_o);
-}
-
-/*
- * Return a new string that replaces the beginning portion (which matches
- * entry->dir), with entry->new_dir. In perl-speak:
- * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);
- * NOTE:
- * Caller must ensure that old_path starts with entry->dir + '/'.
- */
-static char *apply_dir_rename(struct dir_rename_entry *entry,
- const char *old_path)
-{
- struct strbuf new_path = STRBUF_INIT;
- int oldlen, newlen;
-
- if (entry->non_unique_new_dir)
- return NULL;
-
- oldlen = strlen(entry->dir);
- newlen = entry->new_dir.len + (strlen(old_path) - oldlen) + 1;
- strbuf_grow(&new_path, newlen);
- strbuf_addbuf(&new_path, &entry->new_dir);
- strbuf_addstr(&new_path, &old_path[oldlen]);
-
- return strbuf_detach(&new_path, NULL);
-}
-
-static void get_renamed_dir_portion(const char *old_path, const char *new_path,
- char **old_dir, char **new_dir)
-{
- char *end_of_old, *end_of_new;
- int old_len, new_len;
-
- *old_dir = NULL;
- *new_dir = NULL;
-
- /*
- * For
- * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"
- * the "e/foo.c" part is the same, we just want to know that
- * "a/b/c/d" was renamed to "a/b/some/thing/else"
- * so, for this example, this function returns "a/b/c/d" in
- * *old_dir and "a/b/some/thing/else" in *new_dir.
- *
- * Also, if the basename of the file changed, we don't care. We
- * want to know which portion of the directory, if any, changed.
- */
- end_of_old = strrchr(old_path, '/');
- end_of_new = strrchr(new_path, '/');
-
- if (end_of_old == NULL || end_of_new == NULL)
- return;
- while (*--end_of_new == *--end_of_old &&
- end_of_old != old_path &&
- end_of_new != new_path)
- ; /* Do nothing; all in the while loop */
- /*
- * We've found the first non-matching character in the directory
- * paths. That means the current directory we were comparing
- * represents the rename. Move end_of_old and end_of_new back
- * to the full directory name.
- */
- if (*end_of_old == '/')
- end_of_old++;
- if (*end_of_old != '/')
- end_of_new++;
- end_of_old = strchr(end_of_old, '/');
- end_of_new = strchr(end_of_new, '/');
-
- /*
- * It may have been the case that old_path and new_path were the same
- * directory all along. Don't claim a rename if they're the same.
- */
- old_len = end_of_old - old_path;
- new_len = end_of_new - new_path;
-
- if (old_len != new_len || strncmp(old_path, new_path, old_len)) {
- *old_dir = xstrndup(old_path, old_len);
- *new_dir = xstrndup(new_path, new_len);
- }
-}
-
-static void remove_hashmap_entries(struct hashmap *dir_renames,
- struct string_list *items_to_remove)
-{
- int i;
- struct dir_rename_entry *entry;
-
- for (i = 0; i < items_to_remove->nr; i++) {
- entry = items_to_remove->items[i].util;
- hashmap_remove(dir_renames, entry, NULL);
- }
- string_list_clear(items_to_remove, 0);
-}
-
-/*
- * See if there is a directory rename for path, and if there are any file
- * level conflicts for the renamed location. If there is a rename and
- * there are no conflicts, return the new name. Otherwise, return NULL.
- */
-static char *handle_path_level_conflicts(struct merge_options *o,
- const char *path,
- struct dir_rename_entry *entry,
- struct hashmap *collisions,
- struct tree *tree)
-{
- char *new_path = NULL;
- struct collision_entry *collision_ent;
- int clean = 1;
- struct strbuf collision_paths = STRBUF_INIT;
-
- /*
- * entry has the mapping of old directory name to new directory name
- * that we want to apply to path.
- */
- new_path = apply_dir_rename(entry, path);
-
- if (!new_path) {
- /* This should only happen when entry->non_unique_new_dir set */
- if (!entry->non_unique_new_dir)
- BUG("entry->non_unqiue_dir not set and !new_path");
- output(o, 1, _("CONFLICT (directory rename split): "
- "Unclear where to place %s because directory "
- "%s was renamed to multiple other directories, "
- "with no destination getting a majority of the "
- "files."),
- path, entry->dir);
- clean = 0;
- return NULL;
- }
-
- /*
- * The caller needs to have ensured that it has pre-populated
- * collisions with all paths that map to new_path. Do a quick check
- * to ensure that's the case.
- */
- collision_ent = collision_find_entry(collisions, new_path);
- if (collision_ent == NULL)
- BUG("collision_ent is NULL");
-
- /*
- * Check for one-sided add/add/.../add conflicts, i.e.
- * where implicit renames from the other side doing
- * directory rename(s) can affect this side of history
- * to put multiple paths into the same location. Warn
- * and bail on directory renames for such paths.
- */
- if (collision_ent->reported_already) {
- clean = 0;
- } else if (tree_has_path(tree, new_path)) {
- collision_ent->reported_already = 1;
- strbuf_add_separated_string_list(&collision_paths, ", ",
- &collision_ent->source_files);
- output(o, 1, _("CONFLICT (implicit dir rename): Existing "
- "file/dir at %s in the way of implicit "
- "directory rename(s) putting the following "
- "path(s) there: %s."),
- new_path, collision_paths.buf);
- clean = 0;
- } else if (collision_ent->source_files.nr > 1) {
- collision_ent->reported_already = 1;
- strbuf_add_separated_string_list(&collision_paths, ", ",
- &collision_ent->source_files);
- output(o, 1, _("CONFLICT (implicit dir rename): Cannot map "
- "more than one path to %s; implicit directory "
- "renames tried to put these paths there: %s"),
- new_path, collision_paths.buf);
- clean = 0;
- }
-
- /* Free memory we no longer need */
- strbuf_release(&collision_paths);
- if (!clean && new_path) {
- free(new_path);
- return NULL;
- }
-
- return new_path;
-}
-
-/*
- * There are a couple things we want to do at the directory level:
- * 1. Check for both sides renaming to the same thing, in order to avoid
- * implicit renaming of files that should be left in place. (See
- * testcase 6b in t6043 for details.)
- * 2. Prune directory renames if there are still files left in the
- * the original directory. These represent a partial directory rename,
- * i.e. a rename where only some of the files within the directory
- * were renamed elsewhere. (Technically, this could be done earlier
- * in get_directory_renames(), except that would prevent us from
- * doing the previous check and thus failing testcase 6b.)
- * 3. Check for rename/rename(1to2) conflicts (at the directory level).
- * In the future, we could potentially record this info as well and
- * omit reporting rename/rename(1to2) conflicts for each path within
- * the affected directories, thus cleaning up the merge output.
- * NOTE: We do NOT check for rename/rename(2to1) conflicts at the
- * directory level, because merging directories is fine. If it
- * causes conflicts for files within those merged directories, then
- * that should be detected at the individual path level.
- */
-static void handle_directory_level_conflicts(struct merge_options *o,
- struct hashmap *dir_re_head,
- struct tree *head,
- struct hashmap *dir_re_merge,
- struct tree *merge)
-{
- struct hashmap_iter iter;
- struct dir_rename_entry *head_ent;
- struct dir_rename_entry *merge_ent;
-
- struct string_list remove_from_head = STRING_LIST_INIT_NODUP;
- struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;
-
- hashmap_iter_init(dir_re_head, &iter);
- while ((head_ent = hashmap_iter_next(&iter))) {
- merge_ent = dir_rename_find_entry(dir_re_merge, head_ent->dir);
- if (merge_ent &&
- !head_ent->non_unique_new_dir &&
- !merge_ent->non_unique_new_dir &&
- !strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {
- /* 1. Renamed identically; remove it from both sides */
- string_list_append(&remove_from_head,
- head_ent->dir)->util = head_ent;
- strbuf_release(&head_ent->new_dir);
- string_list_append(&remove_from_merge,
- merge_ent->dir)->util = merge_ent;
- strbuf_release(&merge_ent->new_dir);
- } else if (tree_has_path(head, head_ent->dir)) {
- /* 2. This wasn't a directory rename after all */
- string_list_append(&remove_from_head,
- head_ent->dir)->util = head_ent;
- strbuf_release(&head_ent->new_dir);
- }
- }
-
- remove_hashmap_entries(dir_re_head, &remove_from_head);
- remove_hashmap_entries(dir_re_merge, &remove_from_merge);
-
- hashmap_iter_init(dir_re_merge, &iter);
- while ((merge_ent = hashmap_iter_next(&iter))) {
- head_ent = dir_rename_find_entry(dir_re_head, merge_ent->dir);
- if (tree_has_path(merge, merge_ent->dir)) {
- /* 2. This wasn't a directory rename after all */
- string_list_append(&remove_from_merge,
- merge_ent->dir)->util = merge_ent;
- } else if (head_ent &&
- !head_ent->non_unique_new_dir &&
- !merge_ent->non_unique_new_dir) {
- /* 3. rename/rename(1to2) */
- /*
- * We can assume it's not rename/rename(1to1) because
- * that was case (1), already checked above. So we
- * know that head_ent->new_dir and merge_ent->new_dir
- * are different strings.
- */
- output(o, 1, _("CONFLICT (rename/rename): "
- "Rename directory %s->%s in %s. "
- "Rename directory %s->%s in %s"),
- head_ent->dir, head_ent->new_dir.buf, o->branch1,
- head_ent->dir, merge_ent->new_dir.buf, o->branch2);
- string_list_append(&remove_from_head,
- head_ent->dir)->util = head_ent;
- strbuf_release(&head_ent->new_dir);
- string_list_append(&remove_from_merge,
- merge_ent->dir)->util = merge_ent;
- strbuf_release(&merge_ent->new_dir);
- }
- }
-
- remove_hashmap_entries(dir_re_head, &remove_from_head);
- remove_hashmap_entries(dir_re_merge, &remove_from_merge);
-}
-
-static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,
- struct tree *tree)
-{
- struct hashmap *dir_renames;
- struct hashmap_iter iter;
- struct dir_rename_entry *entry;
- int i;
-
- /*
- * Typically, we think of a directory rename as all files from a
- * certain directory being moved to a target directory. However,
- * what if someone first moved two files from the original
- * directory in one commit, and then renamed the directory
- * somewhere else in a later commit? At merge time, we just know
- * that files from the original directory went to two different
- * places, and that the bulk of them ended up in the same place.
- * We want each directory rename to represent where the bulk of the
- * files from that directory end up; this function exists to find
- * where the bulk of the files went.
- *
- * The first loop below simply iterates through the list of file
- * renames, finding out how often each directory rename pair
- * possibility occurs.
- */
- dir_renames = xmalloc(sizeof(struct hashmap));
- dir_rename_init(dir_renames);
- for (i = 0; i < pairs->nr; ++i) {
- struct string_list_item *item;
- int *count;
- struct diff_filepair *pair = pairs->queue[i];
- char *old_dir, *new_dir;
-
- /* File not part of directory rename if it wasn't renamed */
- if (pair->status != 'R')
- continue;
-
- get_renamed_dir_portion(pair->one->path, pair->two->path,
- &old_dir, &new_dir);
- if (!old_dir)
- /* Directory didn't change at all; ignore this one. */
- continue;
-
- entry = dir_rename_find_entry(dir_renames, old_dir);
- if (!entry) {
- entry = xmalloc(sizeof(struct dir_rename_entry));
- dir_rename_entry_init(entry, old_dir);
- hashmap_put(dir_renames, entry);
- } else {
- free(old_dir);
- }
- item = string_list_lookup(&entry->possible_new_dirs, new_dir);
- if (!item) {
- item = string_list_insert(&entry->possible_new_dirs,
- new_dir);
- item->util = xcalloc(1, sizeof(int));
- } else {
- free(new_dir);
- }
- count = item->util;
- *count += 1;
- }
-
- /*
- * For each directory with files moved out of it, we find out which
- * target directory received the most files so we can declare it to
- * be the "winning" target location for the directory rename. This
- * winner gets recorded in new_dir. If there is no winner
- * (multiple target directories received the same number of files),
- * we set non_unique_new_dir. Once we've determined the winner (or
- * that there is no winner), we no longer need possible_new_dirs.
- */
- hashmap_iter_init(dir_renames, &iter);
- while ((entry = hashmap_iter_next(&iter))) {
- int max = 0;
- int bad_max = 0;
- char *best = NULL;
-
- for (i = 0; i < entry->possible_new_dirs.nr; i++) {
- int *count = entry->possible_new_dirs.items[i].util;
-
- if (*count == max)
- bad_max = max;
- else if (*count > max) {
- max = *count;
- best = entry->possible_new_dirs.items[i].string;
- }
- }
- if (bad_max == max)
- entry->non_unique_new_dir = 1;
- else {
- assert(entry->new_dir.len == 0);
- strbuf_addstr(&entry->new_dir, best);
- }
- /*
- * The relevant directory sub-portion of the original full
- * filepaths were xstrndup'ed before inserting into
- * possible_new_dirs, and instead of manually iterating the
- * list and free'ing each, just lie and tell
- * possible_new_dirs that it did the strdup'ing so that it
- * will free them for us.
- */
- entry->possible_new_dirs.strdup_strings = 1;
- string_list_clear(&entry->possible_new_dirs, 1);
- }
-
- return dir_renames;
-}
-
-static struct dir_rename_entry *check_dir_renamed(const char *path,
- struct hashmap *dir_renames)
-{
- char temp[PATH_MAX];
- char *end;
- struct dir_rename_entry *entry;
-
- strcpy(temp, path);
- while ((end = strrchr(temp, '/'))) {
- *end = '\0';
- entry = dir_rename_find_entry(dir_renames, temp);
- if (entry)
- return entry;
- }
- return NULL;
-}
-
-static void compute_collisions(struct hashmap *collisions,
- struct hashmap *dir_renames,
- struct diff_queue_struct *pairs)
-{
- int i;
-
- /*
- * Multiple files can be mapped to the same path due to directory
- * renames done by the other side of history. Since that other
- * side of history could have merged multiple directories into one,
- * if our side of history added the same file basename to each of
- * those directories, then all N of them would get implicitly
- * renamed by the directory rename detection into the same path,
- * and we'd get an add/add/.../add conflict, and all those adds
- * from *this* side of history. This is not representable in the
- * index, and users aren't going to easily be able to make sense of
- * it. So we need to provide a good warning about what's
- * happening, and fall back to no-directory-rename detection
- * behavior for those paths.
- *
- * See testcases 9e and all of section 5 from t6043 for examples.
- */
- collision_init(collisions);
-
- for (i = 0; i < pairs->nr; ++i) {
- struct dir_rename_entry *dir_rename_ent;
- struct collision_entry *collision_ent;
- char *new_path;
- struct diff_filepair *pair = pairs->queue[i];
-
- if (pair->status != 'A' && pair->status != 'R')
- continue;
- dir_rename_ent = check_dir_renamed(pair->two->path,
- dir_renames);
- if (!dir_rename_ent)
- continue;
-
- new_path = apply_dir_rename(dir_rename_ent, pair->two->path);
- if (!new_path)
- /*
- * dir_rename_ent->non_unique_new_path is true, which
- * means there is no directory rename for us to use,
- * which means it won't cause us any additional
- * collisions.
- */
- continue;
- collision_ent = collision_find_entry(collisions, new_path);
- if (!collision_ent) {
- collision_ent = xcalloc(1,
- sizeof(struct collision_entry));
- hashmap_entry_init(collision_ent, strhash(new_path));
- hashmap_put(collisions, collision_ent);
- collision_ent->target_file = new_path;
- } else {
- free(new_path);
- }
- string_list_insert(&collision_ent->source_files,
- pair->two->path);
- }
-}
-
-static char *check_for_directory_rename(struct merge_options *o,
- const char *path,
- struct tree *tree,
- struct hashmap *dir_renames,
- struct hashmap *dir_rename_exclusions,
- struct hashmap *collisions,
- int *clean_merge)
-{
- char *new_path = NULL;
- struct dir_rename_entry *entry = check_dir_renamed(path, dir_renames);
- struct dir_rename_entry *oentry = NULL;
-
- if (!entry)
- return new_path;
-
- /*
- * This next part is a little weird. We do not want to do an
- * implicit rename into a directory we renamed on our side, because
- * that will result in a spurious rename/rename(1to2) conflict. An
- * example:
- * Base commit: dumbdir/afile, otherdir/bfile
- * Side 1: smrtdir/afile, otherdir/bfile
- * Side 2: dumbdir/afile, dumbdir/bfile
- * Here, while working on Side 1, we could notice that otherdir was
- * renamed/merged to dumbdir, and change the diff_filepair for
- * otherdir/bfile into a rename into dumbdir/bfile. However, Side
- * 2 will notice the rename from dumbdir to smrtdir, and do the
- * transitive rename to move it from dumbdir/bfile to
- * smrtdir/bfile. That gives us bfile in dumbdir vs being in
- * smrtdir, a rename/rename(1to2) conflict. We really just want
- * the file to end up in smrtdir. And the way to achieve that is
- * to not let Side1 do the rename to dumbdir, since we know that is
- * the source of one of our directory renames.
- *
- * That's why oentry and dir_rename_exclusions is here.
- *
- * As it turns out, this also prevents N-way transient rename
- * confusion; See testcases 9c and 9d of t6043.
- */
- oentry = dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);
- if (oentry) {
- output(o, 1, _("WARNING: Avoiding applying %s -> %s rename "
- "to %s, because %s itself was renamed."),
- entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);
- } else {
- new_path = handle_path_level_conflicts(o, path, entry,
- collisions, tree);
- *clean_merge &= (new_path != NULL);
- }
-
- return new_path;
-}
-
-static void apply_directory_rename_modifications(struct merge_options *o,
- struct diff_filepair *pair,
- char *new_path,
- struct rename *re,
- struct tree *tree,
- struct tree *o_tree,
- struct tree *a_tree,
- struct tree *b_tree,
- struct string_list *entries,
- int *clean)
-{
- struct string_list_item *item;
- int stage = (tree == a_tree ? 2 : 3);
- int update_wd;
-
- /*
- * In all cases where we can do directory rename detection,
- * unpack_trees() will have read pair->two->path into the
- * index and the working copy. We need to remove it so that
- * we can instead place it at new_path. It is guaranteed to
- * not be untracked (unpack_trees() would have errored out
- * saying the file would have been overwritten), but it might
- * be dirty, though.
- */
- update_wd = !was_dirty(o, pair->two->path);
- if (!update_wd)
- output(o, 1, _("Refusing to lose dirty file at %s"),
- pair->two->path);
- remove_file(o, 1, pair->two->path, !update_wd);
-
- /* Find or create a new re->dst_entry */
- item = string_list_lookup(entries, new_path);
- if (item) {
- /*
- * Since we're renaming on this side of history, and it's
- * due to a directory rename on the other side of history
- * (which we only allow when the directory in question no
- * longer exists on the other side of history), the
- * original entry for re->dst_entry is no longer
- * necessary...
- */
- re->dst_entry->processed = 1;
-
- /*
- * ...because we'll be using this new one.
- */
- re->dst_entry = item->util;
- } else {
- /*
- * re->dst_entry is for the before-dir-rename path, and we
- * need it to hold information for the after-dir-rename
- * path. Before creating a new entry, we need to mark the
- * old one as unnecessary (...unless it is shared by
- * src_entry, i.e. this didn't use to be a rename, in which
- * case we can just allow the normal processing to happen
- * for it).
- */
- if (pair->status == 'R')
- re->dst_entry->processed = 1;
-
- re->dst_entry = insert_stage_data(new_path,
- o_tree, a_tree, b_tree,
- entries);
- item = string_list_insert(entries, new_path);
- item->util = re->dst_entry;
- }
-
- /*
- * Update the stage_data with the information about the path we are
- * moving into place. That slot will be empty and available for us
- * to write to because of the collision checks in
- * handle_path_level_conflicts(). In other words,
- * re->dst_entry->stages[stage].oid will be the null_oid, so it's
- * open for us to write to.
- *
- * It may be tempting to actually update the index at this point as
- * well, using update_stages_for_stage_data(), but as per the big
- * "NOTE" in update_stages(), doing so will modify the current
- * in-memory index which will break calls to would_lose_untracked()
- * that we need to make. Instead, we need to just make sure that
- * the various conflict_rename_*() functions update the index
- * explicitly rather than relying on unpack_trees() to have done it.
- */
- get_tree_entry(&tree->object.oid,
- pair->two->path,
- &re->dst_entry->stages[stage].oid,
- &re->dst_entry->stages[stage].mode);
-
- /* Update pair status */
- if (pair->status == 'A') {
- /*
- * Recording rename information for this add makes it look
- * like a rename/delete conflict. Make sure we can
- * correctly handle this as an add that was moved to a new
- * directory instead of reporting a rename/delete conflict.
- */
- re->add_turned_into_rename = 1;
- }
- /*
- * We don't actually look at pair->status again, but it seems
- * pedagogically correct to adjust it.
- */
- pair->status = 'R';
-
- /*
- * Finally, record the new location.
- */
- pair->two->path = new_path;
-}
-
-/*
- * Get information of all renames which occurred in 'pairs', making use of
- * any implicit directory renames inferred from the other side of history.
- * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')
- * to be able to associate the correct cache entries with the rename
- * information; tree is always equal to either a_tree or b_tree.
- */
-static struct string_list *get_renames(struct merge_options *o,
- struct diff_queue_struct *pairs,
- struct hashmap *dir_renames,
- struct hashmap *dir_rename_exclusions,
- struct tree *tree,
- struct tree *o_tree,
- struct tree *a_tree,
- struct tree *b_tree,
- struct string_list *entries,
- int *clean_merge)
-{
- int i;
- struct hashmap collisions;
- struct hashmap_iter iter;
- struct collision_entry *e;
- struct string_list *renames;
-
- compute_collisions(&collisions, dir_renames, pairs);
- renames = xcalloc(1, sizeof(struct string_list));
-
- for (i = 0; i < pairs->nr; ++i) {
- struct string_list_item *item;
- struct rename *re;
- struct diff_filepair *pair = pairs->queue[i];
- char *new_path; /* non-NULL only with directory renames */
-
- if (pair->status != 'A' && pair->status != 'R') {
- diff_free_filepair(pair);
- continue;
- }
- new_path = check_for_directory_rename(o, pair->two->path, tree,
- dir_renames,
- dir_rename_exclusions,
- &collisions,
- clean_merge);
- if (pair->status != 'R' && !new_path) {
- diff_free_filepair(pair);
- continue;
- }
-
- re = xmalloc(sizeof(*re));
- re->processed = 0;
- re->add_turned_into_rename = 0;
- re->pair = pair;
- item = string_list_lookup(entries, re->pair->one->path);
- if (!item)
- re->src_entry = insert_stage_data(re->pair->one->path,
- o_tree, a_tree, b_tree, entries);
- else
- re->src_entry = item->util;
-
- item = string_list_lookup(entries, re->pair->two->path);
- if (!item)
- re->dst_entry = insert_stage_data(re->pair->two->path,
- o_tree, a_tree, b_tree, entries);
- else
- re->dst_entry = item->util;
- item = string_list_insert(renames, pair->one->path);
- item->util = re;
- if (new_path)
- apply_directory_rename_modifications(o, pair, new_path,
- re, tree, o_tree,
- a_tree, b_tree,
- entries,
- clean_merge);
- }
-
- hashmap_iter_init(&collisions, &iter);
- while ((e = hashmap_iter_next(&iter))) {
- free(e->target_file);
- string_list_clear(&e->source_files, 0);
- }
- hashmap_free(&collisions, 1);
- return renames;
-}
-
static int process_renames(struct merge_options *o,
struct string_list *a_renames,
struct string_list *b_renames)
dst_other.mode = ren1->dst_entry->stages[other_stage].mode;
try_merge = 0;
- if (oid_eq(&src_other.oid, &null_oid) &&
- ren1->add_turned_into_rename) {
- setup_rename_conflict_info(RENAME_DIR,
- ren1->pair,
- NULL,
- branch1,
- branch2,
- ren1->dst_entry,
- NULL,
- o,
- NULL,
- NULL);
- } else if (oid_eq(&src_other.oid, &null_oid)) {
+ if (oid_eq(&src_other.oid, &null_oid)) {
setup_rename_conflict_info(RENAME_DELETE,
ren1->pair,
NULL,
return clean_merge;
}
-struct rename_info {
- struct string_list *head_renames;
- struct string_list *merge_renames;
-};
-
-static void initial_cleanup_rename(struct diff_queue_struct *pairs,
- struct hashmap *dir_renames)
-{
- struct hashmap_iter iter;
- struct dir_rename_entry *e;
-
- hashmap_iter_init(dir_renames, &iter);
- while ((e = hashmap_iter_next(&iter))) {
- free(e->dir);
- strbuf_release(&e->new_dir);
- /* possible_new_dirs already cleared in get_directory_renames */
- }
- hashmap_free(dir_renames, 1);
- free(dir_renames);
-
- free(pairs->queue);
- free(pairs);
-}
-
-static int handle_renames(struct merge_options *o,
- struct tree *common,
- struct tree *head,
- struct tree *merge,
- struct string_list *entries,
- struct rename_info *ri)
-{
- struct diff_queue_struct *head_pairs, *merge_pairs;
- struct hashmap *dir_re_head, *dir_re_merge;
- int clean = 1;
-
- ri->head_renames = NULL;
- ri->merge_renames = NULL;
-
- if (!o->detect_rename)
- return 1;
-
- head_pairs = get_diffpairs(o, common, head);
- merge_pairs = get_diffpairs(o, common, merge);
-
- dir_re_head = get_directory_renames(head_pairs, head);
- dir_re_merge = get_directory_renames(merge_pairs, merge);
-
- handle_directory_level_conflicts(o,
- dir_re_head, head,
- dir_re_merge, merge);
-
- ri->head_renames = get_renames(o, head_pairs,
- dir_re_merge, dir_re_head, head,
- common, head, merge, entries,
- &clean);
- if (clean < 0)
- goto cleanup;
- ri->merge_renames = get_renames(o, merge_pairs,
- dir_re_head, dir_re_merge, merge,
- common, head, merge, entries,
- &clean);
- if (clean < 0)
- goto cleanup;
- clean &= process_renames(o, ri->head_renames, ri->merge_renames);
-
-cleanup:
- /*
- * Some cleanup is deferred until cleanup_renames() because the
- * data structures are still needed and referenced in
- * process_entry(). But there are a few things we can free now.
- */
- initial_cleanup_rename(head_pairs, dir_re_head);
- initial_cleanup_rename(merge_pairs, dir_re_merge);
-
- return clean;
-}
-
-static void final_cleanup_rename(struct string_list *rename)
-{
- const struct rename *re;
- int i;
-
- if (rename == NULL)
- return;
-
- for (i = 0; i < rename->nr; i++) {
- re = rename->items[i].util;
- diff_free_filepair(re->pair);
- }
- string_list_clear(rename, 1);
- free(rename);
-}
-
-static void final_cleanup_renames(struct rename_info *re_info)
-{
- final_cleanup_rename(re_info->head_renames);
- final_cleanup_rename(re_info->merge_renames);
-}
-
static struct object_id *stage_oid(const struct object_id *oid, unsigned mode)
{
return (is_null_oid(oid) || mode == 0) ? NULL: (struct object_id *)oid;
static int merge_content(struct merge_options *o,
const char *path,
- int file_in_way,
struct object_id *o_oid, int o_mode,
struct object_id *a_oid, int a_mode,
struct object_id *b_oid, int b_mode,
if (mfi.clean && !df_conflict_remains &&
oid_eq(&mfi.oid, a_oid) && mfi.mode == a_mode) {
+ int path_renamed_outside_HEAD;
output(o, 3, _("Skipped %s (merged same as existing)"), path);
/*
* The content merge resulted in the same file contents we
* are recorded at the correct path (which may not be true
* if the merge involves a rename).
*/
- if (was_tracked(path)) {
+ path_renamed_outside_HEAD = !path2 || !strcmp(path, path2);
+ if (!path_renamed_outside_HEAD) {
add_cacheinfo(o, mfi.mode, &mfi.oid, path,
0, (!o->call_depth), 0);
return mfi.clean;
return -1;
}
- if (df_conflict_remains || file_in_way) {
+ if (df_conflict_remains) {
char *new_path;
if (o->call_depth) {
remove_file_from_cache(path);
return mfi.clean;
}
-static int conflict_rename_normal(struct merge_options *o,
- const char *path,
- struct object_id *o_oid, unsigned int o_mode,
- struct object_id *a_oid, unsigned int a_mode,
- struct object_id *b_oid, unsigned int b_mode,
- struct rename_conflict_info *ci)
-{
- int clean_merge;
- int file_in_the_way = 0;
-
- if (was_dirty(o, path)) {
- file_in_the_way = 1;
- output(o, 1, _("Refusing to lose dirty file at %s"), path);
- }
-
- /* Merge the content and write it out */
- clean_merge = merge_content(o, path, file_in_the_way,
- o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
- ci);
- if (clean_merge > 0 && file_in_the_way)
- clean_merge = 0;
- return clean_merge;
-}
-
/* Per entry merge function */
static int process_entry(struct merge_options *o,
const char *path, struct stage_data *entry)
switch (conflict_info->rename_type) {
case RENAME_NORMAL:
case RENAME_ONE_FILE_TO_ONE:
- clean_merge = conflict_rename_normal(o,
- path,
- o_oid, o_mode,
- a_oid, a_mode,
- b_oid, b_mode,
- conflict_info);
- break;
- case RENAME_DIR:
- clean_merge = 1;
- if (conflict_rename_dir(o,
- conflict_info->pair1,
- conflict_info->branch1,
- conflict_info->branch2))
- clean_merge = -1;
+ clean_merge = merge_content(o, path,
+ o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
+ conflict_info);
break;
case RENAME_DELETE:
clean_merge = 0;
} else if (a_oid && b_oid) {
/* Case C: Added in both (check for same permissions) and */
/* case D: Modified in both, but differently. */
- clean_merge = merge_content(o, path, 0 /* file_in_way */,
+ clean_merge = merge_content(o, path,
o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
NULL);
} else if (!o_oid && !a_oid && !b_oid) {
return 1;
}
- code = git_merge_trees(o, common, head, merge);
+ code = git_merge_trees(o->call_depth, common, head, merge);
if (code != 0) {
if (show(o, 4) || o->call_depth)
}
if (unmerged_cache()) {
- struct string_list *entries;
- struct rename_info re_info;
+ struct string_list *entries, *re_head, *re_merge;
int i;
/*
* Only need the hashmap while processing entries, so
get_files_dirs(o, merge);
entries = get_unmerged();
- clean = handle_renames(o, common, head, merge, entries,
- &re_info);
+ re_head = get_renames(o, head, common, head, merge, entries);
+ re_merge = get_renames(o, merge, common, head, merge, entries);
+ clean = process_renames(o, re_head, re_merge);
record_df_conflict_files(o, entries);
if (clean < 0)
goto cleanup;
}
cleanup:
- final_cleanup_renames(&re_info);
-
+ string_list_clear(re_merge, 0);
+ string_list_clear(re_head, 0);
string_list_clear(entries, 1);
- free(entries);
hashmap_free(&o->current_file_dir_set, 1);
+ free(re_merge);
+ free(re_head);
+ free(entries);
+
if (clean < 0)
return clean;
}
projects / thirdparty / git.git / blobdiff