* [PATCH 1/2] resolve-undo: allow resurrecting conflicted state that resolved to deletion
@ 2023-07-27 21:46 Junio C Hamano
2023-07-27 21:51 ` [PATCH 2/2] update-index: use unmerge_index_entry() to support removal Junio C Hamano
0 siblings, 1 reply; 3+ messages in thread
From: Junio C Hamano @ 2023-07-27 21:46 UTC (permalink / raw)
To: git
The resolve-undo index extension records up to three (mode, object
name) tuples for non-zero stages for each path that was resolved,
to be used to recreate the original conflicted state later when the
user requests.
The unmerge_index_entry_at() function uses the resolve-undo data to
do so, but it assumes that the path for which the conflicted state
needs to be recreated can be specified by the position in the
active_cache[] array. This obviously cannot salvage a conflicted
state that was resolved by removing them. A delete-modify conflict,
in which the change whose "modify" side made is a trivial typofix,
may legitimately be resolved to remove the path, and resolve-undo
extension does record the two (mode, object name) tuples for the
common ancestor version and their version, lacking our version.
Introduce a new unmerge_index_entry() helper function that takes the
path (which does not necessarily have to exist in the active_cache[]
array) and resolve-undo data, and use it to reimplement unmerge_index()
public function that is used by "git rerere".
The limited interface is still kept for now, as it is used by "git
checkout -m" and "git update-index --unmerge", but these two codepaths
will be updated to lift the assumption to allow conflicts that resolved
to deletion can be recreated.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
* No new tests, as unmerge_index() that is used by "git rerere"
already exercises the codepath. We'll use the new function also
in "update-index" in a future patch.
resolve-undo.c | 46 +++++++++++++++++++++++++++++++++++++++++-----
resolve-undo.h | 1 +
2 files changed, 42 insertions(+), 5 deletions(-)
diff --git a/resolve-undo.c b/resolve-undo.c
index 7817f5d6db..9ceab129ac 100644
--- a/resolve-undo.c
+++ b/resolve-undo.c
@@ -184,19 +184,55 @@ void unmerge_marked_index(struct index_state *istate)
}
}
+int unmerge_index_entry(struct index_state *istate, const char *path,
+ struct resolve_undo_info *ru)
+{
+ int i = index_name_pos(istate, path, strlen(path));
+
+ if (i < 0) {
+ /* unmerged? */
+ i = -i - 1;
+ if (i < istate->cache_nr &&
+ !strcmp(istate->cache[i]->name, path))
+ /* yes, it is already unmerged */
+ return 0;
+ /* fallthru: resolved to removal */
+ } else {
+ /* merged - remove it to replace it with unmerged entries */
+ remove_index_entry_at(istate, i);
+ }
+
+ for (i = 0; i < 3; i++) {
+ struct cache_entry *ce;
+ if (!ru->mode[i])
+ continue;
+ ce = make_cache_entry(istate, ru->mode[i], &ru->oid[i],
+ path, i + 1, 0);
+ if (add_index_entry(istate, ce, ADD_CACHE_OK_TO_ADD))
+ return error("cannot unmerge '%s'", path);
+ }
+ return 0;
+}
+
void unmerge_index(struct index_state *istate, const struct pathspec *pathspec)
{
- int i;
+ struct string_list_item *item;
if (!istate->resolve_undo)
return;
/* TODO: audit for interaction with sparse-index. */
ensure_full_index(istate);
- for (i = 0; i < istate->cache_nr; i++) {
- const struct cache_entry *ce = istate->cache[i];
- if (!ce_path_match(istate, ce, pathspec, NULL))
+
+ for_each_string_list_item(item, istate->resolve_undo) {
+ const char *path = item->string;
+ struct resolve_undo_info *ru = item->util;
+ if (!item->util)
+ continue;
+ if (!match_pathspec(istate, pathspec,
+ item->string, strlen(item->string),
+ 0, NULL, 0))
continue;
- i = unmerge_index_entry_at(istate, i);
+ unmerge_index_entry(istate, path, ru);
}
}
diff --git a/resolve-undo.h b/resolve-undo.h
index c5deafc92f..1ae321c88b 100644
--- a/resolve-undo.h
+++ b/resolve-undo.h
@@ -18,6 +18,7 @@ void resolve_undo_write(struct strbuf *, struct string_list *);
struct string_list *resolve_undo_read(const char *, unsigned long);
void resolve_undo_clear_index(struct index_state *);
int unmerge_index_entry_at(struct index_state *, int);
+int unmerge_index_entry(struct index_state *, const char *, struct resolve_undo_info *);
void unmerge_index(struct index_state *, const struct pathspec *);
void unmerge_marked_index(struct index_state *);
--
2.41.0-459-gb4fce4b6e4
^ permalink raw reply related [flat|nested] 3+ messages in thread
* [PATCH 2/2] update-index: use unmerge_index_entry() to support removal
2023-07-27 21:46 [PATCH 1/2] resolve-undo: allow resurrecting conflicted state that resolved to deletion Junio C Hamano
@ 2023-07-27 21:51 ` Junio C Hamano
2023-07-28 19:49 ` [PATCH 3/2] update-index: remove stale fallback code for "--unresolve" Junio C Hamano
0 siblings, 1 reply; 3+ messages in thread
From: Junio C Hamano @ 2023-07-27 21:51 UTC (permalink / raw)
To: git
"update-index --unresolve" used the unmerge_index_entry_at() that
assumed that the path to be unresolved must be in the index, which
made it impossible to unresolve a path that was resolved as removal.
Rewrite unresolve_one() to use the unmerge_index_entry() to support
unresolving such a path.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
* Now getting rid of unmerge_index_entry_at() is a bigger task. The
only remaining user of it is the "checkout -m -- $path" codepath.
builtin/update-index.c | 33 +++++++++++++++++----------------
t/t2030-unresolve-info.sh | 29 +++++++++++++++++++++++++----
2 files changed, 42 insertions(+), 20 deletions(-)
diff --git a/builtin/update-index.c b/builtin/update-index.c
index 853ec9eb7a..d02ac55313 100644
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -661,26 +661,26 @@ static int unresolve_one(const char *path)
int pos;
int ret = 0;
struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
+ struct resolve_undo_info *ru = NULL;
+
+ if (the_index.resolve_undo) {
+ struct string_list_item *item;
+ item = string_list_lookup(the_index.resolve_undo, path);
+ if (item)
+ ru = item->util;
+ }
+
+ /* resolve-undo record exists for the path */
+ if (ru)
+ return unmerge_index_entry(&the_index, path, ru);
/* See if there is such entry in the index. */
pos = index_name_pos(&the_index, path, namelen);
if (0 <= pos) {
- /* already merged */
- pos = unmerge_index_entry_at(&the_index, pos);
- if (pos < the_index.cache_nr) {
- const struct cache_entry *ce = the_index.cache[pos];
- if (ce_stage(ce) &&
- ce_namelen(ce) == namelen &&
- !memcmp(ce->name, path, namelen))
- return 0;
- }
- /* no resolve-undo information; fall back */
+ ; /* resolve-undo record was used already -- fall back */
} else {
- /* If there isn't, either it is unmerged, or
- * resolved as "removed" by mistake. We do not
- * want to do anything in the former case.
- */
- pos = -pos-1;
+ /* Is it unmerged? */
+ pos = -pos - 1;
if (pos < the_index.cache_nr) {
const struct cache_entry *ce = the_index.cache[pos];
if (ce_namelen(ce) == namelen &&
@@ -688,9 +688,10 @@ static int unresolve_one(const char *path)
fprintf(stderr,
"%s: skipping still unmerged path.\n",
path);
- goto free_return;
}
+ goto free_return;
}
+ /* No, such a path does not exist -- removed */
}
/*
diff --git a/t/t2030-unresolve-info.sh b/t/t2030-unresolve-info.sh
index d4e7760df5..6a3af64e0f 100755
--- a/t/t2030-unresolve-info.sh
+++ b/t/t2030-unresolve-info.sh
@@ -37,11 +37,17 @@ prime_resolve_undo () {
git checkout second^0 &&
test_tick &&
test_must_fail git merge third^0 &&
- echo merge does not leave anything &&
check_resolve_undo empty &&
- echo different >fi/le &&
- git add fi/le &&
- echo resolving records &&
+
+ # how should the conflict be resolved?
+ case "$1" in
+ remove)
+ rm -f file/le && git rm fi/le
+ ;;
+ *) # modify
+ echo different >fi/le && git add fi/le
+ ;;
+ esac
check_resolve_undo recorded fi/le initial:fi/le second:fi/le third:fi/le
}
@@ -134,6 +140,21 @@ test_expect_success 'unmerge can be done even after committing' '
test_line_count = 3 actual
'
+test_expect_success 'unmerge removal' '
+ prime_resolve_undo remove &&
+ git update-index --unresolve fi/le &&
+ git ls-files -u actual &&
+ test_line_count = 3 actual
+'
+
+test_expect_success 'unmerge removal after committing' '
+ prime_resolve_undo remove &&
+ git commit -m "record to nuke MERGE_HEAD" &&
+ git update-index --unresolve fi/le &&
+ git ls-files -u actual &&
+ test_line_count = 3 actual
+'
+
test_expect_success 'rerere and rerere forget' '
mkdir .git/rr-cache &&
prime_resolve_undo &&
--
2.41.0-459-gb4fce4b6e4
^ permalink raw reply related [flat|nested] 3+ messages in thread
* [PATCH 3/2] update-index: remove stale fallback code for "--unresolve"
2023-07-27 21:51 ` [PATCH 2/2] update-index: use unmerge_index_entry() to support removal Junio C Hamano
@ 2023-07-28 19:49 ` Junio C Hamano
0 siblings, 0 replies; 3+ messages in thread
From: Junio C Hamano @ 2023-07-28 19:49 UTC (permalink / raw)
To: git
The "update-index --unresolve" is a relatively old feature that was
introduced in Git v1.4.1 (June 2006), which predates the
resolve-undo extension introduced in Git v1.7.0 (February 2010).
The original code that was limited only to work during a merge (and
not during a rebase or a cherry-pick) has been kept as the fallback
codepath to be used as a transition measure.
By now, for more than 10 years we have stored resolve-undo extension
in the index file, and the fallback code way outlived its usefulness.
Remove it, together with two file-scope static global variables.
One of these variables is still used by surviving function, but it
does not have to be a global at all, so move it to local to that
function.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
builtin/update-index.c | 103 ++++-------------------------------------
1 file changed, 8 insertions(+), 95 deletions(-)
diff --git a/builtin/update-index.c b/builtin/update-index.c
index d02ac55313..79c25a2a58 100644
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -609,9 +609,6 @@ static const char * const update_index_usage[] = {
NULL
};
-static struct object_id head_oid;
-static struct object_id merge_head_oid;
-
static struct cache_entry *read_one_ent(const char *which,
struct object_id *ent, const char *path,
int namelen, int stage)
@@ -640,102 +637,17 @@ static struct cache_entry *read_one_ent(const char *which,
return ce;
}
-static int read_head_pointers(void)
-{
- static int result = -2; /* unknown yet */
-
- if (result == -2) {
- result = -1;
- if (read_ref("HEAD", &head_oid))
- return error("No HEAD -- no initial comit yet?");
- if (read_ref("MERGE_HEAD", &merge_head_oid))
- return error("Not in the middle of a merge");
- result = 0;
- }
- return result;
-}
-
static int unresolve_one(const char *path)
{
- int namelen = strlen(path);
- int pos;
- int ret = 0;
- struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
- struct resolve_undo_info *ru = NULL;
-
- if (the_index.resolve_undo) {
- struct string_list_item *item;
- item = string_list_lookup(the_index.resolve_undo, path);
- if (item)
- ru = item->util;
- }
-
- /* resolve-undo record exists for the path */
- if (ru)
- return unmerge_index_entry(&the_index, path, ru);
+ struct string_list_item *item;
- /* See if there is such entry in the index. */
- pos = index_name_pos(&the_index, path, namelen);
- if (0 <= pos) {
- ; /* resolve-undo record was used already -- fall back */
- } else {
- /* Is it unmerged? */
- pos = -pos - 1;
- if (pos < the_index.cache_nr) {
- const struct cache_entry *ce = the_index.cache[pos];
- if (ce_namelen(ce) == namelen &&
- !memcmp(ce->name, path, namelen)) {
- fprintf(stderr,
- "%s: skipping still unmerged path.\n",
- path);
- }
- goto free_return;
- }
- /* No, such a path does not exist -- removed */
- }
-
- /*
- * We are not using resolve-undo information but just
- * populating the stages #2 and #3 from HEAD and MERGE_HEAD.
- *
- * This is a flawed replacement of true "unresolve", as we do
- * not have a way to recreate the stage #1 for the common
- * ancestor (which may not be a unique merge-base between the
- * two).
- */
- if (read_head_pointers()) {
- ret = -1;
- goto free_return;
- }
-
- ce_2 = read_one_ent("our", &head_oid, path, namelen, 2);
- ce_3 = read_one_ent("their", &merge_head_oid, path, namelen, 3);
-
- if (!ce_2 || !ce_3) {
- ret = -1;
- goto free_return;
- }
- if (oideq(&ce_2->oid, &ce_3->oid) &&
- ce_2->ce_mode == ce_3->ce_mode) {
- fprintf(stderr, "%s: identical in both, skipping.\n",
- path);
- goto free_return;
- }
-
- remove_file_from_index(&the_index, path);
- if (add_index_entry(&the_index, ce_2, ADD_CACHE_OK_TO_ADD)) {
- error("%s: cannot add our version to the index.", path);
- ret = -1;
- goto free_return;
- }
- if (!add_index_entry(&the_index, ce_3, ADD_CACHE_OK_TO_ADD))
+ if (!the_index.resolve_undo)
return 0;
- error("%s: cannot add their version to the index.", path);
- ret = -1;
- free_return:
- discard_cache_entry(ce_2);
- discard_cache_entry(ce_3);
- return ret;
+ item = string_list_lookup(the_index.resolve_undo, path);
+ if (!item)
+ return 0; /* no resolve-undo record for the path */
+
+ return unmerge_index_entry(&the_index, path, item->util);
}
static int do_unresolve(int ac, const char **av,
@@ -762,6 +674,7 @@ static int do_reupdate(const char **paths,
int pos;
int has_head = 1;
struct pathspec pathspec;
+ struct object_id head_oid;
parse_pathspec(&pathspec, 0,
PATHSPEC_PREFER_CWD,
--
2.41.0-478-gee48e70a82
^ permalink raw reply related [flat|nested] 3+ messages in thread
end of thread, other threads:[~2023-07-28 19:49 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2023-07-27 21:46 [PATCH 1/2] resolve-undo: allow resurrecting conflicted state that resolved to deletion Junio C Hamano
2023-07-27 21:51 ` [PATCH 2/2] update-index: use unmerge_index_entry() to support removal Junio C Hamano
2023-07-28 19:49 ` [PATCH 3/2] update-index: remove stale fallback code for "--unresolve" Junio C Hamano
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).