mirror of
https://github.com/git/git.git
synced 2024-05-12 17:36:08 +02:00
Merge branch 'en/rename-directory-detection'
Rename detection logic in "diff" family that is used in "merge" has learned to guess when all of x/a, x/b and x/c have moved to z/a, z/b and z/c, it is likely that x/d added in the meantime would also want to move to z/d by taking the hint that the entire directory 'x' moved to 'z'. A bug causing dirty files involved in a rename to be overwritten during merge has also been fixed as part of this work. * en/rename-directory-detection: (29 commits) merge-recursive: ensure we write updates for directory-renamed file merge-recursive: avoid spurious rename/rename conflict from dir renames directory rename detection: new testcases showcasing a pair of bugs merge-recursive: fix remaining directory rename + dirty overwrite cases merge-recursive: fix overwriting dirty files involved in renames merge-recursive: avoid clobbering untracked files with directory renames merge-recursive: apply necessary modifications for directory renames merge-recursive: when comparing files, don't include trees merge-recursive: check for file level conflicts then get new name merge-recursive: add computation of collisions due to dir rename & merging merge-recursive: check for directory level conflicts merge-recursive: add get_directory_renames() merge-recursive: make a helper function for cleanup for handle_renames merge-recursive: split out code for determining diff_filepairs merge-recursive: make !o->detect_rename codepath more obvious merge-recursive: fix leaks of allocated renames and diff_filepairs merge-recursive: introduce new functions to handle rename logic merge-recursive: move the get_renames() function directory rename detection: tests for handling overwriting dirty files directory rename detection: tests for handling overwriting untracked files ...
This commit is contained in:
commit
e4bb62fa1e
1243
merge-recursive.c
1243
merge-recursive.c
|
@ -49,6 +49,67 @@ 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) {
|
||||
|
@ -119,6 +180,7 @@ 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,
|
||||
|
@ -275,32 +337,37 @@ 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(int index_only,
|
||||
static int git_merge_trees(struct merge_options *o,
|
||||
struct tree *common,
|
||||
struct tree *head,
|
||||
struct tree *merge)
|
||||
{
|
||||
int rc;
|
||||
struct tree_desc t[3];
|
||||
struct unpack_trees_options opts;
|
||||
|
||||
memset(&opts, 0, sizeof(opts));
|
||||
if (index_only)
|
||||
opts.index_only = 1;
|
||||
memset(&o->unpack_opts, 0, sizeof(o->unpack_opts));
|
||||
if (o->call_depth)
|
||||
o->unpack_opts.index_only = 1;
|
||||
else
|
||||
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");
|
||||
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");
|
||||
|
||||
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, &opts);
|
||||
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;
|
||||
cache_tree_free(&active_cache_tree);
|
||||
return rc;
|
||||
}
|
||||
|
@ -360,6 +427,21 @@ 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(const unsigned char *tree,
|
||||
const char *path,
|
||||
unsigned char *hashy,
|
||||
unsigned int *mode_o)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = get_tree_entry(tree, path, hashy, mode_o);
|
||||
if (S_ISDIR(*mode_o)) {
|
||||
hashcpy(hashy, null_sha1);
|
||||
*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.
|
||||
|
@ -370,12 +452,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(o->object.oid.hash, path,
|
||||
e->stages[1].oid.hash, &e->stages[1].mode);
|
||||
get_tree_entry(a->object.oid.hash, path,
|
||||
e->stages[2].oid.hash, &e->stages[2].mode);
|
||||
get_tree_entry(b->object.oid.hash, path,
|
||||
e->stages[3].oid.hash, &e->stages[3].mode);
|
||||
get_tree_entry_if_blob(o->object.oid.hash, path,
|
||||
e->stages[1].oid.hash, &e->stages[1].mode);
|
||||
get_tree_entry_if_blob(a->object.oid.hash, path,
|
||||
e->stages[2].oid.hash, &e->stages[2].mode);
|
||||
get_tree_entry_if_blob(b->object.oid.hash, path,
|
||||
e->stages[3].oid.hash, &e->stages[3].mode);
|
||||
item = string_list_insert(entries, path);
|
||||
item->util = e;
|
||||
return e;
|
||||
|
@ -534,78 +616,10 @@ 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,
|
||||
|
@ -637,6 +651,27 @@ 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,
|
||||
|
@ -765,6 +800,20 @@ 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;
|
||||
|
@ -1114,6 +1163,38 @@ 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,
|
||||
|
@ -1127,7 +1208,8 @@ 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)) {
|
||||
if (dir_in_way(path, !o->call_depth, 0) ||
|
||||
(!o->call_depth && would_lose_untracked(path))) {
|
||||
update_path = alt_path = unique_path(o, path, change_branch);
|
||||
}
|
||||
|
||||
|
@ -1242,17 +1324,34 @@ 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;
|
||||
|
||||
remove_file(o, 0, rename->path, 0);
|
||||
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);
|
||||
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)))
|
||||
|
@ -1378,11 +1477,43 @@ 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);
|
||||
remove_file(o, 0, path, 0);
|
||||
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);
|
||||
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);
|
||||
}
|
||||
|
@ -1390,6 +1521,754 @@ 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)
|
||||
{
|
||||
unsigned char hashy[GIT_MAX_RAWSZ];
|
||||
unsigned int mode_o;
|
||||
|
||||
return !get_tree_entry(tree->object.oid.hash, 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.hash,
|
||||
pair->two->path,
|
||||
re->dst_entry->stages[stage].oid.hash,
|
||||
&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)
|
||||
|
@ -1548,7 +2427,19 @@ 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)) {
|
||||
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)) {
|
||||
setup_rename_conflict_info(RENAME_DELETE,
|
||||
ren1->pair,
|
||||
NULL,
|
||||
|
@ -1645,6 +2536,105 @@ 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;
|
||||
|
@ -1735,6 +2725,7 @@ 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,
|
||||
|
@ -1782,7 +2773,6 @@ 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
|
||||
|
@ -1790,8 +2780,7 @@ 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).
|
||||
*/
|
||||
path_renamed_outside_HEAD = !path2 || !strcmp(path, path2);
|
||||
if (!path_renamed_outside_HEAD) {
|
||||
if (was_tracked(path)) {
|
||||
add_cacheinfo(o, mfi.mode, &mfi.oid, path,
|
||||
0, (!o->call_depth), 0);
|
||||
return mfi.clean;
|
||||
|
@ -1809,7 +2798,7 @@ static int merge_content(struct merge_options *o,
|
|||
return -1;
|
||||
}
|
||||
|
||||
if (df_conflict_remains) {
|
||||
if (df_conflict_remains || file_in_way) {
|
||||
char *new_path;
|
||||
if (o->call_depth) {
|
||||
remove_file_from_cache(path);
|
||||
|
@ -1843,6 +2832,30 @@ 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)
|
||||
|
@ -1862,9 +2875,20 @@ static int process_entry(struct merge_options *o,
|
|||
switch (conflict_info->rename_type) {
|
||||
case RENAME_NORMAL:
|
||||
case RENAME_ONE_FILE_TO_ONE:
|
||||
clean_merge = merge_content(o, path,
|
||||
o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
|
||||
conflict_info);
|
||||
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;
|
||||
break;
|
||||
case RENAME_DELETE:
|
||||
clean_merge = 0;
|
||||
|
@ -1952,7 +2976,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,
|
||||
clean_merge = merge_content(o, path, 0 /* file_in_way */,
|
||||
o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
|
||||
NULL);
|
||||
} else if (!o_oid && !a_oid && !b_oid) {
|
||||
|
@ -1993,7 +3017,7 @@ int merge_trees(struct merge_options *o,
|
|||
return 1;
|
||||
}
|
||||
|
||||
code = git_merge_trees(o->call_depth, common, head, merge);
|
||||
code = git_merge_trees(o, common, head, merge);
|
||||
|
||||
if (code != 0) {
|
||||
if (show(o, 4) || o->call_depth)
|
||||
|
@ -2004,7 +3028,8 @@ int merge_trees(struct merge_options *o,
|
|||
}
|
||||
|
||||
if (unmerged_cache()) {
|
||||
struct string_list *entries, *re_head, *re_merge;
|
||||
struct string_list *entries;
|
||||
struct rename_info re_info;
|
||||
int i;
|
||||
/*
|
||||
* Only need the hashmap while processing entries, so
|
||||
|
@ -2018,9 +3043,8 @@ int merge_trees(struct merge_options *o,
|
|||
get_files_dirs(o, merge);
|
||||
|
||||
entries = get_unmerged();
|
||||
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);
|
||||
clean = handle_renames(o, common, head, merge, entries,
|
||||
&re_info);
|
||||
record_df_conflict_files(o, entries);
|
||||
if (clean < 0)
|
||||
goto cleanup;
|
||||
|
@ -2045,16 +3069,13 @@ int merge_trees(struct merge_options *o,
|
|||
}
|
||||
|
||||
cleanup:
|
||||
string_list_clear(re_merge, 0);
|
||||
string_list_clear(re_head, 0);
|
||||
final_cleanup_renames(&re_info);
|
||||
|
||||
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;
|
||||
}
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
#ifndef MERGE_RECURSIVE_H
|
||||
#define MERGE_RECURSIVE_H
|
||||
|
||||
#include "unpack-trees.h"
|
||||
#include "string-list.h"
|
||||
|
||||
struct merge_options {
|
||||
|
@ -27,6 +28,32 @@ struct merge_options {
|
|||
struct strbuf obuf;
|
||||
struct hashmap current_file_dir_set;
|
||||
struct string_list df_conflict_file_set;
|
||||
struct unpack_trees_options unpack_opts;
|
||||
};
|
||||
|
||||
/*
|
||||
* For dir_rename_entry, directory names are stored as a full path from the
|
||||
* toplevel of the repository and do not include a trailing '/'. Also:
|
||||
*
|
||||
* dir: original name of directory being renamed
|
||||
* non_unique_new_dir: if true, could not determine new_dir
|
||||
* new_dir: final name of directory being renamed
|
||||
* possible_new_dirs: temporary used to help determine new_dir; see comments
|
||||
* in get_directory_renames() for details
|
||||
*/
|
||||
struct dir_rename_entry {
|
||||
struct hashmap_entry ent; /* must be the first member! */
|
||||
char *dir;
|
||||
unsigned non_unique_new_dir:1;
|
||||
struct strbuf new_dir;
|
||||
struct string_list possible_new_dirs;
|
||||
};
|
||||
|
||||
struct collision_entry {
|
||||
struct hashmap_entry ent; /* must be the first member! */
|
||||
char *target_file;
|
||||
struct string_list source_files;
|
||||
unsigned reported_already:1;
|
||||
};
|
||||
|
||||
/* merge_trees() but with recursive ancestor consolidation */
|
||||
|
|
16
strbuf.c
16
strbuf.c
|
@ -1,5 +1,6 @@
|
|||
#include "cache.h"
|
||||
#include "refs.h"
|
||||
#include "string-list.h"
|
||||
#include "utf8.h"
|
||||
|
||||
int starts_with(const char *str, const char *prefix)
|
||||
|
@ -171,6 +172,21 @@ struct strbuf **strbuf_split_buf(const char *str, size_t slen,
|
|||
return ret;
|
||||
}
|
||||
|
||||
void strbuf_add_separated_string_list(struct strbuf *str,
|
||||
const char *sep,
|
||||
struct string_list *slist)
|
||||
{
|
||||
struct string_list_item *item;
|
||||
int sep_needed = 0;
|
||||
|
||||
for_each_string_list_item(item, slist) {
|
||||
if (sep_needed)
|
||||
strbuf_addstr(str, sep);
|
||||
strbuf_addstr(str, item->string);
|
||||
sep_needed = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void strbuf_list_free(struct strbuf **sbs)
|
||||
{
|
||||
struct strbuf **s = sbs;
|
||||
|
|
16
strbuf.h
16
strbuf.h
|
@ -1,6 +1,8 @@
|
|||
#ifndef STRBUF_H
|
||||
#define STRBUF_H
|
||||
|
||||
struct string_list;
|
||||
|
||||
/**
|
||||
* strbuf's are meant to be used with all the usual C string and memory
|
||||
* APIs. Given that the length of the buffer is known, it's often better to
|
||||
|
@ -531,6 +533,20 @@ static inline struct strbuf **strbuf_split(const struct strbuf *sb,
|
|||
return strbuf_split_max(sb, terminator, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Adds all strings of a string list to the strbuf, separated by the given
|
||||
* separator. For example, if sep is
|
||||
* ', '
|
||||
* and slist contains
|
||||
* ['element1', 'element2', ..., 'elementN'],
|
||||
* then write:
|
||||
* 'element1, element2, ..., elementN'
|
||||
* to str. If only one element, just write "element1" to str.
|
||||
*/
|
||||
extern void strbuf_add_separated_string_list(struct strbuf *str,
|
||||
const char *sep,
|
||||
struct string_list *slist);
|
||||
|
||||
/**
|
||||
* Free a NULL-terminated list of strbufs (for example, the return
|
||||
* values of the strbuf_split*() functions).
|
||||
|
|
|
@ -141,7 +141,7 @@ test_expect_success 'cherry-pick "-" works with arguments' '
|
|||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_failure 'cherry-pick works with dirty renamed file' '
|
||||
test_expect_success 'cherry-pick works with dirty renamed file' '
|
||||
test_commit to-rename &&
|
||||
git checkout -b unrelated &&
|
||||
test_commit unrelated &&
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -92,7 +92,7 @@ test_expect_success 'will not overwrite removed file with staged changes' '
|
|||
test_cmp important c1.c
|
||||
'
|
||||
|
||||
test_expect_failure 'will not overwrite unstaged changes in renamed file' '
|
||||
test_expect_success 'will not overwrite unstaged changes in renamed file' '
|
||||
git reset --hard c1 &&
|
||||
git mv c1.c other.c &&
|
||||
git commit -m rename &&
|
||||
|
|
|
@ -1509,8 +1509,8 @@ static int verify_uptodate_1(const struct cache_entry *ce,
|
|||
add_rejected_path(o, error_type, ce->name);
|
||||
}
|
||||
|
||||
static int verify_uptodate(const struct cache_entry *ce,
|
||||
struct unpack_trees_options *o)
|
||||
int verify_uptodate(const struct cache_entry *ce,
|
||||
struct unpack_trees_options *o)
|
||||
{
|
||||
if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))
|
||||
return 0;
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
#ifndef UNPACK_TREES_H
|
||||
#define UNPACK_TREES_H
|
||||
|
||||
#include "tree-walk.h"
|
||||
#include "string-list.h"
|
||||
|
||||
#define MAX_UNPACK_TREES 8
|
||||
|
@ -78,6 +79,9 @@ struct unpack_trees_options {
|
|||
extern int unpack_trees(unsigned n, struct tree_desc *t,
|
||||
struct unpack_trees_options *options);
|
||||
|
||||
int verify_uptodate(const struct cache_entry *ce,
|
||||
struct unpack_trees_options *o);
|
||||
|
||||
int threeway_merge(const struct cache_entry * const *stages,
|
||||
struct unpack_trees_options *o);
|
||||
int twoway_merge(const struct cache_entry * const *src,
|
||||
|
|
Loading…
Reference in New Issue