directory rename detection: miscellaneous testcases to complete coverage
[gitweb.git] / merge-recursive.c
index 9c05eb7f700eed0dc3e20a4c22f3a60e0aa21488..0c0d48624da1d6162f0804e4a105841d965bb2c2 100644 (file)
@@ -49,67 +49,6 @@ static unsigned int path_hash(const char *path)
        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) {
@@ -180,7 +119,6 @@ static int oid_eq(const struct object_id *a, const struct object_id *b)
 
 enum rename_type {
        RENAME_NORMAL = 0,
-       RENAME_DIR,
        RENAME_DELETE,
        RENAME_ONE_FILE_TO_ONE,
        RENAME_ONE_FILE_TO_TWO,
@@ -337,37 +275,32 @@ static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)
        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;
 }
@@ -427,21 +360,6 @@ static void get_files_dirs(struct merge_options *o, struct tree *tree)
        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.
@@ -452,12 +370,12 @@ static struct stage_data *insert_stage_data(const char *path,
 {
        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;
@@ -616,10 +534,78 @@ struct rename {
         */
        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,
@@ -651,27 +637,6 @@ static int update_stages(struct merge_options *opt, const char *path,
        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,
@@ -800,20 +765,6 @@ static int would_lose_untracked(const char *path)
        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;
@@ -1163,38 +1114,6 @@ static int merge_file_one(struct merge_options *o,
        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,
@@ -1208,8 +1127,7 @@ static int handle_change_delete(struct merge_options *o,
        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);
        }
 
@@ -1324,34 +1242,17 @@ static int handle_file(struct merge_options *o,
 
        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)))
@@ -1477,43 +1378,11 @@ static int conflict_rename_rename_2to1(struct merge_options *o,
                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);
        }
@@ -1521,754 +1390,6 @@ static int conflict_rename_rename_2to1(struct merge_options *o,
        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)
@@ -2427,19 +1548,7 @@ static int process_renames(struct merge_options *o,
                        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,
@@ -2536,105 +1645,6 @@ static int process_renames(struct merge_options *o,
        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;
@@ -2725,7 +1735,6 @@ static int handle_modify_delete(struct merge_options *o,
 
 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,
@@ -2773,6 +1782,7 @@ static int merge_content(struct merge_options *o,
 
        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
@@ -2780,7 +1790,8 @@ static int merge_content(struct merge_options *o,
                 * 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;
@@ -2798,7 +1809,7 @@ static int merge_content(struct merge_options *o,
                                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);
@@ -2832,30 +1843,6 @@ static int merge_content(struct merge_options *o,
        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)
@@ -2875,20 +1862,9 @@ static int process_entry(struct merge_options *o,
                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;
@@ -2976,7 +1952,7 @@ static int process_entry(struct merge_options *o,
        } 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) {
@@ -3017,7 +1993,7 @@ int merge_trees(struct merge_options *o,
                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)
@@ -3028,8 +2004,7 @@ int merge_trees(struct merge_options *o,
        }
 
        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
@@ -3043,8 +2018,9 @@ int merge_trees(struct merge_options *o,
                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;
@@ -3069,13 +2045,16 @@ int merge_trees(struct merge_options *o,
                }
 
 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;
        }