[PATCH v4 0/4] worktree: treat a branch being rebased or bisected as checked out
- From
- Jasper Mayone <me@jaspermayone.com>
- Date
- Nov 2, 2026, 18:29 UTC
- Message-ID
- <20261102182930.3511-1-me@jaspermayone.com>
- In-Reply-To
- <20261030142137.54750-1-me@jaspermayone.com>
While a worktree is rebasing or bisecting a branch, its HEAD is detached. "git worktree add" and "git branch -d" already treat the branch as checked out there, but "git worktree remove" deletes such a worktree when its files are clean, and %(worktreepath) and "git branch" do not show which worktree has the branch.
Patch 1 makes "git worktree remove" refuse a worktree in the middle of an operation unless --force is given. Patch 2 documents how to read %(worktreepath) safely. Patch 3 makes %(worktreepath) name the worktree that is rebasing or bisecting a branch, and patch 4 keeps "git branch" from marking that branch with "+" in that worktree.
Changes since v3 [1]:
* Patch 1: also refuse a worktree that has CHERRY_PICK_HEAD or REVERT_HEAD, for a single cherry-pick or revert whose files are clean, with tests. The git-worktree documentation now lists the cases that need --force. The tests use a shared setup and subshells. Dropped the Helped-by trailer, as Phillip asked.
* Patch 2 is new. It adds the notes that Phillip suggested to the documentation of %(worktreepath): the path can contain a newline, and only one worktree is shown for a branch that is checked out in more than one.
* Patch 3: %(worktreepath) now uses a new branch.c function, branch_checked_out_worktree(), that reads the list that prepare_checked_out_branches() builds, in place of a copy of that code in ref-filter.c. ref-filter.c loses its own worktree map. The commit message explains why branches that "rebase --update-refs" will update are not included, and the change for the HEAD of a bare repository, which now has a test.
* Patch 4 is new. "git branch" no longer marks a branch with "+" in the worktree that is rebasing or bisecting it, because the "(no branch, ...)" line already names it.
[1] https://lore.kernel.org/git/20261030142137.54750-1-me@jaspermayone.com/
Jasper Mayone (4): worktree remove: refuse a worktree in the middle of an operation doc: for-each-ref: say how to read %(worktreepath) safely ref-filter: name the worktree of a branch being rebased or bisected branch: do not mark the branch the current worktree is rebasing
Documentation/git-branch.adoc | 6 +- Documentation/git-for-each-ref.adoc | 12 +++- Documentation/git-worktree.adoc | 17 +++-- branch.c | 13 ++++ branch.h | 9 +++ builtin/branch.c | 103 +++++++++++++++++++++------- builtin/worktree.c | 37 +++++++++- ref-filter.c | 74 +------------------- t/t2403-worktree-move.sh | 94 +++++++++++++++++++++++++ t/t3203-branch-output.sh | 49 +++++++++++++ t/t6302-for-each-ref-filter.sh | 76 ++++++++++++++++++++ 11 files changed, 386 insertions(+), 104 deletions(-)
Range-diff against v3:
1: a79b69a0e4 ! 1: bca692b844 worktree remove: refuse a worktree in the middle of a rebase or bisect
@@ Metadata
Author: Jasper Mayone <me@jaspermayone.com>
## Commit message ##
- worktree remove: refuse a worktree in the middle of a rebase or bisect
+ worktree remove: refuse a worktree in the middle of an operation
- "git worktree remove" refuses a worktree with modified or untracked
- files unless --force is given, but it removes a worktree that is in
- the middle of a rebase, a "git am" session, a bisect or a cherry-pick
- or revert sequence when its files happen to be clean. The state of
- that operation lives in the worktree's own $GIT_DIR, so it is lost
- with the worktree. A rebase stopped at an "edit" or "break" line, an
- "exec" that failed, or a cherry-pick sequence after a conflict was
- resolved and committed is clean in this sense and still has work in
- progress.
+ "git worktree remove" refuses to remove a worktree with modified or
+ untracked files unless --force is given, but it removes a worktree
+ that is in the middle of a rebase, a "git am" session, a bisect, a
+ cherry-pick or a revert when its files happen to be clean. The state
+ of that operation lives in the worktree's own $GIT_DIR, so it is lost
+ with the worktree. Examples of such a clean worktree are a rebase
+ stopped at an "edit" or "break" line or after a failed "exec", a
+ cherry-pick sequence after a conflict was resolved and committed, and
+ a single cherry-pick or revert whose conflict was resolved to the
+ current contents, which leaves CHERRY_PICK_HEAD or REVERT_HEAD behind.
Treat such a worktree as unclean: refuse to remove it unless --force
is given, and name the operation in the message.
@@ Commit message
worktree, which is only done when the directory exists.
Reported-by: D. Ben Knoble <ben.knoble@gmail.com>
- Helped-by: Phillip Wood <phillip.wood123@gmail.com>
Signed-off-by: Jasper Mayone <me@jaspermayone.com>
## Documentation/git-worktree.adoc ##
@@ Documentation/git-worktree.adoc: the new working tree location.
+
`remove`::
- Remove a worktree. Only clean worktrees (no untracked files and no
+-Remove a worktree. Only clean worktrees (no untracked files and no
-modification in tracked files) can be removed. Unclean worktrees or ones
-with submodules can be removed with `--force`. The main worktree cannot be
-removed.
-+modification in tracked files) can be removed. A worktree in the middle
-+of a rebase, a `git am` session, a bisect or a cherry-pick or revert
-+sequence is not clean either, because removing it loses that state. Unclean worktrees or ones with submodules
-+can be removed with `--force`. The main worktree cannot be removed.
++Remove a worktree. The main worktree cannot be removed. Without
++`--force`, a worktree is not removed when:
+++
++--
++* it has untracked files or modifications in tracked files,
++* it has submodules, or
++* it is in the middle of a rebase, a `git am` session, a bisect, a
++ cherry-pick or a revert, because removing it loses the state of that
++ operation.
++--
`repair [<path>...]`::
@@ Documentation/git-worktree.adoc: twice. If the destination is already assigned t
allows the move to proceed; use `--force` twice if the destination is locked.
+
-`remove` refuses to remove an unclean worktree unless `--force` is used.
-+`remove` refuses to remove an unclean worktree, or one in the middle of a
-+rebase, `git am` session, bisect, or cherry-pick or revert sequence,
-+unless `--force` is used.
++`remove` refuses to remove a worktree in the cases listed under
++`remove` above unless `--force` is used.
To remove a locked worktree, specify `--force` twice.
`-b <new-branch>`::
@@ builtin/worktree.c: static void check_clean_worktree(struct worktree *wt,
}
+/*
-+ * A rebase, "git am", bisect or cherry-pick/revert sequence keeps its
-+ * state in the worktree's own $GIT_DIR, and removing the worktree
-+ * throws that away even when "git status" says the files are clean.
++ * A rebase, "git am", bisect, cherry-pick or revert keeps its state in
++ * the worktree's own $GIT_DIR, and removing the worktree throws that
++ * away even when "git status" says the files are clean.
+ */
+static void check_no_operation_in_progress(struct worktree *wt,
+ const char *original_path)
@@ builtin/worktree.c: static void check_clean_worktree(struct worktree *wt,
+ die(_("'%s' is in the middle of a bisect, use --force to delete it"),
+ original_path);
+ wt_status_state_free_buffers(&state);
++ if (refs_ref_exists(get_worktree_ref_store(wt), "CHERRY_PICK_HEAD"))
++ die(_("'%s' is in the middle of a cherry-pick, use --force to delete it"),
++ original_path);
++ if (refs_ref_exists(get_worktree_ref_store(wt), "REVERT_HEAD"))
++ die(_("'%s' is in the middle of a revert, use --force to delete it"),
++ original_path);
+ if (is_directory(worktree_git_path(wt, "sequencer")))
+ die(_("'%s' is in the middle of a cherry-pick or revert, use --force to delete it"),
+ original_path);
@@ t/t2403-worktree-move.sh: test_expect_success 'move worktree with relative path
test_cmp expect .git/worktrees/absolute/gitdir
'
++test_expect_success 'setup commits that conflict for am, cherry-pick and revert' '
++ git worktree add --detach conflict-setup init &&
++ (
++ cd conflict-setup &&
++ test_commit base conflict.t base &&
++ git switch --detach init &&
++ test_commit side conflict.t side &&
++ test_commit side-two
++ ) &&
++ git worktree remove conflict-setup
++'
++
+test_expect_success 'remove worktree in the middle of a rebase' '
+ test_when_finished "rm -rf mid-rebase; git worktree prune" &&
-+ git worktree add --detach mid-rebase init &&
-+ test_commit -C mid-rebase rebase-me &&
++ git worktree add --detach mid-rebase side &&
+ test_must_fail git -C mid-rebase rebase -f -x false init &&
+ test_must_fail git worktree remove mid-rebase 2>err &&
+ test_grep "in the middle of a rebase" err &&
@@ t/t2403-worktree-move.sh: test_expect_success 'move worktree with relative path
+
+test_expect_success 'remove worktree in the middle of an am session' '
+ test_when_finished "rm -rf mid-am patch; git worktree prune" &&
-+ git worktree add --detach mid-am init &&
-+ test_commit -C mid-am am-me &&
-+ git -C mid-am format-patch -1 --stdout >patch &&
-+ git -C mid-am reset --hard init &&
-+ echo conflict >mid-am/am-me.t &&
-+ git -C mid-am add am-me.t &&
-+ git -C mid-am commit -m conflict &&
-+ test_must_fail git -C mid-am am ../patch &&
-+ git -C mid-am reset --hard &&
++ git format-patch -1 --stdout side >patch &&
++ git worktree add --detach mid-am base &&
++ (
++ cd mid-am &&
++ test_must_fail git am ../patch &&
++ git reset --hard
++ ) &&
+ test_must_fail git worktree remove mid-am 2>err &&
+ test_grep "in the middle of an am session" err &&
+ git worktree remove --force mid-am
@@ t/t2403-worktree-move.sh: test_expect_success 'move worktree with relative path
+
+test_expect_success 'remove worktree in the middle of a bisect' '
+ test_when_finished "rm -rf mid-bisect; git worktree prune" &&
-+ git worktree add --detach mid-bisect init &&
-+ test_commit -C mid-bisect bisect-one &&
-+ test_commit -C mid-bisect bisect-two &&
-+ git -C mid-bisect bisect start HEAD init &&
++ git worktree add --detach mid-bisect side-two &&
++ git -C mid-bisect bisect start side-two init &&
+ test_must_fail git worktree remove mid-bisect 2>err &&
+ test_grep "in the middle of a bisect" err &&
+ git worktree remove --force mid-bisect
+'
+
-+test_expect_success 'remove worktree in the middle of a cherry-pick sequence' '
++test_expect_success 'remove worktree in the middle of a cherry-pick' '
+ test_when_finished "rm -rf mid-pick; git worktree prune" &&
-+ git worktree add --detach mid-pick init &&
-+ git -C mid-pick switch -c pick-src &&
-+ test_commit -C mid-pick pick-one &&
-+ test_commit -C mid-pick pick-two &&
-+ git -C mid-pick switch --detach init &&
-+ echo conflict >mid-pick/pick-one.t &&
-+ git -C mid-pick add pick-one.t &&
-+ git -C mid-pick commit -m conflict &&
-+ test_must_fail git -C mid-pick cherry-pick pick-src~1 pick-src &&
-+ git -C mid-pick checkout --theirs pick-one.t &&
-+ git -C mid-pick add pick-one.t &&
-+ git -C mid-pick commit --no-edit &&
-+ test_path_is_dir .git/worktrees/mid-pick/sequencer &&
++ git worktree add --detach mid-pick base &&
++ (
++ cd mid-pick &&
++ test_must_fail git cherry-pick side &&
++ git checkout --ours conflict.t &&
++ git add conflict.t &&
++ git rev-parse --verify CHERRY_PICK_HEAD
++ ) &&
++ test_path_is_missing .git/worktrees/mid-pick/sequencer &&
+ test_must_fail git worktree remove mid-pick 2>err &&
-+ test_grep "in the middle of a cherry-pick or revert" err &&
++ test_grep "in the middle of a cherry-pick," err &&
+ git worktree remove --force mid-pick
+'
++
++test_expect_success 'remove worktree in the middle of a revert' '
++ test_when_finished "rm -rf mid-revert; git worktree prune" &&
++ git worktree add --detach mid-revert base &&
++ (
++ cd mid-revert &&
++ test_must_fail git revert side &&
++ git checkout --ours conflict.t &&
++ git add conflict.t &&
++ git rev-parse --verify REVERT_HEAD
++ ) &&
++ test_path_is_missing .git/worktrees/mid-revert/sequencer &&
++ test_must_fail git worktree remove mid-revert 2>err &&
++ test_grep "in the middle of a revert" err &&
++ git worktree remove --force mid-revert
++'
++
++test_expect_success 'remove worktree in the middle of a cherry-pick sequence' '
++ test_when_finished "rm -rf mid-pick-seq; git worktree prune" &&
++ git worktree add --detach mid-pick-seq base &&
++ (
++ cd mid-pick-seq &&
++ test_must_fail git cherry-pick side side-two &&
++ git checkout --theirs conflict.t &&
++ git add conflict.t &&
++ git commit --no-edit
++ ) &&
++ test_path_is_dir .git/worktrees/mid-pick-seq/sequencer &&
++ test_must_fail git worktree remove mid-pick-seq 2>err &&
++ test_grep "in the middle of a cherry-pick or revert" err &&
++ git worktree remove --force mid-pick-seq
++'
+
test_done
-: ---------- > 2: 39eb92d441 doc: for-each-ref: say how to read %(worktreepath) safely
2: 0cd13347e1 ! 3: 990a19fd11 ref-filter: name the worktree of a branch being rebased or bisected
@@ Commit message
The rest of Git already treats that branch as checked out: "git
worktree add" and "git branch -d" refuse it, because finishing the
- rebase or bisect will check it out again. "git worktree list" shows
- such a worktree as "(detached HEAD)", so %(worktreepath) is the only
- place a script could find out which worktree is working on the
- branch.
+ rebase or bisect will check it out again. But no command shows which
+ worktree is working on the branch: "git worktree list" shows such a
+ worktree as "(detached HEAD)", and %(worktreepath) is empty.
- Also map the branch that a worktree is rebasing or bisecting to that
- worktree, as prepare_checked_out_branches() in branch.c does.
- Branches that "rebase --update-refs" will update are not mapped: that
- worktree has not checked them out, it only moves them when the rebase
- is done.
+ branch.c already knows the answer, as prepare_checked_out_branches()
+ records the branch that each worktree has checked out, is rebasing or
+ is bisecting. Add branch_checked_out_worktree() to look a branch up in
+ that list, and use it for %(worktreepath) in place of the map that
+ ref-filter.c builds from the HEAD of each worktree.
- As a result "git branch" marks such a branch with "+", also when it
- runs in the worktree that is rebasing or bisecting it, where it shows
- both "* (no branch, rebasing topic)" and "+ topic". Document that.
+ The new function skips the branches that "rebase --update-refs" will
+ update. branch_checked_out() includes them, so that they cannot be
+ checked out or deleted during the rebase, but the worktree that runs
+ the rebase has not checked them out. %(worktreepath) therefore stays
+ empty for them, unlike branch_checked_out().
+
+ This also changes the result for a bare repository: its HEAD names a
+ branch, and %(worktreepath) used to give the path of the bare
+ repository for that branch. "git branch" in a linked worktree marked
+ the branch with "+", although no worktree has it checked out and "git
+ worktree add" lets you check it out. prepare_checked_out_branches()
+ skips bare repositories, so %(worktreepath) is now empty for that
+ branch and "git branch" no longer marks it.
Reported-by: Kristoffer Haugsbakk <kristofferhaugsbakk@fastmail.com>
Helped-by: Phillip Wood <phillip.wood123@gmail.com>
@@ Documentation/git-branch.adoc: DESCRIPTION
branches are listed; the current branch will be highlighted in green and
marked with an asterisk. Any branches checked out in linked worktrees will
-be highlighted in cyan and marked with a plus sign. Option `-r` causes the
+-remote-tracking branches to be listed,
+be highlighted in cyan and marked with a plus sign. A branch that a
-+worktree is rebasing or bisecting counts as checked out there, so it is
-+marked in the same way, also in the worktree that is rebasing or
-+bisecting it. Option `-r` causes the
- remote-tracking branches to be listed,
++worktree is rebasing or bisecting counts as checked out in that
++worktree, so the other worktrees mark it in the same way. Option `-r`
++causes the remote-tracking branches to be listed,
and option `-a` shows both local and remote branches.
+ If a `<pattern>`
## Documentation/git-for-each-ref.adoc ##
@@ Documentation/git-for-each-ref.adoc: but if used together the last option is selected.
@@ Documentation/git-for-each-ref.adoc: but if used together the last option is sel
- out, if it is checked out in any linked worktree. Empty string
+ out, if it is checked out in any linked worktree. A branch that
+ a worktree is rebasing or bisecting counts as checked out there,
-+ although that worktree's `HEAD` is detached. Empty string
- otherwise.
-
- `ahead-behind:<commit-ish>`::
++ although that worktree's `HEAD` is detached. A branch that
++ `git rebase --update-refs` will update does not. Empty string
+ otherwise. If the ref is checked out in more than one worktree,
+ only one of them is shown. The path can contain a newline, so
+ use one of the quoting options such as `--shell`, or follow
- ## ref-filter.c ##
-@@ ref-filter.c: static struct expand_data {
-
- struct ref_to_worktree_entry {
- struct hashmap_entry ent;
-- struct worktree *wt; /* key is wt->head_ref */
-+ struct worktree *wt;
-+ char refname[FLEX_ARRAY]; /* the key */
- };
-
- static int ref_to_worktree_map_cmpfnc(const void *lookupdata UNUSED,
-@@ ref-filter.c: static int ref_to_worktree_map_cmpfnc(const void *lookupdata UNUSED,
- e = container_of(eptr, const struct ref_to_worktree_entry, ent);
- k = container_of(kptr, const struct ref_to_worktree_entry, ent);
-
-- return strcmp(e->wt->head_ref,
-- keydata_aka_refname ? keydata_aka_refname : k->wt->head_ref);
-+ return strcmp(e->refname,
-+ keydata_aka_refname ? keydata_aka_refname : k->refname);
+ ## branch.c ##
+@@ branch.c: const char *branch_checked_out(const char *refname)
+ return strmap_get(¤t_checked_out_branches, refname);
}
- static struct ref_to_worktree_map {
++const char *branch_checked_out_worktree(const char *refname)
++{
++ const char *path = NULL;
++
++ prepare_checked_out_branches();
++ for (size_t i = 0; i < checked_out_branches_nr; i++) {
++ if (checked_out_branches[i].kind != BRANCH_CHECKOUT_KIND_UPDATE_REF &&
++ !strcmp(refname, checked_out_branches[i].refname))
++ path = checked_out_branches[i].path;
++ }
++ return path;
++}
++
+ const char *branch_bisecting(const char *refname)
+ {
+ prepare_checked_out_branches();
+
+ ## branch.h ##
+@@ branch.h: void create_branches_recursively(struct repository *r, const char *name,
+ */
+ const char *branch_checked_out(const char *refname);
+
++/*
++ * If a worktree has the branch 'refname' checked out, or is rebasing or
++ * bisecting it, return the path of that worktree, or of the last one if
++ * there are more. Otherwise return NULL. Unlike branch_checked_out(),
++ * this ignores the branches that "git rebase --update-refs" will
++ * update, because no worktree has them checked out.
++ */
++const char *branch_checked_out_worktree(const char *refname);
++
+ /*
+ * If the branch at 'refname' is currently used for bisecting in a
+ * worktree, then return the path to that worktree.
+
+ ## ref-filter.c ##
+@@
+ #define DISABLE_SIGN_COMPARE_WARNINGS
+
+ #include "git-compat-util.h"
++#include "branch.h"
+ #include "environment.h"
+ #include "gettext.h"
+ #include "config.h"
+@@ ref-filter.c: static struct expand_data {
+ struct object_info info;
+ } oi, oi_deref;
+
+-struct ref_to_worktree_entry {
+- struct hashmap_entry ent;
+- struct worktree *wt; /* key is wt->head_ref */
+-};
+-
+-static int ref_to_worktree_map_cmpfnc(const void *lookupdata UNUSED,
+- const struct hashmap_entry *eptr,
+- const struct hashmap_entry *kptr,
+- const void *keydata_aka_refname)
+-{
+- const struct ref_to_worktree_entry *e, *k;
+-
+- e = container_of(eptr, const struct ref_to_worktree_entry, ent);
+- k = container_of(kptr, const struct ref_to_worktree_entry, ent);
+-
+- return strcmp(e->wt->head_ref,
+- keydata_aka_refname ? keydata_aka_refname : k->wt->head_ref);
+-}
+-
+-static struct ref_to_worktree_map {
+- struct hashmap map;
+- struct worktree **worktrees;
+-} ref_to_worktree_map;
+-
+ /*
+ * The enum atom_type is used as the index of valid_atom array.
+ * In the atom parsing stage, it will be passed to used_atom.atom_type
@@ ref-filter.c: static int get_object(struct ref_array_item *ref, int deref,
return ret;
}
-+static void add_worktree_entry(struct hashmap *map, struct worktree *wt,
-+ const char *refname)
-+{
-+ struct ref_to_worktree_entry *entry;
-+
-+ FLEX_ALLOC_STR(entry, refname, refname);
-+ entry->wt = wt;
-+ hashmap_entry_init(&entry->ent, strhash(refname));
-+ hashmap_add(map, &entry->ent);
-+}
-+
-+/*
-+ * Map each branch to the worktree that has it checked out. A worktree
-+ * that is rebasing or bisecting a branch has it checked out, too,
-+ * even though its HEAD may be detached, as for
-+ * prepare_checked_out_branches() in branch.c.
-+ */
- static void populate_worktree_map(struct hashmap *map, struct worktree **worktrees)
- {
+-static void populate_worktree_map(struct hashmap *map, struct worktree **worktrees)
+-{
- int i;
-+ struct strbuf ref = STRBUF_INIT;
-
+-
- for (i = 0; worktrees[i]; i++) {
- if (worktrees[i]->head_ref) {
- struct ref_to_worktree_entry *entry;
@@ ref-filter.c: static int get_object(struct ref_array_item *ref, int deref,
- entry->wt = worktrees[i];
- hashmap_entry_init(&entry->ent,
- strhash(worktrees[i]->head_ref));
-+ for (size_t i = 0; worktrees[i]; i++) {
-+ struct worktree *wt = worktrees[i];
-+ struct wt_status_state state = { 0 };
-
+-
- hashmap_add(map, &entry->ent);
-+ if (wt->is_bare)
-+ continue;
-+
-+ if (wt->head_ref)
-+ add_worktree_entry(map, wt, wt->head_ref);
-+
-+ if (wt_status_check_rebase(wt, &state) &&
-+ (state.rebase_in_progress ||
-+ state.rebase_interactive_in_progress) &&
-+ state.branch) {
-+ strbuf_reset(&ref);
-+ strbuf_addf(&ref, "refs/heads/%s", state.branch);
-+ add_worktree_entry(map, wt, ref.buf);
- }
-+ wt_status_state_free_buffers(&state);
-+
-+ if (wt_status_check_bisect(wt, &state) &&
-+ state.bisecting_from) {
-+ strbuf_reset(&ref);
-+ strbuf_addf(&ref, "refs/heads/%s", state.bisecting_from);
-+ add_worktree_entry(map, wt, ref.buf);
-+ }
-+ wt_status_state_free_buffers(&state);
- }
-+ strbuf_release(&ref);
+- }
+- }
+-}
+-
+-static void lazy_init_worktree_map(void)
+-{
+- if (ref_to_worktree_map.worktrees)
+- return;
+-
+- ref_to_worktree_map.worktrees = get_worktrees(the_repository);
+- hashmap_init(&(ref_to_worktree_map.map), ref_to_worktree_map_cmpfnc, NULL, 0);
+- populate_worktree_map(&(ref_to_worktree_map.map), ref_to_worktree_map.worktrees);
+-}
+-
+ static char *get_worktree_path(const struct ref_array_item *ref)
+ {
+- struct hashmap_entry entry, *e;
+- struct ref_to_worktree_entry *lookup_result;
++ const char *path = branch_checked_out_worktree(ref->refname);
+
+- lazy_init_worktree_map();
+-
+- hashmap_entry_init(&entry, strhash(ref->refname));
+- e = hashmap_get(&(ref_to_worktree_map.map), &entry, ref->refname);
+-
+- if (!e)
+- return xstrdup("");
+-
+- lookup_result = container_of(e, struct ref_to_worktree_entry, ent);
+-
+- return xstrdup(lookup_result->wt->path);
++ return xstrdup(path ? path : "");
+ }
+
+ /*
+@@ ref-filter.c: void ref_array_clear(struct ref_array *array)
+ FREE_AND_NULL(used_atom);
+ used_atom_cnt = 0;
+
+- if (ref_to_worktree_map.worktrees) {
+- hashmap_clear_and_free(&(ref_to_worktree_map.map),
+- struct ref_to_worktree_entry, ent);
+- free_worktrees(ref_to_worktree_map.worktrees);
+- ref_to_worktree_map.worktrees = NULL;
+- }
+-
+ FREE_AND_NULL(array->counts);
}
- static void lazy_init_worktree_map(void)
## t/t3203-branch-output.sh ##
@@ t/t3203-branch-output.sh: test_expect_success 'worktree colors correct' '
@@ t/t3203-branch-output.sh: test_expect_success 'worktree colors correct' '
+test_expect_success 'branch being rebased in a worktree is marked' '
+ test_when_finished "git -C rebase_dir rebase --abort; rm -rf rebase_dir; git worktree prune; git branch -D rebasing" &&
+ git worktree add -b rebasing rebase_dir branch-two &&
-+ git -C rebase_dir commit --allow-empty -m rebase-me &&
-+ test_must_fail git -C rebase_dir rebase -f -x false HEAD~1 &&
-+ test_must_fail git -C rebase_dir symbolic-ref -q HEAD &&
++ (
++ cd rebase_dir &&
++ git commit --allow-empty -m rebase-me &&
++ test_must_fail git rebase -f -x false HEAD~1 &&
++ test_must_fail git symbolic-ref -q HEAD
++ ) &&
+ git branch --list rebasing >actual &&
+ echo "+ rebasing" >expect &&
+ test_cmp expect actual
+'
+
-+test_expect_success 'branch being rebased is marked in its own worktree' '
-+ test_when_finished "git -C rebase_dir rebase --abort; rm -rf rebase_dir; git worktree prune; git branch -D rebasing" &&
-+ git worktree add -b rebasing rebase_dir branch-two &&
-+ git -C rebase_dir commit --allow-empty -m rebase-me &&
-+ test_must_fail git -C rebase_dir rebase -f -x false HEAD~1 &&
-+ git -C rebase_dir branch --list rebasing >actual &&
-+ echo "+ rebasing" >expect &&
-+ test_cmp expect actual &&
-+ git -C rebase_dir branch >actual &&
-+ test_grep "^\* (no branch, rebasing rebasing)" actual
-+'
-+
+test_expect_success 'branch being bisected in a worktree is marked' '
+ test_when_finished "git -C bisect_dir bisect reset; rm -rf bisect_dir; git worktree prune; git branch -D bisecting" &&
+ git worktree add -b bisecting bisect_dir branch-two &&
-+ git -C bisect_dir commit --allow-empty -m bisect-one &&
-+ git -C bisect_dir commit --allow-empty -m bisect-two &&
-+ git -C bisect_dir bisect start HEAD HEAD~2 &&
-+ test_must_fail git -C bisect_dir symbolic-ref -q HEAD &&
++ (
++ cd bisect_dir &&
++ git commit --allow-empty -m bisect-one &&
++ git commit --allow-empty -m bisect-two &&
++ git bisect start HEAD HEAD~2 &&
++ test_must_fail git symbolic-ref -q HEAD
++ ) &&
+ git branch --list bisecting >actual &&
+ echo "+ bisecting" >expect &&
+ test_cmp expect actual
@@ t/t6302-for-each-ref-filter.sh: test_expect_success 'validate worktree atom' '
+ git for-each-ref --format="%(worktreepath)" refs/heads/ >actual &&
+ test_grep ! detached-rebase actual
+'
++
++test_expect_success 'worktree atom ignores the HEAD of a bare repository' '
++ test_when_finished "rm -rf bare.git bare-wt" &&
++ git clone --bare . bare.git &&
++ git -C bare.git symbolic-ref HEAD refs/heads/main &&
++ git -C bare.git worktree add --detach ../bare-wt main &&
++ git -C bare.git for-each-ref --format="%(worktreepath)" refs/heads/main >actual &&
++ echo >expect &&
++ test_cmp expect actual &&
++ git -C bare-wt branch --list main >actual &&
++ echo " main" >expect &&
++ test_cmp expect actual
++'
+
test_expect_success 'start after with empty value' '
cat >expect <<-\EOF &&
-: ---------- > 4: 56e29c448f branch: do not mark the branch the current worktree is rebasing-- 2.56.0