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

[PATCH v8 19/29] merge-recursive: check for directory level conflicts

From
Elijah Newren <newren@gmail.com>
Date
Feb 14, 2018, 18:51 UTC
Message-ID
<20180214185206.15492-20-newren@gmail.com>
In-Reply-To
<20180214185206.15492-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 directory level. There will be additional checks at the individual file level too, which will be added later.

Reviewed-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 merge-recursive.c | 119 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 119 insertions(+)
diff --git a/merge-recursive.c b/merge-recursive.c
index aca4acdfcb..a9f1579d22 100644
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -1394,6 +1394,15 @@ static struct diff_queue_struct *get_diffpairs(struct merge_options *o,
 	return ret;
 }
 
+static int tree_has_path(struct tree *tree, const char *path)
+{
+	unsigned char hashy[GIT_MAX_RAWSZ];
+	unsigned int mode_o;
+
+	return !get_tree_entry(tree->object.oid.hash, path,
+			       hashy, &mode_o);
+}
+
 static void get_renamed_dir_portion(const char *old_path, const char *new_path,
 				    char **old_dir, char **new_dir)
 {
@@ -1449,6 +1458,112 @@ static void get_renamed_dir_portion(const char *old_path, const char *new_path,
 	}
 }
 
+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);
+}
+
+/*
+ * 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)
 {
@@ -1910,6 +2025,10 @@ static int handle_renames(struct merge_options *o,
 	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, head,
 					 common, head, merge, entries);
 	ri->merge_renames = get_renames(o, merge_pairs, merge,

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

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.