]> git.ipfire.org Git - thirdparty/git.git/commitdiff
read-tree: make two-way merge sparse-aware
authorVictoria Dye <vdye@github.com>
Tue, 1 Mar 2022 20:24:30 +0000 (20:24 +0000)
committerJunio C Hamano <gitster@pobox.com>
Tue, 1 Mar 2022 20:36:01 +0000 (12:36 -0800)
Enable two-way merge with 'git read-tree' without expanding the sparse
index. When in a sparse index, a two-way merge will trivially succeed as
long as there are not changes to the same sparse directory in multiple trees
(i.e., sparse directory-level "edit-edit" conflicts). If there are such
conflicts, the merge will fail despite the possibility that individual files
could merge cleanly.

In order to resolve these "edit-edit" conflicts, "conflicted" sparse
directories are - rather than rejected - merged by traversing their
associated trees by OID. For each child of the sparse directory:

1. Files are merged as normal (see Documentation/git-read-tree.txt for
   details).
2. Subdirectories are treated as sparse directories and merged in
   'twoway_merge'. If there are no conflicts, they are merged according to
   the rules in Documentation/git-read-tree.txt; otherwise, the subdirectory
   is recursively traversed and merged.

This process allows sparse directories to be individually merged at the
necessary depth *without* expanding a full index.

The 't/t1092-sparse-checkout-compatibility.sh' test 'read-tree --merge with
edit/edit conflicts in sparse directories' tests two-way merges with 1)
changes inside sparse directories that do not conflict and 2) changes that
do conflict (with the correct file(s) reported in the error message).
Additionally, add two-way merge cases to 'sparse index is not expanded:
read-tree' to confirm that the index is not expanded regardless of whether
edit/edit conflicts are present in a sparse directory.

Signed-off-by: Victoria Dye <vdye@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
builtin/read-tree.c
t/t1092-sparse-checkout-compatibility.sh
unpack-trees.c

index ec6d038242aeceb35d09ca3da5f018df48b30b1e..9227f07ab1589272104366188c5dad41b4442c2f 100644 (file)
@@ -229,11 +229,6 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
                        opts.fn = opts.prefix ? bind_merge : oneway_merge;
                        break;
                case 2:
-                       /*
-                        * TODO: update twoway_merge to handle edit/edit conflicts in
-                        * sparse directories.
-                        */
-                       ensure_full_index(&the_index);
                        opts.fn = twoway_merge;
                        opts.initial_checkout = is_cache_unborn();
                        break;
index d98558f32389431bb027eb69cb42b9956716400a..61dc2ea777c70a32b1844af3e490eded3880a928 100755 (executable)
@@ -1413,7 +1413,9 @@ test_expect_success 'sparse index is not expanded: read-tree' '
        init_repos &&
 
        ensure_not_expanded checkout -b test-branch update-folder1 &&
-       for MERGE_TREES in "update-folder2"
+       for MERGE_TREES in "base update-folder2" \
+                          "base rename-base" \
+                          "update-folder2"
        do
                ensure_not_expanded read-tree -mu $MERGE_TREES &&
                ensure_not_expanded reset --hard || return 1
index f3667d85ec50be75868f176ceedb08822df18933..0c2a678cd6d7d4869756ac719ca896acf4533e75 100644 (file)
@@ -1360,6 +1360,42 @@ static int is_sparse_directory_entry(struct cache_entry *ce,
        return sparse_dir_matches_path(ce, info, name);
 }
 
+static int unpack_sparse_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info)
+{
+       struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, };
+       struct unpack_trees_options *o = info->data;
+       int ret;
+
+       assert(o->merge);
+
+       /*
+        * Unlike in 'unpack_callback', where src[0] is derived from the index when
+        * merging, src[0] is a transient cache entry derived from the first tree
+        * provided. Create the temporary entry as if it came from a non-sparse index.
+        */
+       if (!is_null_oid(&names[0].oid)) {
+               src[0] = create_ce_entry(info, &names[0], 0,
+                                       &o->result, 1,
+                                       dirmask & (1ul << 0));
+               src[0]->ce_flags |= (CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);
+       }
+
+       /*
+        * 'unpack_single_entry' assumes that src[0] is derived directly from
+        * the index, rather than from an entry in 'names'. This is *not* true when
+        * merging a sparse directory, in which case names[0] is the "index" source
+        * entry. To match the expectations of 'unpack_single_entry', shift past the
+        * "index" tree (i.e., names[0]) and adjust 'names', 'n', 'mask', and
+        * 'dirmask' accordingly.
+        */
+       ret = unpack_single_entry(n - 1, mask >> 1, dirmask >> 1, src, names + 1, info);
+
+       if (src[0])
+               discard_cache_entry(src[0]);
+
+       return ret >= 0 ? mask : -1;
+}
+
 /*
  * Note that traverse_by_cache_tree() duplicates some logic in this function
  * without actually calling it. If you change the logic here you may need to
@@ -2472,6 +2508,37 @@ static int merged_entry(const struct cache_entry *ce,
        return 1;
 }
 
+static int merged_sparse_dir(const struct cache_entry * const *src, int n,
+                            struct unpack_trees_options *o)
+{
+       struct tree_desc t[MAX_UNPACK_TREES + 1];
+       void * tree_bufs[MAX_UNPACK_TREES + 1];
+       struct traverse_info info;
+       int i, ret;
+
+       /*
+        * Create the tree traversal information for traversing into *only* the
+        * sparse directory.
+        */
+       setup_traverse_info(&info, src[0]->name);
+       info.fn = unpack_sparse_callback;
+       info.data = o;
+       info.show_all_errors = o->show_all_errors;
+       info.pathspec = o->pathspec;
+
+       /* Get the tree descriptors of the sparse directory in each of the merging trees */
+       for (i = 0; i < n; i++)
+               tree_bufs[i] = fill_tree_descriptor(o->src_index->repo, &t[i],
+                                                   src[i] && !is_null_oid(&src[i]->oid) ? &src[i]->oid : NULL);
+
+       ret = traverse_trees(o->src_index, n, t, &info);
+
+       for (i = 0; i < n; i++)
+               free(tree_bufs[i]);
+
+       return ret;
+}
+
 static int deleted_entry(const struct cache_entry *ce,
                         const struct cache_entry *old,
                         struct unpack_trees_options *o)
@@ -2742,6 +2809,14 @@ int twoway_merge(const struct cache_entry * const *src,
                         * reject the merge instead.
                         */
                        return merged_entry(newtree, current, o);
+               } else if (S_ISSPARSEDIR(current->ce_mode)) {
+                       /*
+                        * The sparse directories differ, but we don't know whether that's
+                        * because of two different files in the directory being modified
+                        * (can be trivially merged) or if there is a real file conflict.
+                        * Merge the sparse directory by OID to compare file-by-file.
+                        */
+                       return merged_sparse_dir(src, 3, o);
                } else
                        return reject_merge(current, o);
        }