git/list[1] front-page[2] threads[3] people[4] search[5] about
 

[PATCH v2 25/33] merge-recursive: check for file level conflicts then get new name

From
Elijah Newren <newren@gmail.com>
Date
Nov 20, 2017, 22:02 UTC
Message-ID
<20171120220209.15111-26-newren@gmail.com>
In-Reply-To
<20171120220209.15111-1-newren@gmail.com>

Before trying to apply directory renames to paths within the given directories, we want to make sure that there aren't conflicts at the file level either. If there aren't any, then get the new name from any directory renames.

Signed-off-by: Elijah Newren <newren@gmail.com>
---
 merge-recursive.c                   | 190 ++++++++++++++++++++++++++++++++++--
 t/t6043-merge-rename-directories.sh |   2 +-
 2 files changed, 183 insertions(+), 9 deletions(-)
diff --git a/merge-recursive.c b/merge-recursive.c
index 939b3ea5e7..6a17bcee33 100644
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -1493,6 +1493,107 @@ static void get_renamed_dir_portion(const char *old_path, const char *new_path,
 	}
 }
 
+/*
+ * Write:
+ *   element1, element2, element3, ..., elementN
+ * to str.  If only one element, just write "element1" to str.
+ */
+static void comma_separated_list(char *str, struct string_list *slist)
+{
+	int i;
+
+	for (i = 0; i < slist->nr; i++) {
+		str += sprintf(str, "%s", slist->items[i].string);
+		if (i < slist->nr-1)
+			str += sprintf(str, ", ");
+	}
+}
+
+/*
+ * 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;
+
+	/*
+	 * 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.
+	 */
+	char collision_paths[(PATH_MAX+2) * collision_ent->source_files.nr];
+
+	if (collision_ent->reported_already) {
+		clean = 0;
+	} else if (tree_has_path(tree, new_path)) {
+		collision_ent->reported_already = 1;
+		comma_separated_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);
+		clean = 0;
+	} else if (collision_ent->source_files.nr > 1) {
+		collision_ent->reported_already = 1;
+		comma_separated_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);
+		clean = 0;
+	}
+
+	/* Free memory we no longer need */
+	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
@@ -1742,6 +1843,60 @@ static void compute_collisions(struct hashmap *collisions,
 	}
 }
 
+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);
+
+	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.
+	 */
+	struct dir_rename_entry *oentry = NULL;
+
+	oentry = dir_rename_find_entry(dir_rename_exclusions, entry->new_dir);
+	if (oentry) {
+		output(o, 1, _("WARNING: Avoiding applying %s -> %s rename "
+			       "to %s, because %s itself was renamed."),
+		       entry->dir, entry->new_dir, path, entry->new_dir);
+	} else {
+		new_path = handle_path_level_conflicts(o, path, entry,
+						       collisions, tree);
+		*clean_merge &= (new_path != NULL);
+	}
+
+	return 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.
@@ -1752,11 +1907,13 @@ static void compute_collisions(struct hashmap *collisions,
 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)
+				       struct string_list *entries,
+				       int *clean_merge)
 {
 	int i;
 	struct hashmap collisions;
@@ -1771,11 +1928,22 @@ static struct string_list *get_renames(struct merge_options *o,
 		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 != 'R') {
+		if (pair->status == 'D') {
+			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->pair = pair;
@@ -2076,7 +2244,7 @@ static int handle_renames(struct merge_options *o,
 	struct hashmap *dir_re_head, *dir_re_merge;
 	struct hashmap_iter iter;
 	struct dir_rename_entry *e;
-	int clean;
+	int clean = 1;
 
 	if (!o->detect_rename) {
 		ri->head_renames = NULL;
@@ -2095,12 +2263,18 @@ static int handle_renames(struct merge_options *o,
 					 dir_re_merge, merge);
 
 	ri->head_renames  = get_renames(o, head_pairs,
-					dir_re_merge, head,
-					common, head, merge, entries);
+					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, merge,
-					 common, head, merge, entries);
-	clean = process_renames(o, ri->head_renames, ri->merge_renames);
+					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:
 	/*
diff --git a/t/t6043-merge-rename-directories.sh b/t/t6043-merge-rename-directories.sh
index 88243651f7..a45425f4d7 100755
--- a/t/t6043-merge-rename-directories.sh
+++ b/t/t6043-merge-rename-directories.sh
@@ -477,7 +477,7 @@ test_expect_success '2a-setup: Directory split into two on one side, with equal
 	)
 '
 
-test_expect_failure '2a-check: Directory split into two on one side, with equal numbers of paths' '
+test_expect_success '2a-check: Directory split into two on one side, with equal numbers of paths' '
 	(
 		cd 2a &&
 

-- 
2.15.0.309.g00c152f825
Previous: Elijah NewrenNext: Elijah Newren
Message 6 of 34 in “Add directory rename detection to git”
  1. 00/33 Add directory rename detection to gitElijah Newren, Nov 20, 2017
  2. 04/33 directory rename detection: basic testcasesElijah Newren, Nov 20, 2017
  3. 06/33 directory rename detection: testcases to avoid taking detection too farElijah Newren, Nov 20, 2017
  4. 24/33 merge-recursive: add computation of collisions due to dir rename & mergingElijah Newren, Nov 20, 2017
  5. 22/33 merge-recursive: check for directory level conflictsElijah Newren, Nov 20, 2017
  6. 25/33 merge-recursive: check for file level conflicts then get new nameElijah Newren, Nov 20, 2017
  7. 29/33 merge-recursive: fix overwriting dirty files involved in renamesElijah Newren, Nov 20, 2017
  8. 30/33 merge-recursive: fix remaining directory rename + dirty overwrite casesElijah Newren, Nov 20, 2017
  9. 31/33 directory rename detection: new testcases showcasing a pair of bugsElijah Newren, Nov 20, 2017
  10. 17/33 merge-recursive: fix leaks of allocated renames and diff_filepairsElijah Newren, Nov 20, 2017
  11. 33/33 merge-recursive: ensure we write updates for directory-renamed fileElijah Newren, Nov 20, 2017
  12. 28/33 merge-recursive: avoid clobbering untracked files with directory renamesElijah Newren, Nov 20, 2017
  13. 18/33 merge-recursive: make !o->detect_rename codepath more obviousElijah Newren, Nov 20, 2017
  14. 26/33 merge-recursive: when comparing files, don't include treesElijah Newren, Nov 20, 2017
  15. 11/33 directory rename detection: testcases exploring possibly suboptimal mergesElijah Newren, Nov 20, 2017
  16. 32/33 merge-recursive: avoid spurious rename/rename conflict from dir renamesElijah Newren, Nov 20, 2017
  17. 21/33 merge-recursive: add get_directory_renames()Elijah Newren, Nov 20, 2017
  18. 10/33 directory rename detection: more involved edge/corner testcasesElijah Newren, Nov 20, 2017
  19. 27/33 merge-recursive: apply necessary modifications for directory renamesElijah Newren, Nov 20, 2017
  20. 23/33 merge-recursive: add a new hashmap for storing file collisionsElijah Newren, Nov 20, 2017
  21. 20/33 merge-recursive: add a new hashmap for storing directory renamesElijah Newren, Nov 20, 2017
  22. 02/33 merge-recursive: fix logic ordering issueElijah Newren, Nov 20, 2017
  23. 12/33 directory rename detection: miscellaneous testcases to complete coverageElijah Newren, Nov 20, 2017
  24. 05/33 directory rename detection: directory splitting testcasesElijah Newren, Nov 20, 2017
  25. 19/33 merge-recursive: split out code for determining diff_filepairsElijah Newren, Nov 20, 2017
  26. 15/33 merge-recursive: move the get_renames() functionElijah Newren, Nov 20, 2017
  27. 16/33 merge-recursive: introduce new functions to handle rename logicElijah Newren, Nov 20, 2017
  28. 13/33 directory rename detection: tests for handling overwriting untracked filesElijah Newren, Nov 20, 2017
  29. 14/33 directory rename detection: tests for handling overwriting dirty filesElijah Newren, Nov 20, 2017
  30. 03/33 merge-recursive: add explanation for src_entry and dst_entryElijah Newren, Nov 20, 2017
  31. 01/33 Tighten and correct a few testcases for merging and cherry-pickingElijah Newren, Nov 20, 2017
  32. 09/33 directory rename detection: testcases checking which side did the renameElijah Newren, Nov 20, 2017
  33. 07/33 directory rename detection: partially renamed directory testcase/discussionElijah Newren, Nov 20, 2017
  34. 08/33 directory rename detection: files/directories in the way of some renamesElijah Newren, Nov 20, 2017

Read the whole thread, see it on lore, or plain text.

$ cat FOOTERMessages come from the public archive at lore.kernel.org/git, fetched every hour. The front page is chosen and written each morning by an AI editor and can be wrong; the threads themselves are the record. About and API. For agents: an MCP server at https://gitlist.dev/mcp, and any thread, story or person page as Markdown by adding .md to its URL (or sending Accept: text/markdown). Details in /llms.txt.