merge-ort: add implementation of both sides renaming identically

Implement rename/rename(1to1) handling, i.e. both sides of history
renaming a file but renaming the same way.  This code replaces the
following from merge-recurisve.c:

  * all the 1to1 code in process_renames()
  * the RENAME_ONE_FILE_TO_ONE case of process_entry()

Also, there is some shared code from merge-recursive.c for multiple
different rename cases which we will no longer need for this case (or
other rename cases):

  * handle_rename_normal()
  * setup_rename_conflict_info()

The consolidation of four separate codepaths into one is made possible
by a change in design: process_renames() tweaks the conflict_info
entries within opt->priv->paths such that process_entry() can then
handle all the non-rename conflict types (directory/file, modify/delete,
etc.) orthogonally.  This means we're much less likely to miss special
implementation of some kind of combination of conflict types (see
commits brought in by 66c62eaec6 ("Merge branch 'en/merge-tests'",
2020-11-18), especially commit ef52778708 ("merge tests: expect improved
directory/file conflict handling in ort", 2020-10-26) for more details).
That, together with letting worktree/index updating be handled
orthogonally in the merge_switch_to_result() function, dramatically
simplifies the code for various special rename cases.

Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/merge-ort.c b/merge-ort.c
index ebe275ef73c9f2c2065ebb1940353ea790159967..da3715baa63fcc5f9d1d9568493e58358b2acfa5 100644 (file)
--- a/merge-ort.c
+++ b/merge-ort.c
@@ -674,14 +674,30 @@ static int process_renames(struct merge_options *opt,
                    !strcmp(oldpath, renames->queue[i+1]->one->path)) {
                        /* Handle rename/rename(1to2) or rename/rename(1to1) */
                        const char *pathnames[3];
+                       struct version_info merged;
+                       struct conflict_info *base, *side1, *side2;
 
                        pathnames[0] = oldpath;
                        pathnames[1] = newpath;
                        pathnames[2] = renames->queue[i+1]->two->path;
 
+                       base = strmap_get(&opt->priv->paths, pathnames[0]);
+                       side1 = strmap_get(&opt->priv->paths, pathnames[1]);
+                       side2 = strmap_get(&opt->priv->paths, pathnames[2]);
+
+                       VERIFY_CI(base);
+                       VERIFY_CI(side1);
+                       VERIFY_CI(side2);
+
                        if (!strcmp(pathnames[1], pathnames[2])) {
-                               /* Both sides renamed the same way. */
-                               die("Not yet implemented");
+                               /* Both sides renamed the same way */
+                               assert(side1 == side2);
+                               memcpy(&side1->stages[0], &base->stages[0],
+                                      sizeof(merged));
+                               side1->filemask |= (1 << MERGE_BASE);
+                               /* Mark base as resolved by removal */
+                               base->merged.is_null = 1;
+                               base->merged.clean = 1;
 
                                /* We handled both renames, i.e. i+1 handled */
                                i++;