fetch: add fetch.pruneLocalBranches config

Delete branches that have already been merged on upstream.

Changes in v18:

* Instead of keeping the whole chain of upstream branches, keep only the ones an unmerged branch still needs. When a kept (merged) branch in turn tracks a branch that is being deleted, clear its now-stale upstream config.
* Rework spare_stacked_bases() to record the kept bases and, in a second pass, clear the upstream of any whose own base is going away. Build the to-delete list with strset_for_each_entry() instead of re-walking the candidate array.

Changes in v17:

* Keep a merged branch when another surviving branch still tracks it as its upstream, so --delete-merged no longer deletes a branch out from under one stacked on top of it.
* Move the --dry-run and branch.<name>.deleteMerged opt-out fully into their own commits.

Changes in v16:

* Convert delete_merged_branches() to take an unsigned int flags argument instead of separate quiet/dry_run booleans, matching delete_branches()
* Reuse the strbuf across the skip-config loop (strbuf_reset per iteration, single strbuf_release after) instead of allocating and freeing it each time
* Rewrite the --delete-merged tests as integration tests: branches that land commits upstream, with deletion and the checked-out, upstream-gone, and push-equals-upstream safety cases exercised together in one run and output asserted via test_cmp
* Collapse the many per-aspect test repos into a single reused repo set up by a setup_repo_for_delete_merged helper, and rename helpers off the old pm_/prune naming
* Nest single-repo setup sequences in ( cd ... ) subshells instead of prefixing every command with -C

Changes in v15:

* Renamed --prune-merged to --delete-merged throughout. Not necessarily final, but something to advance the discussion.
* --delete-merged now silently skips not-yet-merged branches instead of warning.
* Initialized the delete_branches() flag locals where declared. Only force stays deferred.
* delete_branches()/check_branch_commit() doc and code cleanups: redundant branch NULL checks dropped, ref_array candidates = { 0 }, a BUG() for the unreachable non-branch ref, and reworked --delete-merged doc wording.
* Broadened the --forked tests (local commits for realism, remote add -f, --forked coverage), renamed the misleading trunk fixture, and replaced the misnamed detached branch with git checkout --detach.

Changes in v14:

* Fixed a git branch -d -r regression (broke t5404/t5505/t5514): the remotes path set a local force but not the DELETE_BRANCH_FORCE bit that check_branch_commit() reads, so it wrongly ran the merge check.
* Made flags the single source of truth in delete_branches() so the bit and the derived locals can't disagree.
* Works locally, but GitHub CI has problems that are there for other branches too, hopefully not related
(https://github.com/git/git/pull/2285).

Changes in v13:

* Reworked --forked into a real ref-filter applied in apply_ref_filter() instead of a post-pass, so non-matching branches are never allocated.
* Match exact --forked patterns on full refnames (only globs use the abbreviated upstream), and dropped the old helper machinery, forward declaration, and string_list in favor of a strvec.
* Replaced the boolean parameters of delete_branches()/check_branch_commit() with a single unsigned int flags.
* --prune-merged now collects candidates via filter_refs() rather than its own branch walk.
* --prune-merged now takes its patterns as positional arguments (e.g. git branch --prune-merged origin/main 'feature*') instead of repeating the option.

Changes in v12:

* Reworked --forked from a standalone action into a --list-mode filter.
* Switched --forked and --prune-merged to repeatable OPT_STRING_LIST options.
* Dropped the bare-remote-name resolution for --forked, the argument is now a ref or a glob.

Changes in v11:

* The flags now take a branch, not a remote. --forked and --prune-merged accept a literal upstream short name like origin/main or a wildmatch pattern like origin/. The old --all-remotes flag is gone, since origin/ covers that case.
* The prune guard now compares @{push} against @{upstream}. A branch is spared when these are equal. That is the trunk like case, such as local main tracking and pushing to origin/main, where "fully merged to upstream" cannot be told apart from "just pulled". Only branches that push somewhere other than their upstream, typically fork based topics, are candidates. The earlier /HEAD by name guard that the reviewer rejected is gone.
* New --dry-run for --prune-merged.

Changes in v10:

* --forked / --prune-merged now take a branch glob instead of a remote name — origin, origin/*, origin/release-- all work. This replaces the remote-only form and subsumes the old --all-remotes flag, which has been dropped.
* New --dry-run for --prune-merged.

Changes in v9:

* --force no longer has special meaning with --prune-merged; reachability is always enforced. Use git branch -D to delete an unmerged branch. Matches how git branch's other read/safe actions treat --force.
* Synopsis drops [-f]; "not fully merged" hint points at git branch -D.
* Dropped the --prune-merged --force tests.

Changes in v8:

* Delete only when the branch's work is actually reachable from its upstream
* Skip branches whose upstream is gone (even with --force)
* Simplified the internal safety flag to live in one place

Changes in v7:

* --prune-merged now checks if a branch is merged into its own upstream first. If the upstream is gone, it checks against the remote's default branch instead. If neither exists, the branch is refused (use --force to delete anyway).

Changes in v6:

* --prune-merged now measures merged-ness against the remote's default branch instead of the candidate's upstream — so the decision no longer depends on which branch happens to be checked out locally.
* delete_branches() / check_branch_commit() gained a per-candidate override that lets a caller substitute a different "what counts as merged" reference (or skip the check). branch -d callers pass NULL and keep their existing semantics.
* prune_merged_branches() resolves each candidate's push-remote HEAD and threads it through, so --prune-merged --all-remotes measures each candidate against its own remote rather than a single global reference.

Changes in v5:

* Drop commit 'fetch: add --prune-merged'

Changes in v4:

* Resolve each remote's HEAD and collect the targets into a protected_default_refs set in collect_forked_set.
* In prune_merged_branches, skip a candidate when its upstream is a protected default ref and the local branch name matches the default branch's leaf name (so a local main tracking origin/main is spared, but a renamed trunk tracking origin/main is not).
* Also skip when the candidate's push ref points at a protected default ref, so a topic branch configured to push to origin/main is never pruned.
* Tests: spare the local default branch; only protect by matching leaf name (not by upstream alone); spare a branch whose push ref is the remote default.

Changes in v3:

* s/remote-tracking refs/remote-tracking branches/g

Changes in v2:

* The whole feature moved out of git fetch and into git branch. git fetch --prune-merged now just calls git branch --prune-merged after fetching.
* The fetch.pruneLocalBranches and remote..pruneLocalBranches config options are gone, replaced by per-branch opt-out via branch..pruneMerged.
* New git branch --forked lists local branches whose upstream lives on the given remote (read-only building block).
* New git branch --prune-merged deletes those branches, but only if their tip is reachable from the upstream tracking ref; --force skips that safety check.
* New git branch --all-remotes lets --forked/--prune-merged operate across every configured remote at once.
* The currently checked-out branch in any worktree is always preserved.
* branch..pruneMerged=false lets you exempt a branch (e.g. a long-running topic branch) even with --force; doesn't affect explicit git branch -d.
* delete_branches() got a warn_only mode so bulk deletion prints a one-line warning per skipped branch instead of the noisy four-line hint that git branch -d shows.
* New section in git-branch docs; git-fetch docs trimmed to just mention --prune-merged.
* New tests in t3200-branch.sh for the new branch flags; t5510-fetch.sh shrunk since most logic moved.

Harald Nordgren (7):
branch: add --forked filter for --list mode
branch: convert delete_branches() to a flags argument
branch: let delete_branches skip unmerged branches on bulk refusal
branch: prepare delete_branches for a bulk caller
branch: add --delete-merged <branch>
branch: add branch.<name>.deleteMerged opt-out
branch: add --dry-run for --delete-merged

 Documentation/config/branch.adoc |   7 +
 Documentation/git-branch.adoc    |  48 ++++-
 builtin/branch.c                 | 266 +++++++++++++++++++++---
 ref-filter.c                     |  70 +++++++
 ref-filter.h                     |  10 +
 t/t3200-branch.sh                | 342 +++++++++++++++++++++++++++++++
 6 files changed, 715 insertions(+), 28 deletions(-)

base-commit: ab776a62a78576513ee121424adb19597fbb7613
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2285%2FHaraldNordgren%2Ffetch-prune-local-branches-v18
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2285/HaraldNordgren/fetch-prune-local-branches-v18
Pull-Request: https://github.com/git/git/pull/2285

Range-diff vs v17:

 1:  d8cc17bd7f = 1:  3e29ff17bd branch: add --forked filter for --list mode
 2:  d14b0403f0 = 2:  cdd4fea4a7 branch: convert delete_branches() to a flags argument
 3:  ef2719dac3 = 3:  a0fd5b4a6c branch: let delete_branches skip unmerged branches on bulk refusal
 4:  80518f5d11 = 4:  a56d8fe93e branch: prepare delete_branches for a bulk caller
 5:  46da7c8140 ! 5:  a84c555d99 branch: add --delete-merged <branch>
     @@ Commit message
          upstream. The work has already landed on the upstream they track,
          so the local copy is no longer needed.
      
     -    Three kinds of branches are not deleted:
     +    A branch is not deleted when:
      
     -      * any branch checked out in any worktree
     -      * any branch whose upstream remote-tracking branch no longer
     -        exists, since a missing upstream is not by itself a sign of
     -        integration
     -      * any branch whose push destination equals its upstream
     -        (<branch>@{push} is the same as <branch>@{upstream}), such as
     -        a local "main" that tracks and pushes to "origin/main". Right
     -        after a pull it just looks "fully merged", so it is kept. Only
     -        branches that push somewhere other than their upstream,
     -        typically topics in a fork workflow, are candidates.
     +      * it is checked out in any worktree
     +      * its upstream remote-tracking branch no longer exists, since a
     +        missing upstream is not by itself a sign of integration
     +      * its push destination equals its upstream (<branch>@{push} is
     +        the same as <branch>@{upstream}), such as a local "main" that
     +        tracks and pushes to "origin/main". Right after a pull it just
     +        looks "fully merged", so it is kept. Only branches that push
     +        somewhere other than their upstream, typically topics in a fork
     +        workflow, are candidates.
      
          A branch whose work is not yet merged into its upstream is silently
          skipped, so one unmerged topic does not abort the whole sweep.
      
          A branch that another, surviving branch tracks as its upstream is
          also kept, so a branch is never deleted out from under one stacked
     -    on top of it. Sparing such a base can in turn protect its own
     -    upstream, so the check repeats until the set stops changing.
     +    on top of it. Such a kept branch is itself merged, so when its own
     +    upstream is being deleted, clear its now-stale upstream config.
      
          Signed-off-by: Harald Nordgren <[email protected]>
      
     @@ Documentation/git-branch.adoc: This option is only applicable in non-verbose mod
      +silently skipped. Delete it with `git branch -D` if you want to
      +remove it anyway.
      ++
     -+A branch that another, surviving branch still tracks as its upstream
     -+is kept, so a branch is never deleted out from under one stacked on
     -+top of it.
     ++A branch that another, surviving branch tracks as its upstream is
     ++kept, so a branch is never deleted out from under one stacked on top
     ++of it. If that kept branch in turn tracks a branch that is being
     ++deleted, its now-stale upstream configuration is cleared.
      +
       `-v`::
       `-vv`::
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
       	return 0;
       }
       
     -+static int collect_upstream(const struct reference *ref, void *cb_data)
     -+{
     -+	struct string_list *upstreams = cb_data;
     -+	struct branch *branch = branch_get(ref->name);
     -+	const char *upstream = branch_get_upstream(branch, NULL);
     ++struct spare_data {
     ++	struct strset *deletable;
     ++	struct strset *spared;
     ++};
      +
     -+	string_list_append(upstreams, ref->name)->util =
     -+		xstrdup_or_null(upstream);
     ++/*
     ++ * A surviving branch stacked on a deletion candidate would lose its
     ++ * upstream, so drop that candidate from the delete set and remember it
     ++ * in "spared" so its own upstream can be tidied up afterwards.
     ++ */
     ++static int spare_stacked_base(const struct reference *ref, void *cb_data)
     ++{
     ++	struct spare_data *data = cb_data;
     ++	struct branch *branch;
     ++	const char *upstream, *up_short;
     ++
     ++	if (strset_contains(data->deletable, ref->name))
     ++		return 0;
     ++	branch = branch_get(ref->name);
     ++	upstream = branch_get_upstream(branch, NULL);
     ++	if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     ++	    !strset_contains(data->deletable, up_short))
     ++		return 0;
     ++
     ++	strset_remove(data->deletable, up_short);
     ++	strset_add(data->spared, up_short);
      +	return 0;
      +}
      +
      +/*
     -+ * Keep any branch that another, surviving branch tracks as its
     -+ * upstream, so we never delete a branch out from under one stacked on
     -+ * top of it.  Sparing a branch makes it a survivor whose own upstream
     -+ * then needs the same protection, so repeat until nothing changes.
     ++ * Keep any branch that a surviving branch tracks as its upstream, so we
     ++ * never delete a branch out from under one stacked on top of it.  Such a
     ++ * base is itself merged, so when its own upstream is also going away
     ++ * (no surviving branch tracks it), clear the base's now-stale upstream.
      + */
      +static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable)
      +{
     -+	struct string_list upstreams = STRING_LIST_INIT_DUP;
     -+	struct string_list_item *item;
     -+	bool spared;
     -+
     -+	refs_for_each_branch_ref(refs, collect_upstream, &upstreams);
     -+	do {
     -+		spared = false;
     -+		for_each_string_list_item(item, &upstreams) {
     -+			const char *up = item->util, *up_short;
     -+
     -+			if (!up || strset_contains(deletable, item->string))
     -+				continue;
     -+			if (!skip_prefix(up, "refs/heads/", &up_short) ||
     -+			    !strset_contains(deletable, up_short))
     -+				continue;
     -+
     -+			strset_remove(deletable, up_short);
     -+			spared = true;
     -+		}
     -+	} while (spared);
     -+
     -+	string_list_clear(&upstreams, 1);
     ++	struct strset spared = STRSET_INIT;
     ++	struct spare_data data = { .deletable = deletable, .spared = &spared };
     ++	struct strbuf key = STRBUF_INIT;
     ++	struct hashmap_iter iter;
     ++	struct strmap_entry *entry;
     ++
     ++	refs_for_each_branch_ref(refs, spare_stacked_base, &data);
     ++
     ++	strset_for_each_entry(&spared, &iter, entry) {
     ++		struct branch *branch = branch_get(entry->key);
     ++		const char *upstream = branch_get_upstream(branch, NULL);
     ++		const char *up_short;
     ++
     ++		if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     ++		    !strset_contains(deletable, up_short))
     ++			continue;
     ++
     ++		strbuf_reset(&key);
     ++		strbuf_addf(&key, "branch.%s.merge", branch->name);
     ++		repo_config_set_gently(the_repository, key.buf, NULL);
     ++		strbuf_reset(&key);
     ++		strbuf_addf(&key, "branch.%s.remote", branch->name);
     ++		repo_config_set_gently(the_repository, key.buf, NULL);
     ++	}
     ++
     ++	strbuf_release(&key);
     ++	strset_clear(&spared);
      +}
      +
      +static int delete_merged_branches(int argc, const char **argv,
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
      +	struct ref_array candidates = { 0 };
      +	struct strset deletable = STRSET_INIT;
      +	struct strvec to_delete = STRVEC_INIT;
     ++	struct hashmap_iter iter;
     ++	struct strmap_entry *entry;
      +	int i, ret = 0;
      +
      +	if (!argc)
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
      +
      +	spare_stacked_bases(refs, &deletable);
      +
     -+	for (i = 0; i < candidates.nr; i++) {
     -+		const char *short_name;
     -+
     -+		if (skip_prefix(candidates.items[i]->refname, "refs/heads/",
     -+				&short_name) &&
     -+		    strset_contains(&deletable, short_name))
     -+			strvec_push(&to_delete, short_name);
     -+	}
     ++	strset_for_each_entry(&deletable, &iter, entry)
     ++		strvec_push(&to_delete, entry->key);
      +
      +	if (to_delete.nr)
      +		ret = delete_branches(to_delete.nr, to_delete.v,
     @@ t/t3200-branch.sh: test_expect_success '--forked narrows a <pattern> argument' '
      +		git checkout --detach
      +	) &&
      +
     ++	git -C repo branch --dry-run --delete-merged origin/next >out &&
     ++	test_grep ! "feature" out &&
     ++
      +	git -C repo branch --delete-merged origin/next 2>err &&
      +
      +	test_must_be_empty err &&
      +	git -C repo rev-parse --verify refs/heads/feature &&
     -+	git -C repo rev-parse --verify refs/heads/topic
     ++	git -C repo rev-parse --verify refs/heads/topic &&
     ++	echo origin/next >expect &&
     ++	git -C repo rev-parse --abbrev-ref feature@{upstream} >actual &&
     ++	test_cmp expect actual &&
     ++	echo feature >expect &&
     ++	git -C repo rev-parse --abbrev-ref topic@{upstream} >actual &&
     ++	test_cmp expect actual
      +'
      +
      +test_expect_success '--delete-merged keeps a chain of upstreams of a kept branch' '
     @@ t/t3200-branch.sh: test_expect_success '--forked narrows a <pattern> argument' '
      +	EOF
      +	test_cmp expect actual
      +'
     ++
     ++test_expect_success '--delete-merged clears the upstream of a kept base whose own base is deleted' '
     ++	test_when_finished "rm -rf repo" &&
     ++	setup_repo_for_delete_merged &&
     ++	(
     ++		cd repo &&
     ++		git branch lower origin/next &&
     ++		git branch --set-upstream-to=origin/next lower &&
     ++		git branch mid origin/next &&
     ++		git branch --set-upstream-to=lower mid &&
     ++		git checkout -b tip mid &&
     ++		git commit --allow-empty -m "tip work" &&
     ++		git branch --set-upstream-to=mid tip &&
     ++		git checkout --detach
     ++	) &&
     ++
     ++	git -C repo branch --delete-merged origin/next lower &&
     ++
     ++	test_must_fail git -C repo rev-parse --verify refs/heads/lower &&
     ++	git -C repo rev-parse --verify refs/heads/mid &&
     ++	test_must_fail git -C repo rev-parse mid@{upstream} &&
     ++	echo mid >expect &&
     ++	git -C repo rev-parse --abbrev-ref tip@{upstream} >actual &&
     ++	test_cmp expect actual
     ++'
      +
       test_done
 6:  27903fbb1d ! 6:  d52d717b70 branch: add branch.<name>.deleteMerged opt-out
     @@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
       	struct strset deletable = STRSET_INIT;
       	struct strvec to_delete = STRVEC_INIT;
      +	struct strbuf key = STRBUF_INIT;
     + 	struct hashmap_iter iter;
     + 	struct strmap_entry *entry;
      +	bool quiet = flags & DELETE_BRANCH_QUIET;
       	int i, ret = 0;
       
     @@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
       	ref_array_clear(&candidates);
      
       ## t/t3200-branch.sh ##
     -@@ t/t3200-branch.sh: test_expect_success '--delete-merged keeps a chain of upstreams of a kept branch
     +@@ t/t3200-branch.sh: test_expect_success '--delete-merged clears the upstream of a kept base whose ow
       	test_cmp expect actual
       '

7: 49c1bcf1fb ! 7: 8d0323f4b3 branch: add --dry-run for --delete-merged
@@ Documentation/git-branch.adoc: git branch (-m|-M) [<old-branch>] <new-branch>

DESCRIPTION
-----------
-@@ Documentation/git-branch.adoc: A branch that another, surviving branch still tracks as its upstream
- is kept, so a branch is never deleted out from under one stacked on
- top of it.
+@@ Documentation/git-branch.adoc: kept, so a branch is never deleted out from under one stacked on top
+ of it. If that kept branch in turn tracks a branch that is being
+ deleted, its now-stale upstream configuration is cleared.

+--dry-run::
+ With --delete-merged, print which branches would be

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a --forked option to "git branch" list mode that lists only branches whose configured upstream matches <branch>. The argument can be a ref (e.g. "origin/main", "master"), a remote name like "origin" for the branch its origin/HEAD points at, or a shell glob (e.g. "origin/*"), and may be repeated to widen the filter.

It is an ordinary list filter, so it combines with the others:

    git branch --merged origin/main --forked 'origin/*'

lists branches forked from origin that are already merged into origin/main, and --no-merged inverts the question.

This is the building block for --delete-merged, which deletes the listed branches once they have landed on their upstream.

---
 Documentation/git-branch.adoc |  12 +++-
 builtin/branch.c              |  18 ++++-
 ref-filter.c                  |  70 +++++++++++++++++++
 ref-filter.h                  |  10 +++
 t/t3200-branch.sh             | 122 ++++++++++++++++++++++++++++++++++
 5 files changed, 229 insertions(+), 3 deletions(-)

index c0afddc424..b0d66a6deb 100644
@@ -13,6 +13,7 @@ git branch [--color[=<when>] | --no-color] [--show-current]
 	   [--column[=<options>] | --no-column] [--sort=<key>]
 	   [--merged [<commit>]] [--no-merged [<commit>]]
 	   [--contains [<commit>]] [--no-contains [<commit>]]
+	   [(--forked <branch>)...]
 	   [--points-at <object>] [--format=<format>]
 	   [(-r|--remotes) | (-a|--all)]
 	   [--list] [<pattern>...]

@@ -51,7 +52,8 @@ merged into the named commit (i.e. the branches whose tip commits are
 reachable from the named commit) will be listed.  With `--no-merged` only
 branches not merged into the named commit will be listed.  If the _<commit>_
 argument is missing it defaults to `HEAD` (i.e. the tip of the current
-branch).
+branch).  With `--forked`, only branches whose configured upstream matches
+the given branch or pattern will be listed.
 
 The command's second form creates a new branch head named _<branch-name>_
 which points to the current `HEAD`, or _<start-point>_ if given. As a

@@ -311,6 +313,14 @@ superproject's "origin/main", but tracks the submodule's "origin/main".
 	Only list branches whose tips are not reachable from
 	_<commit>_ (`HEAD` if not specified). Implies `--list`.
 
+`--forked <branch>`::
+	Only list branches whose configured upstream matches
+	_<branch>_. The argument can be a ref (e.g. `origin/main`,
+	`master`), a remote name like `origin` for the branch its
+	`origin/HEAD` points at, or a shell-style glob (e.g.
+	`'origin/*'`). The option can be repeated to widen the
+	filter. Implies `--list`.
+
 `--points-at <object>`::
 	Only list branches of _<object>_.
 

index 1572a4f9ef..c159f45b4c 100644
@@ -30,7 +30,7 @@
 #include "commit-reach.h"
 
 static const char * const builtin_branch_usage[] = {
-	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),
+	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged] [(--forked <branch>)...]"),
 	N_("git branch [<options>] [-f] [--recurse-submodules] <branch-name> [<start-point>]"),
 	N_("git branch [<options>] [-l] [<pattern>...]"),
 	N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."),

@@ -673,6 +673,16 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
 	free_worktrees(worktrees);
 }
 
+static int parse_opt_forked(const struct option *opt, const char *arg, int unset)
+{
+	struct ref_filter *filter = opt->value;
+
+	BUG_ON_OPT_NEG(unset);
+	if (ref_filter_forked_add(filter, arg) < 0)
+		die(_("'%s' is not a valid branch or pattern"), arg);
+	return 0;
+}
+
 static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
 
 static int edit_branch_description(const char *branch_name)

@@ -770,6 +780,9 @@ int cmd_branch(int argc,
 		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
 		OPT_MERGED(&filter, N_("print only branches that are merged")),
 		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
+		OPT_CALLBACK_F(0, "forked", &filter, N_("branch"),
+			N_("print only branches whose upstream matches <branch> (repeatable)"),
+			PARSE_OPT_NONEG, parse_opt_forked),
 		OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
 		OPT_REF_SORT(&sorting_options),
 		OPT_CALLBACK(0, "points-at", &filter.points_at, N_("object"),

@@ -815,7 +828,8 @@ int cmd_branch(int argc,
 		list = 1;
 
 	if (filter.with_commit || filter.no_commit ||
-	    filter.reachable_from || filter.unreachable_from || filter.points_at.nr)
+	    filter.reachable_from || filter.unreachable_from ||
+	    filter.points_at.nr || filter.forked.nr)
 		list = 1;
 
 	noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +

index 120221b47f..9361296e2a 100644
@@ -67,6 +67,7 @@ struct ref_filter {
 	const char **name_patterns;
 	const char *start_after;
 	struct strvec exclude;
+	struct strvec forked;
 	struct oid_array points_at;
 	struct commit_list *with_commit;
 	struct commit_list *no_commit;

@@ -110,6 +111,7 @@ struct ref_format {
 #define REF_FILTER_INIT { \
 	.points_at = OID_ARRAY_INIT, \
 	.exclude = STRVEC_INIT, \
+	.forked = STRVEC_INIT, \
 }
 #define REF_FORMAT_INIT {             \
 	.use_color = GIT_COLOR_UNKNOWN, \

@@ -172,6 +174,14 @@ void ref_sorting_release(struct ref_sorting *);
 struct ref_sorting *ref_sorting_options(struct string_list *);
 /*  Function to parse --merged and --no-merged options */
 int parse_opt_merge_filter(const struct option *opt, const char *arg, int unset);
+/*
+ * Register a --forked <branch> pattern on the filter. The argument is
+ * either a ref, which is resolved to its full refname, or a shell-style
+ * glob. Branches are kept only when their configured upstream matches
+ * one of the registered patterns. Returns -1 if the argument is not a
+ * valid ref or pattern.
+ */
+int ref_filter_forked_add(struct ref_filter *filter, const char *arg);
 /*  Get the current HEAD's description */
 char *get_head_description(void);
 /*  Set up translated strings in the output. */

gitgitgadget

Hi Harald

The implementation looks good, I've left a couple of small comments on the tests. One thought I had was whether we want a mode which recurses so that if the upstream of topic2 is topic1 which has an upstream of origin/main --forked=recurse origin/main would list topic1 and topic2. So long as we don't think that is a sensible default we can add it in the future if we want.

Thanks for all the help so far! Much appreciated!

I don't understand this one, but if we safely do it later then that sounds good considering we will soon be on v19.

The '--delete-merged honours branch.<name>.deleteMerged=false' ' and "branch -d still deletes a deleteMerged=false branch" ' tests need it, but it's not necessary here, deleting.

Good point, reordering.

Harald

From: Harald Nordgren <[email protected]>

delete_branches() and check_branch_commit() take a pair of int booleans (force and quiet) that the next commits would grow further. Replace them with a single "unsigned int flags" argument and an enum, splitting the bits back into named bool locals so the body keeps reading the same named values.

No change in behavior.

---
 builtin/branch.c | 36 ++++++++++++++++++++++++------------
 1 file changed, 24 insertions(+), 12 deletions(-)

index c159f45b4c..a9be980aef 100644
@@ -189,10 +189,16 @@ static int branch_merged(int kind, const char *name,
 	return merged;
 }
 
+enum delete_branch_flags {
+	DELETE_BRANCH_FORCE = (1 << 0),
+	DELETE_BRANCH_QUIET = (1 << 1),
+};
+
 static int check_branch_commit(const char *branchname, const char *refname,
 			       const struct object_id *oid, struct commit *head_rev,
-			       int kinds, int force)
+			       int kinds, unsigned int flags)
 {
+	bool force = flags & DELETE_BRANCH_FORCE;
 	struct commit *rev = lookup_commit_reference(the_repository, oid);
 	if (!force && !rev) {
 		error(_("couldn't look up commit object for '%s'"), refname);

@@ -217,8 +223,8 @@ static void delete_branch_config(const char *branchname)
 	strbuf_release(&buf);
 }
 
-static int delete_branches(int argc, const char **argv, int force, int kinds,
-			   int quiet)
+static int delete_branches(int argc, const char **argv, int kinds,
+			   unsigned int flags)
 {
 	struct commit *head_rev = NULL;
 	struct object_id oid;

@@ -227,6 +233,8 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 	int i;
 	int ret = 0;
 	int remote_branch = 0;
+	bool force;
+	bool quiet = flags & DELETE_BRANCH_QUIET;
 	struct strbuf bname = STRBUF_INIT;
 	enum interpret_branch_kind allowed_interpret;
 	struct string_list refs_to_delete = STRING_LIST_INIT_DUP;

@@ -241,7 +249,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 		remote_branch = 1;
 		allowed_interpret = INTERPRET_BRANCH_REMOTE;
 
-		force = 1;
+		flags |= DELETE_BRANCH_FORCE;
 		break;
 	case FILTER_REFS_BRANCHES:
 		fmt = "refs/heads/%s";

@@ -252,12 +260,14 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 	}
 	branch_name_pos = strcspn(fmt, "%");
 
+	force = flags & DELETE_BRANCH_FORCE;
+
 	if (!force)
 		head_rev = lookup_commit_reference(the_repository, &head_oid);
 
 	for (i = 0; i < argc; i++, strbuf_reset(&bname)) {
 		char *target = NULL;
-		int flags = 0;
+		int ref_flags = 0;
 
 		copy_branchname(&bname, argv[i], allowed_interpret);
 		free(name);

@@ -279,7 +289,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 					     RESOLVE_REF_READING
 					     | RESOLVE_REF_NO_RECURSE
 					     | RESOLVE_REF_ALLOW_BAD_NAME,
-					     &oid, &flags);
+					     &oid, &ref_flags);
 		if (!target) {
 			if (remote_branch) {
 				error(_("remote-tracking branch '%s' not found"), bname.buf);

@@ -291,7 +301,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 									   | RESOLVE_REF_NO_RECURSE
 									   | RESOLVE_REF_ALLOW_BAD_NAME,
 									   &oid,
-									   &flags);
+									   &ref_flags);
 				FREE_AND_NULL(virtual_name);
 
 				if (virtual_target)

@@ -306,16 +316,16 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 			continue;
 		}
 
-		if (!(flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
+		if (!(ref_flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
 		    check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
-					force)) {
+					flags)) {
 			ret = 1;
 			goto next;
 		}
 
 		item = string_list_append(&refs_to_delete, name);
-		item->util = xstrdup((flags & REF_ISBROKEN) ? "broken"
-				    : (flags & REF_ISSYMREF) ? target
+		item->util = xstrdup((ref_flags & REF_ISBROKEN) ? "broken"
+				    : (ref_flags & REF_ISSYMREF) ? target
 				    : repo_find_unique_abbrev(the_repository, &oid, DEFAULT_ABBREV));
 
 	next:

@@ -872,7 +882,9 @@ int cmd_branch(int argc,
 	if (delete) {
 		if (!argc)
 			die(_("branch name required"));
-		ret = delete_branches(argc, argv, delete > 1, filter.kind, quiet);
+		ret = delete_branches(argc, argv, filter.kind,
+				      (delete > 1 ? DELETE_BRANCH_FORCE : 0) |
+				      (quiet ? DELETE_BRANCH_QUIET : 0));
 		goto out;
 	} else if (show_current) {
 		print_current_branch_name();

gitgitgadget

Hi Harald

Yes, it makes sense.

I just hope we remember this discussion, so another reviewer doesn't push in the other direction later because it seems like low-hanging fruit.

Harald

Hi Harald

If you explain why we're using flags as the source of truth, rather than replacing the function parameters with local variables in this function that should not be a problem.

Thanks

Phillip

From: Harald Nordgren <[email protected]>

Add a skip-unmerged mode to delete_branches() and check_branch_commit() so a bulk caller can silently skip branches that are not fully merged and carry on, rather than erroring with the "use 'git branch -D'" advice that the plain "git branch -d" path emits. Existing callers are unaffected.

---
 builtin/branch.c | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

index a9be980aef..4c569d056a 100644
@@ -192,6 +192,7 @@ static int branch_merged(int kind, const char *name,
 enum delete_branch_flags {
 	DELETE_BRANCH_FORCE = (1 << 0),
 	DELETE_BRANCH_QUIET = (1 << 1),
+	DELETE_BRANCH_SKIP_UNMERGED = (1 << 2),
 };
 
 static int check_branch_commit(const char *branchname, const char *refname,

@@ -199,16 +200,20 @@ static int check_branch_commit(const char *branchname, const char *refname,
 			       int kinds, unsigned int flags)
 {
 	bool force = flags & DELETE_BRANCH_FORCE;
+	bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
 	struct commit *rev = lookup_commit_reference(the_repository, oid);
 	if (!force && !rev) {
 		error(_("couldn't look up commit object for '%s'"), refname);
 		return -1;
 	}
 	if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
-		error(_("the branch '%s' is not fully merged"), branchname);
-		advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
-				  _("If you are sure you want to delete it, "
-				  "run 'git branch -D %s'"), branchname);
+		if (!skip_unmerged) {
+			error(_("the branch '%s' is not fully merged"),
+			      branchname);
+			advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
+					  _("If you are sure you want to delete it, "
+					  "run 'git branch -D %s'"), branchname);
+		}
 		return -1;
 	}
 	return 0;

@@ -235,6 +240,7 @@ static int delete_branches(int argc, const char **argv, int kinds,
 	int remote_branch = 0;
 	bool force;
 	bool quiet = flags & DELETE_BRANCH_QUIET;
+	bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
 	struct strbuf bname = STRBUF_INIT;
 	enum interpret_branch_kind allowed_interpret;
 	struct string_list refs_to_delete = STRING_LIST_INIT_DUP;

@@ -319,7 +325,8 @@ static int delete_branches(int argc, const char **argv, int kinds,
 		if (!(ref_flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
 		    check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
 					flags)) {
-			ret = 1;
+			if (!skip_unmerged)
+				ret = 1;
 			goto next;
 		}
 

gitgitgadget

Hi Harald

From: Harald Nordgren <[email protected]>

Teach delete_branches() two new modes for the upcoming --delete-merged: one that asks only whether a branch is merged into its upstream, without falling back to HEAD when there is no upstream, and one that rehearses the deletions without removing any ref. Existing callers keep their current behavior.

---
 builtin/branch.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

index 4c569d056a..01c1f64c73 100644
@@ -168,10 +168,13 @@ static int branch_merged(int kind, const char *name,
 	 * upstream, if any, otherwise with HEAD", we should just
 	 * return the result of the repo_in_merge_bases() above without
 	 * any of the following code, but during the transition period,
-	 * a gentle reminder is in order.
+	 * a gentle reminder is in order.  Callers that opt out of the
+	 * HEAD fallback by passing head_rev=NULL are not interested in
+	 * the reminder either: they have already established that the
+	 * branch has an upstream, so HEAD is irrelevant to the decision.
 	 */
-	if (head_rev != reference_rev) {
-		int expect = head_rev ? repo_in_merge_bases(the_repository, rev, head_rev) : 0;
+	if (head_rev && head_rev != reference_rev) {
+		int expect = repo_in_merge_bases(the_repository, rev, head_rev);
 		if (expect < 0)
 			exit(128);
 		if (expect == merged)

@@ -193,6 +196,7 @@ enum delete_branch_flags {
 	DELETE_BRANCH_FORCE = (1 << 0),
 	DELETE_BRANCH_QUIET = (1 << 1),
 	DELETE_BRANCH_SKIP_UNMERGED = (1 << 2),
+	DELETE_BRANCH_NO_HEAD_FALLBACK = (1 << 3),
 };
 
 static int check_branch_commit(const char *branchname, const char *refname,

@@ -241,6 +245,7 @@ static int delete_branches(int argc, const char **argv, int kinds,
 	bool force;
 	bool quiet = flags & DELETE_BRANCH_QUIET;
 	bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
+	bool no_head_fallback = flags & DELETE_BRANCH_NO_HEAD_FALLBACK;
 	struct strbuf bname = STRBUF_INIT;
 	enum interpret_branch_kind allowed_interpret;
 	struct string_list refs_to_delete = STRING_LIST_INIT_DUP;

@@ -268,7 +273,7 @@ static int delete_branches(int argc, const char **argv, int kinds,
 
 	force = flags & DELETE_BRANCH_FORCE;
 
-	if (!force)
+	if (!force && !no_head_fallback)
 		head_rev = lookup_commit_reference(the_repository, &head_oid);
 
 	for (i = 0; i < argc; i++, strbuf_reset(&bname)) {

gitgitgadget

From: Harald Nordgren <[email protected]>

git branch --delete-merged <branch>...

deletes the local branches that "--forked <branch>" would list, keeping only those whose tip is reachable from their configured upstream. The work has already landed on the upstream they track, so the local copy is no longer needed.

A branch is not deleted when:

* it is checked out in any worktree
* its upstream remote-tracking branch no longer exists, since a missing upstream is not by itself a sign of integration
* its push destination equals its upstream (<branch>@{push} is the same as <branch>@{upstream}), such as a local "main" that tracks and pushes to "origin/main". Right after a pull it just looks "fully merged", so it is kept. Only branches that push somewhere other than their upstream, typically topics in a fork workflow, are candidates.

A branch whose work is not yet merged into its upstream is silently skipped, so one unmerged topic does not abort the whole sweep.

A branch that another, surviving branch tracks as its upstream is also kept, so a branch is never deleted out from under one stacked on top of it. Such a kept branch is itself merged, so when its own upstream is being deleted, clear its now-stale upstream config.

---
 Documentation/git-branch.adoc |  29 ++++++
 builtin/branch.c              | 147 ++++++++++++++++++++++++++-
 t/t3200-branch.sh             | 185 ++++++++++++++++++++++++++++++++++
 3 files changed, 359 insertions(+), 2 deletions(-)

index b0d66a6deb..66b1c87c55 100644
@@ -25,6 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
 git branch (-c|-C) [<old-branch>] <new-branch>
 git branch (-d|-D) [-r] <branch-name>...
 git branch --edit-description [<branch-name>]
+git branch --delete-merged <branch>...
 
 DESCRIPTION
 -----------

@@ -201,6 +202,34 @@ This option is only applicable in non-verbose mode.
 	Print the name of the current branch. In detached `HEAD` state,
 	nothing is printed.
 
+`--delete-merged <branch>...`::
+	Delete the local branches that `--forked` would list for the
+	given _<branch>_ arguments, but only those whose tip is
+	reachable from their configured upstream. In other words, the
+	work on the branch has already landed on the upstream it
+	tracks, so the local copy is no longer needed. Several
+	_<branch>_ patterns may be given, e.g. `git branch
+	--delete-merged origin/main 'feature*'`.
++
+A branch is not deleted when:
++
+--
+* its upstream remote-tracking branch no longer exists,
+* it is checked out in any worktree, or
+* its push destination (`<branch>@{push}`) equals its upstream
+  (`<branch>@{upstream}`), so it cannot be distinguished from a
+  branch that just looks "fully merged" right after a pull.
+--
++
+A branch whose work has not yet been merged into its upstream is
+silently skipped. Delete it with `git branch -D` if you want to
+remove it anyway.
++
+A branch that another, surviving branch tracks as its upstream is
+kept, so a branch is never deleted out from under one stacked on top
+of it. If that kept branch in turn tracks a branch that is being
+deleted, its now-stale upstream configuration is cleared.
+
 `-v`::
 `-vv`::
 `--verbose`::

gitgitgadget

Hi Harald

This design means that unlike --forked there is no way to limit the branches considered for deletion. I wonder if we'd be better to have --delete-merged take an argument like --forked so that the user can limit the branches that might be deleted without resorting to the config setting added in the next patch.

The commit message explains the new feature really well. The implementation looks good, I've left a few questions and comments on the tests

    git config --local --get-regexp 

Makes sense, I updated it now and it seems to work fine.

I want to avoid comments because of the maintenance burden they introduce, I think 'create_merged_branch' will be a very clear name. Thanks for that suggestion!

That's a very good point. I wanted to keep it "vanilla" since I worked a lot on upstreams and tracking branches in my other topics and didn't want it to bleed over, but yes it's much nicer.

I'll hardcode for now.

Nope, let's rip it out.

Yes, but it's also a pattern that I copy-pasted a few too many times, see my other comment where some of these can be removed.

Agreed, but other reviewers were against subshells before. I updated it now and looks much cleaner.

It's to have an indirection of a branch that is the same as main but will be protected. I tried to delete it now and replace it with just main, but then main was deleted and subsequent tests failed.

Deleted.

That's a good point and a good regression test later on.

I'll rename to 'local-to-delete' to clarify and to avoid the comment.

Yup, should be fixed now. And I usually run "git rebase --keep-base --exec" a lot!

Yes, it's better.

Nice.

Deleting this one, which also removes the question of b1, b2 and b3 naming.

Very good idea! Created the helper!

Will update! Thanks again!

Harald

Digging more into this, probably the most elegant solution is to replace mainline with main, but then also do this:

git config branch.main.pushRemote origin

This exposes something that I don't love about this feature, which is that when using a pushDefault (like we do in the tests with 'git config remote.pushDefault fork') if not adding a special case for the main/master branch (like 'git config branch.main.pushRemote origin'), then it will get cleaned up as a forked branch.

But there was a lot of discussion about this already, so I won't get into this again.

Harald

by "this feature" do you mean "git branch --delete-merged"?

Oh, so because the default push remote is not "origin" we need to override that for the branches that we do push to "origin". That's a pain, but even if we did add a special case for the default branch, it would not protect other branches like "next" and "seen".

We should maybe add a note to the documentation about that to warn users.

Fair enough

Thanks

Phillip

Hi Harald

Thinking about this a bit more, rather than protecting branches where $branch@{push} == $branch@{upstream}, perhaps we should be protecting branches that are merged into their upstream but

git push branch.$branch.remote $branch

would update $branch@{upstream}. So we'd apply the push refspec to the branch name, then apply the fetch refspec to that and check the result did not match the name of the upstream branch.

Does that make sense?

Thanks

Phillip

This makes a lot of sense and fixes my major gripe. Seems very possible to implement as well, I'll give it a shot.

Are you done with the rest of your review so I can push out the next version?

Harald

That's great

Yes, though I've just remembered that when we were discussing protecting branches that are the upstreams of another branch Junio was keen for us to extend that protection to "git branch -d" as well.

Thanks

Phillip

Sure, not a bad idea, I'll put it on my list of things to do after this topic has landed.

Harald

From: Harald Nordgren <[email protected]>

Setting branch.<name>.deleteMerged=false exempts that branch from "git branch --delete-merged", which is useful for a topic you want to keep developing after an early round of it has been merged upstream. Unless --quiet is given, each skip is reported so the user knows why their topic was kept.

Explicit deletion with "git branch -d" still uses the normal merge check and ignores this setting.

---
 Documentation/config/branch.adoc |  7 +++++++
 Documentation/git-branch.adoc    |  5 +++--
 builtin/branch.c                 | 15 +++++++++++++++
 t/t3200-branch.sh                | 26 ++++++++++++++++++++++++++
 4 files changed, 51 insertions(+), 2 deletions(-)

index a4db9fa5c8..d8483acb4f 100644
@@ -102,3 +102,10 @@ for details).
 	`git branch --edit-description`. Branch description is
 	automatically added to the `format-patch` cover letter or
 	`request-pull` summary.
+
+`branch.<name>.deleteMerged`::
+	If set to `false`, branch _<name>_ is exempt from
+	`git branch --delete-merged`.  Useful for a topic branch you
+	intend to develop further after an initial round has been
+	merged upstream.  Defaults to true.  Explicit deletion via
+	`git branch -d` is unaffected.

index 66b1c87c55..d482cded3d 100644
@@ -215,10 +215,11 @@ A branch is not deleted when:
 +
 --
 * its upstream remote-tracking branch no longer exists,
-* it is checked out in any worktree, or
+* it is checked out in any worktree,
 * its push destination (`<branch>@{push}`) equals its upstream
   (`<branch>@{upstream}`), so it cannot be distinguished from a
-  branch that just looks "fully merged" right after a pull.
+  branch that just looks "fully merged" right after a pull, or
+* `branch.<name>.deleteMerged` is set to `false`.
 --
 +
 A branch whose work has not yet been merged into its upstream is

index d12a2f57ea..bce85cb52e 100644
@@ -781,8 +781,10 @@ static int delete_merged_branches(int argc, const char **argv,
 	struct ref_array candidates = { 0 };
 	struct strset deletable = STRSET_INIT;
 	struct strvec to_delete = STRVEC_INIT;
+	struct strbuf key = STRBUF_INIT;
 	struct hashmap_iter iter;
 	struct strmap_entry *entry;
+	bool quiet = flags & DELETE_BRANCH_QUIET;
 	int i, ret = 0;
 
 	if (!argc)

@@ -800,6 +802,7 @@ static int delete_merged_branches(int argc, const char **argv,
 		const char *short_name;
 		struct branch *branch;
 		const char *upstream, *push;
+		int opt_out;
 
 		if (!skip_prefix(full_name, "refs/heads/", &short_name))
 			BUG("filter returned non-branch ref '%s'", full_name);

@@ -818,6 +821,17 @@ static int delete_merged_branches(int argc, const char **argv,
 					FILTER_REFS_BRANCHES, DELETE_BRANCH_SKIP_UNMERGED))
 			continue;
 
+		strbuf_reset(&key);
+		strbuf_addf(&key, "branch.%s.deletemerged", short_name);
+		if (!repo_config_get_bool(the_repository, key.buf, &opt_out) &&
+		    !opt_out) {
+			if (!quiet)
+				fprintf(stderr,
+					_("Skipping '%s' (branch.%s.deleteMerged is false)\n"),
+					short_name, short_name);
+			continue;
+		}
+
 		strset_add(&deletable, short_name);
 	}
 

@@ -833,6 +847,7 @@ static int delete_merged_branches(int argc, const char **argv,
 				      DELETE_BRANCH_NO_HEAD_FALLBACK |
 				      flags);
 
+	strbuf_release(&key);
 	strvec_clear(&to_delete);
 	strset_clear(&deletable);
 	ref_array_clear(&candidates);

index 047ba54778..b7595610d9 100755
@@ -2024,4 +2024,30 @@ test_expect_success '--delete-merged clears the upstream of a kept base whose ow
 	test_cmp expect actual
 '
 
+test_expect_success '--delete-merged honours branch.<name>.deleteMerged=false' '
+	test_when_finished "rm -rf repo" &&
+	setup_repo_for_delete_merged &&
+	merged_branch deleted origin/next &&
+	merged_branch kept origin/next &&
+	git -C repo config branch.kept.deleteMerged false &&
+	git -C repo checkout --detach &&
+
+	git -C repo branch --delete-merged origin/next 2>err &&
+
+	test_grep "Skipping .kept." err &&
+	test_must_fail git -C repo rev-parse --verify refs/heads/deleted &&
+	git -C repo rev-parse --verify refs/heads/kept
+'
+
+test_expect_success "branch -d still deletes a deleteMerged=false branch" '
+	test_when_finished "rm -rf repo" &&
+	setup_repo_for_delete_merged &&
+	merged_branch kept origin/next &&
+	git -C repo config branch.kept.deleteMerged false &&
+	git -C repo checkout --detach &&
+
+	git -C repo branch -d kept &&
+	test_must_fail git -C repo rev-parse --verify refs/heads/kept
+'
+
 test_done

gitgitgadget

Hi Harald

Thanks! Yes, I have already created a helper for it, and it makes it a lot clearer. Thanks again for a good suggestion.

Harald

From: Harald Nordgren <[email protected]>

With --dry-run, --delete-merged prints the local branches it would delete, one "Would delete branch <name>" line each, and exits without touching any ref. The same filtering applies, so the output is exactly the set that the real run would delete.

--dry-run is only meaningful together with --delete-merged and is rejected otherwise.

---
 Documentation/git-branch.adoc |  8 +++++++-
 builtin/branch.c              | 22 +++++++++++++++++++---
 t/t3200-branch.sh             | 11 ++++++++++-
 3 files changed, 36 insertions(+), 5 deletions(-)

index d482cded3d..00d6192e6a 100644
@@ -25,7 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
 git branch (-c|-C) [<old-branch>] <new-branch>
 git branch (-d|-D) [-r] <branch-name>...
 git branch --edit-description [<branch-name>]
-git branch --delete-merged <branch>...
+git branch [--dry-run] --delete-merged <branch>...
 
 DESCRIPTION
 -----------

@@ -231,6 +231,12 @@ kept, so a branch is never deleted out from under one stacked on top
 of it. If that kept branch in turn tracks a branch that is being
 deleted, its now-stale upstream configuration is cleared.
 
+`--dry-run`::
+	With `--delete-merged`, print which branches would be
+	deleted and exit without touching any ref.  Useful for
+	sanity-checking a wide pattern like `'origin/*'` before
+	committing to the deletion.
+
 `-v`::
 `-vv`::
 `--verbose`::

index bce85cb52e..e7763437fb 100644
@@ -199,6 +199,7 @@ enum delete_branch_flags {
 	DELETE_BRANCH_QUIET = (1 << 1),
 	DELETE_BRANCH_SKIP_UNMERGED = (1 << 2),
 	DELETE_BRANCH_NO_HEAD_FALLBACK = (1 << 3),
+	DELETE_BRANCH_DRY_RUN = (1 << 4),
 };
 
 static int check_branch_commit(const char *branchname, const char *refname,

@@ -248,6 +249,7 @@ static int delete_branches(int argc, const char **argv, int kinds,
 	bool quiet = flags & DELETE_BRANCH_QUIET;
 	bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
 	bool no_head_fallback = flags & DELETE_BRANCH_NO_HEAD_FALLBACK;
+	bool dry_run = flags & DELETE_BRANCH_DRY_RUN;
 	struct strbuf bname = STRBUF_INIT;
 	enum interpret_branch_kind allowed_interpret;
 	struct string_list refs_to_delete = STRING_LIST_INIT_DUP;

@@ -346,13 +348,20 @@ static int delete_branches(int argc, const char **argv, int kinds,
 		free(target);
 	}
 
-	if (refs_delete_refs(get_main_ref_store(the_repository), NULL, &refs_to_delete, REF_NO_DEREF))
+	if (!dry_run &&
+	    refs_delete_refs(get_main_ref_store(the_repository), NULL, &refs_to_delete, REF_NO_DEREF))
 		ret = 1;
 
 	for_each_string_list_item(item, &refs_to_delete) {
 		char *describe_ref = item->util;
 		char *name = item->string;
-		if (!refs_ref_exists(get_main_ref_store(the_repository), name)) {
+		if (dry_run) {
+			if (!quiet)
+				printf(remote_branch
+					? _("Would delete remote-tracking branch %s (was %s).\n")
+					: _("Would delete branch %s (was %s).\n"),
+					name + branch_name_pos, describe_ref);
+		} else if (!refs_ref_exists(get_main_ref_store(the_repository), name)) {
 			char *refname = name + branch_name_pos;
 			if (!quiet)
 				printf(remote_branch

@@ -897,6 +906,7 @@ int cmd_branch(int argc,
 	int delete = 0, rename = 0, copy = 0, list = 0,
 	    unset_upstream = 0, show_current = 0, edit_description = 0;
 	int delete_merged = 0;
+	int dry_run = 0;
 	const char *new_upstream = NULL;
 	int noncreate_actions = 0;
 	/* possible options */

@@ -952,6 +962,8 @@ int cmd_branch(int argc,
 			 N_("edit the description for the branch")),
 		OPT_BOOL(0, "delete-merged", &delete_merged,
 			N_("delete local branches whose upstream matches <branch> and are merged")),
+		OPT_BOOL(0, "dry-run", &dry_run,
+			N_("with --delete-merged, only print which branches would be deleted")),
 		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
 		OPT_MERGED(&filter, N_("print only branches that are merged")),
 		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),

@@ -1014,6 +1026,9 @@ int cmd_branch(int argc,
 	if (noncreate_actions > 1)
 		usage_with_options(builtin_branch_usage, options);
 
+	if (dry_run && !delete_merged)
+		die(_("--dry-run requires --delete-merged"));
+
 	if (recurse_submodules_explicit) {
 		if (!submodule_propagate_branches)
 			die(_("branch with --recurse-submodules can only be used if submodule.propagateBranches is enabled"));

@@ -1054,7 +1069,8 @@ int cmd_branch(int argc,
 		goto out;
 	} else if (delete_merged) {
 		ret = delete_merged_branches(argc, argv,
-					     quiet ? DELETE_BRANCH_QUIET : 0);
+					     (quiet ? DELETE_BRANCH_QUIET : 0) |
+					     (dry_run ? DELETE_BRANCH_DRY_RUN : 0));
 		goto out;
 	} else if (show_current) {
 		print_current_branch_name();

index b7595610d9..cddcde341d 100755
@@ -1892,8 +1892,12 @@ test_expect_success '--delete-merged deletes merged branches and spares the rest
 	) &&
 	sha=$(git -C repo rev-parse --short merged) &&
 
-	git -C repo branch --delete-merged origin/next >actual 2>&1 &&
+	git -C repo branch --dry-run --delete-merged origin/next >actual 2>&1 &&
+	echo "Would delete branch merged (was $sha)." >expect &&
+	test_cmp expect actual &&
+	git -C repo rev-parse --verify refs/heads/merged &&
 
+	git -C repo branch --delete-merged origin/next >actual 2>&1 &&
 	echo "Deleted branch merged (was $sha)." >expect &&
 	test_cmp expect actual &&
 	git -C repo for-each-ref --format="%(refname:short)" refs/heads/ >actual &&

@@ -2050,4 +2054,9 @@ test_expect_success "branch -d still deletes a deleteMerged=false branch" '
 	test_must_fail git -C repo rev-parse --verify refs/heads/kept
 '
 
+test_expect_success '--dry-run without --delete-merged is rejected' '
+	test_must_fail git -C forked branch --dry-run 2>err &&
+	test_grep "requires --delete-merged" err
+'
+
 test_done

gitgitgadget

Hi Harald

The same filtering as what? I think something like

"git branch --dry-run --delete-merged ..." prints one line per ref that would be deleted without modifing any refs.

would be sufficient

Good

Yeah, it's a bit weird. What do you suggest we do instead, reject the combination or turn it into a no-op?

Harald

Hi Harald

I've looked through the first five patches and left a few comments and queries. I'll look at the last two at the start of next week so don't re-roll just yet, but my all means reply to the comments, especially where I've asked questions. So far I like what I've seen.

Thanks

Phillip

Delete branches that have already been merged on upstream.

Changes in v19:

* Fix bug where dry-run would still remove config, added test coverage.
* Redesigned --delete-merged as a repeatable upstream selector with optional positional patterns limiting deletion scope.
* Protect same-name upstream branches independently of push-default configuration.
* Simplified flags handling where local caching became complicated when mutating values.
* Clarified assertions in tests.

Changes in v18:

* Instead of keeping the whole chain of upstream branches, keep only the ones an unmerged branch still needs. When a kept (merged) branch in turn tracks a branch that is being deleted, clear its now-stale upstream config.
* Rework spare_stacked_bases() to record the kept bases and, in a second pass, clear the upstream of any whose own base is going away. Build the to-delete list with strset_for_each_entry() instead of re-walking the candidate array.

Changes in v17:

* Keep a merged branch when another surviving branch still tracks it as its upstream, so --delete-merged no longer deletes a branch out from under one stacked on top of it.
* Move the --dry-run and branch.<name>.deleteMerged opt-out fully into their own commits.

Changes in v16:

* Convert delete_merged_branches() to take an unsigned int flags argument instead of separate quiet/dry_run booleans, matching delete_branches()
* Reuse the strbuf across the skip-config loop (strbuf_reset per iteration, single strbuf_release after) instead of allocating and freeing it each time
* Rewrite the --delete-merged tests as integration tests: branches that land commits upstream, with deletion and the checked-out, upstream-gone, and push-equals-upstream safety cases exercised together in one run and output asserted via test_cmp
* Collapse the many per-aspect test repos into a single reused repo set up by a setup_repo_for_delete_merged helper, and rename helpers off the old pm_/prune naming
* Nest single-repo setup sequences in ( cd ... ) subshells instead of prefixing every command with -C

Changes in v15:

* Renamed --prune-merged to --delete-merged throughout. Not necessarily final, but something to advance the discussion.
* --delete-merged now silently skips not-yet-merged branches instead of warning.
* Initialized the delete_branches() flag locals where declared. Only force stays deferred.
* delete_branches()/check_branch_commit() doc and code cleanups: redundant branch NULL checks dropped, ref_array candidates = { 0 }, a BUG() for the unreachable non-branch ref, and reworked --delete-merged doc wording.
* Broadened the --forked tests (local commits for realism, remote add -f, --forked coverage), renamed the misleading trunk fixture, and replaced the misnamed detached branch with git checkout --detach.

Changes in v14:

* Fixed a git branch -d -r regression (broke t5404/t5505/t5514): the remotes path set a local force but not the DELETE_BRANCH_FORCE bit that check_branch_commit() reads, so it wrongly ran the merge check.
* Made flags the single source of truth in delete_branches() so the bit and the derived locals can't disagree.
* Works locally, but GitHub CI has problems that are there for other branches too, hopefully not related
(https://github.com/git/git/pull/2285).

Changes in v13:

* Reworked --forked into a real ref-filter applied in apply_ref_filter() instead of a post-pass, so non-matching branches are never allocated.
* Match exact --forked patterns on full refnames (only globs use the abbreviated upstream), and dropped the old helper machinery, forward declaration, and string_list in favor of a strvec.
* Replaced the boolean parameters of delete_branches()/check_branch_commit() with a single unsigned int flags.
* --prune-merged now collects candidates via filter_refs() rather than its own branch walk.
* --prune-merged now takes its patterns as positional arguments (e.g. git branch --prune-merged origin/main 'feature*') instead of repeating the option.

Changes in v12:

* Reworked --forked from a standalone action into a --list-mode filter.
* Switched --forked and --prune-merged to repeatable OPT_STRING_LIST options.
* Dropped the bare-remote-name resolution for --forked, the argument is now a ref or a glob.

Changes in v11:

* The flags now take a branch, not a remote. --forked and --prune-merged accept a literal upstream short name like origin/main or a wildmatch pattern like origin/. The old --all-remotes flag is gone, since origin/ covers that case.
* The prune guard now compares @{push} against @{upstream}. A branch is spared when these are equal. That is the trunk like case, such as local main tracking and pushing to origin/main, where "fully merged to upstream" cannot be told apart from "just pulled". Only branches that push somewhere other than their upstream, typically fork based topics, are candidates. The earlier /HEAD by name guard that the reviewer rejected is gone.
* New --dry-run for --prune-merged.

Changes in v10:

* --forked / --prune-merged now take a branch glob instead of a remote name — origin, origin/*, origin/release-- all work. This replaces the remote-only form and subsumes the old --all-remotes flag, which has been dropped.
* New --dry-run for --prune-merged.

Changes in v9:

* --force no longer has special meaning with --prune-merged; reachability is always enforced. Use git branch -D to delete an unmerged branch. Matches how git branch's other read/safe actions treat --force.
* Synopsis drops [-f]; "not fully merged" hint points at git branch -D.
* Dropped the --prune-merged --force tests.

Changes in v8:

* Delete only when the branch's work is actually reachable from its upstream
* Skip branches whose upstream is gone (even with --force)
* Simplified the internal safety flag to live in one place

Changes in v7:

* --prune-merged now checks if a branch is merged into its own upstream first. If the upstream is gone, it checks against the remote's default branch instead. If neither exists, the branch is refused (use --force to delete anyway).

Changes in v6:

* --prune-merged now measures merged-ness against the remote's default branch instead of the candidate's upstream — so the decision no longer depends on which branch happens to be checked out locally.
* delete_branches() / check_branch_commit() gained a per-candidate override that lets a caller substitute a different "what counts as merged" reference (or skip the check). branch -d callers pass NULL and keep their existing semantics.
* prune_merged_branches() resolves each candidate's push-remote HEAD and threads it through, so --prune-merged --all-remotes measures each candidate against its own remote rather than a single global reference.

Changes in v5:

* Drop commit 'fetch: add --prune-merged'

Changes in v4:

* Resolve each remote's HEAD and collect the targets into a protected_default_refs set in collect_forked_set.
* In prune_merged_branches, skip a candidate when its upstream is a protected default ref and the local branch name matches the default branch's leaf name (so a local main tracking origin/main is spared, but a renamed trunk tracking origin/main is not).
* Also skip when the candidate's push ref points at a protected default ref, so a topic branch configured to push to origin/main is never pruned.
* Tests: spare the local default branch; only protect by matching leaf name (not by upstream alone); spare a branch whose push ref is the remote default.

Changes in v3:

* s/remote-tracking refs/remote-tracking branches/g

Changes in v2:

* The whole feature moved out of git fetch and into git branch. git fetch --prune-merged now just calls git branch --prune-merged after fetching.
* The fetch.pruneLocalBranches and remote..pruneLocalBranches config options are gone, replaced by per-branch opt-out via branch..pruneMerged.
* New git branch --forked lists local branches whose upstream lives on the given remote (read-only building block).
* New git branch --prune-merged deletes those branches, but only if their tip is reachable from the upstream tracking ref; --force skips that safety check.
* New git branch --all-remotes lets --forked/--prune-merged operate across every configured remote at once.
* The currently checked-out branch in any worktree is always preserved.
* branch..pruneMerged=false lets you exempt a branch (e.g. a long-running topic branch) even with --force; doesn't affect explicit git branch -d.
* delete_branches() got a warn_only mode so bulk deletion prints a one-line warning per skipped branch instead of the noisy four-line hint that git branch -d shows.
* New section in git-branch docs; git-fetch docs trimmed to just mention --prune-merged.
* New tests in t3200-branch.sh for the new branch flags; t5510-fetch.sh shrunk since most logic moved.

Harald Nordgren (7):
branch: add --forked filter for --list mode
branch: convert delete_branches() to a flags argument
branch: let delete_branches skip unmerged branches on bulk refusal
branch: prepare delete_branches for a bulk caller
branch: add --delete-merged <branch>
branch: add branch.<name>.deleteMerged opt-out
branch: add --dry-run for --delete-merged

 Documentation/config/branch.adoc |   7 +
 Documentation/git-branch.adoc    |  50 ++++-
 builtin/branch.c                 | 284 ++++++++++++++++++++++---
 ref-filter.c                     |  70 ++++++
 ref-filter.h                     |  10 +
 t/t3200-branch.sh                | 352 +++++++++++++++++++++++++++++++
 6 files changed, 742 insertions(+), 31 deletions(-)

base-commit: f60db8d575adb79761d363e026fb49bddf330c73
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2285%2FHaraldNordgren%2Ffetch-prune-local-branches-v19
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2285/HaraldNordgren/fetch-prune-local-branches-v19
Pull-Request: https://github.com/git/git/pull/2285

Range-diff vs v18:

1: 3e29ff17bd ! 1: 562648132d branch: add --forked filter for --list mode

     @@ t/t3200-branch.sh: test_expect_success 'errors if given a bad branch name' '
      +	(
      +		cd forked &&
      +		git remote add -f other ../forked-other &&
     -+		git remote set-head origin one &&
      +		git branch local-base &&
      +		git branch --track local-one origin/one &&
      +		git branch --track local-two origin/two &&
     @@ t/t3200-branch.sh: test_expect_success 'errors if given a bad branch name' '
      +		git checkout local-one &&
      +		test_commit --no-tag local-one-work local-one.t &&
      +		git checkout local-foreign &&
     -+		test_commit --no-tag local-foreign-work local-foreign.t &&
     -+		git checkout --detach
     ++		test_commit --no-tag local-foreign-work local-foreign.t
      +	)
      +'
      +
     @@ t/t3200-branch.sh: test_expect_success 'errors if given a bad branch name' '
      +'
      +
      +test_expect_success '--forked composes with --no-merged' '
     -+	test_when_finished "git -C forked checkout --detach" &&
     -+	git -C forked checkout local-one &&
     -+	test_commit -C forked local-only &&
      +	git -C forked branch --forked "origin/*" --no-merged origin/one \
      +		--format="%(refname:short)" >actual &&
      +	echo local-one >expect &&
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success '--forked rejects unknown branch/pattern' '
     -+	test_must_fail git -C forked branch --forked nope 2>err &&
     -+	test_grep "not a valid branch or pattern" err
     -+'
     -+
     -+test_expect_success '--forked requires a value' '
     -+	test_must_fail git -C forked branch --forked 2>err &&
     -+	test_grep "requires a value" err
     -+'
     -+
      +test_expect_success '--forked <remote> uses the branch <remote>/HEAD points at' '
      +	git -C forked branch --forked origin --format="%(refname:short)" >actual &&
     -+	echo local-one >expect &&
     ++	echo main >expect &&
      +	test_cmp expect actual
      +'
      +
     @@ t/t3200-branch.sh: test_expect_success 'errors if given a bad branch name' '
      +	EOF
      +	test_cmp expect actual
      +'
     ++
     ++test_expect_success '--forked rejects unknown branch/pattern' '
     ++	test_must_fail git -C forked branch --forked nope 2>err &&
     ++	test_grep "not a valid branch or pattern" err
     ++'
     ++
     ++test_expect_success '--forked requires a value' '
     ++	test_must_fail git -C forked branch --forked 2>err &&
     ++	test_grep "requires a value" err
     ++'
      +
       test_done

2: cdd4fea4a7 ! 2: c7ebd9344c branch: convert delete_branches() to a flags argument
@@ Metadata
## Commit message ##
branch: convert delete_branches() to a flags argument

- delete_branches() and check_branch_commit() take a pair of int
- booleans (force and quiet) that the next commits would grow further.
- Replace them with a single "unsigned int flags" argument and an
- enum, splitting the bits back into named bool locals so the body
- keeps reading the same named values.
+ delete_branches() takes separate force and quiet parameters, while
+ check_branch_commit() takes force. The next commits would grow this
+ collection further. Replace them with a single unsigned flags argument
+ and an enum.
+
+ Test the FORCE and QUIET bits directly from flags at each use site so
+ that mutating or forwarding flags cannot leave cached values stale.

No change in behavior.

@@ builtin/branch.c: static int branch_merged(int kind, const char *name,
- int kinds, int force)
+ int kinds, unsigned int flags)
{
-+ bool force = flags & DELETE_BRANCH_FORCE;
struct commit *rev = lookup_commit_reference(the_repository, oid);
- if (!force && !rev) {
+- if (!force && !rev) {
++ if (!(flags & DELETE_BRANCH_FORCE) && !rev) {
error(_("couldn't look up commit object for '%s'"), refname);
+ return -1;
+ }
+- if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
++ if (!(flags & DELETE_BRANCH_FORCE) &&
++ !branch_merged(kinds, branchname, rev, head_rev)) {
+ error(_("the branch '%s' is not fully merged"), branchname);
+ advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
+ _("If you are sure you want to delete it, "
@@ builtin/branch.c: static void delete_branch_config(const char *branchname)
strbuf_release(&buf);
}
@@ builtin/branch.c: static void delete_branch_config(const char *branchname)
{
struct commit *head_rev = NULL;
struct object_id oid;
-@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int force, int kinds,
- int i;
- int ret = 0;
- int remote_branch = 0;
-+ bool force;
-+ bool quiet = flags & DELETE_BRANCH_QUIET;
- struct strbuf bname = STRBUF_INIT;
- enum interpret_branch_kind allowed_interpret;
- struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int force, int kinds,
remote_branch = 1;
allowed_interpret = INTERPRET_BRANCH_REMOTE;
@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int fo
}
branch_name_pos = strcspn(fmt, "%");

-+ force = flags & DELETE_BRANCH_FORCE;
-+
- if (!force)
+- if (!force)
++ if (!(flags & DELETE_BRANCH_FORCE))
head_rev = lookup_commit_reference(the_repository, &head_oid);

for (i = 0; i < argc; i++, strbuf_reset(&bname)) {
@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int fo
: repo_find_unique_abbrev(the_repository, &oid, DEFAULT_ABBREV));

next:
+@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int force, int kinds,
+ char *name = item->string;
+ if (!refs_ref_exists(get_main_ref_store(the_repository), name)) {
+ char *refname = name + branch_name_pos;
+- if (!quiet)
++ if (!(flags & DELETE_BRANCH_QUIET))
+ printf(remote_branch
+ ? _("Deleted remote-tracking branch %s (was %s).\n")
+ : _("Deleted branch %s (was %s).\n"),
@@ builtin/branch.c: int cmd_branch(int argc,
if (delete) {
if (!argc)
3: a0fd5b4a6c ! 3: 0c4f3358e3 branch: let delete_branches skip unmerged branches on bulk refusal
@@ builtin/branch.c: static int branch_merged(int kind, const char *name,

static int check_branch_commit(const char *branchname, const char *refname,
@@ builtin/branch.c: static int check_branch_commit(const char *branchname, const char *refname,
- int kinds, unsigned int flags)
- {
- bool force = flags & DELETE_BRANCH_FORCE;
-+ bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
- struct commit *rev = lookup_commit_reference(the_repository, oid);
- if (!force && !rev) {
- error(_("couldn't look up commit object for '%s'"), refname);
- return -1;
}
- if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
+ if (!(flags & DELETE_BRANCH_FORCE) &&
+ !branch_merged(kinds, branchname, rev, head_rev)) {
- error(_("the branch '%s' is not fully merged"), branchname);
- advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
- _("If you are sure you want to delete it, "
- "run 'git branch -D %s'"), branchname);
-+ if (!skip_unmerged) {
++ if (!(flags & DELETE_BRANCH_SKIP_UNMERGED)) {
+ error(_("the branch '%s' is not fully merged"),
+ branchname);
+ advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
@@ builtin/branch.c: static int check_branch_commit(const char *branchname, const c
return -1;
}
return 0;
-@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int kinds,
- int remote_branch = 0;
- bool force;
- bool quiet = flags & DELETE_BRANCH_QUIET;
-+ bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
- struct strbuf bname = STRBUF_INIT;
- enum interpret_branch_kind allowed_interpret;
- struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int kinds,
if (!(ref_flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
flags)) {
- ret = 1;
-+ if (!skip_unmerged)
++ if (!(flags & DELETE_BRANCH_SKIP_UNMERGED))
+ ret = 1;
goto next;
}
4: a56d8fe93e ! 4: 64a202526a branch: prepare delete_branches for a bulk caller
@@ Metadata
## Commit message ##
branch: prepare delete_branches for a bulk caller

- Teach delete_branches() two new modes for the upcoming
- --delete-merged: one that asks only whether a branch is merged into
- its upstream, without falling back to HEAD when there is no
- upstream, and one that rehearses the deletions without removing any
- ref. Existing callers keep their current behavior.
+ Teach delete_branches() a new mode for the upcoming --delete-merged
+ caller that checks whether a branch is merged into its upstream without
+ falling back to HEAD when there is no upstream. Existing callers keep
+ their current behavior.

@@ builtin/branch.c: enum delete_branch_flags {

static int check_branch_commit(const char *branchname, const char *refname,
@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int kinds,
- bool force;
- bool quiet = flags & DELETE_BRANCH_QUIET;
- bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
-+ bool no_head_fallback = flags & DELETE_BRANCH_NO_HEAD_FALLBACK;
- struct strbuf bname = STRBUF_INIT;
- enum interpret_branch_kind allowed_interpret;
- struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
-@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int kinds, -
- force = flags & DELETE_BRANCH_FORCE;
+ }
+ branch_name_pos = strcspn(fmt, "%");

-- if (!force)
-+ if (!force && !no_head_fallback)
+- if (!(flags & DELETE_BRANCH_FORCE))
++ if (!(flags & DELETE_BRANCH_FORCE) &&
++ !(flags & DELETE_BRANCH_NO_HEAD_FALLBACK))
head_rev = lookup_commit_reference(the_repository, &head_oid);

for (i = 0; i < argc; i++, strbuf_reset(&bname)) {
5: a84c555d99 ! 5: a6caa5b397 branch: add --delete-merged <branch>

     @@ Metadata
       ## Commit message ##
          branch: add --delete-merged <branch>
      
     -            git branch --delete-merged <branch>...
     +        git branch (--delete-merged <branch>)... [<pattern>...]
      
     -    deletes the local branches that "--forked <branch>" would list,
     -    keeping only those whose tip is reachable from their configured
     -    upstream. The work has already landed on the upstream they track,
     -    so the local copy is no longer needed.
     +    deletes local branches matching the optional patterns when their
     +    configured upstream matches one of the --delete-merged arguments and
     +    their tip is reachable from that upstream. The work has already landed
     +    on the upstream they track, so the local copy is no longer needed.
     +
     +    The option can be repeated to widen the upstream match. Keeping the
     +    candidate patterns as positional arguments lets users bound the set of
     +    local branches that may be deleted independently of the upstream
     +    selection.
      
          A branch is not deleted when:
      
            * it is checked out in any worktree
     -      * its upstream remote-tracking branch no longer exists, since a
     -        missing upstream is not by itself a sign of integration
     -      * its push destination equals its upstream (<branch>@{push} is
     -        the same as <branch>@{upstream}), such as a local "main" that
     -        tracks and pushes to "origin/main". Right after a pull it just
     -        looks "fully merged", so it is kept. Only branches that push
     -        somewhere other than their upstream, typically topics in a fork
     -        workflow, are candidates.
     +      * its configured upstream ref no longer exists, since a missing
     +        upstream is not by itself a sign of integration
     +      * pushing it by name to the remote configured by
     +        branch.<name>.remote would update its upstream, as determined by
     +        mapping the branch ref through that remote's fetch refspec. For
     +        example, a local "main" that tracks "origin/main" is kept even when
     +        remote.pushDefault names a fork. Right after a pull it merely looks
     +        fully merged.
      
          A branch whose work is not yet merged into its upstream is silently
          skipped, so one unmerged topic does not abort the whole sweep.
     @@ Documentation/git-branch.adoc: git branch (-m|-M) [<old-branch>] <new-branch>
       git branch (-c|-C) [<old-branch>] <new-branch>
       git branch (-d|-D) [-r] <branch-name>...
       git branch --edit-description [<branch-name>]
     -+git branch --delete-merged <branch>...
     ++git branch (--delete-merged <branch>)... [<pattern>...]
       
       DESCRIPTION
       -----------
     @@ Documentation/git-branch.adoc: This option is only applicable in non-verbose mod
       	Print the name of the current branch. In detached `HEAD` state,
       	nothing is printed.
       
     -+`--delete-merged <branch>...`::
     -+	Delete the local branches that `--forked` would list for the
     -+	given _<branch>_ arguments, but only those whose tip is
     -+	reachable from their configured upstream. In other words, the
     -+	work on the branch has already landed on the upstream it
     -+	tracks, so the local copy is no longer needed. Several
     -+	_<branch>_ patterns may be given, e.g. `git branch
     -+	--delete-merged origin/main 'feature*'`.
     ++`--delete-merged <branch>`::
     ++	Delete local branches whose configured upstream matches
     ++	_<branch>_, but only when their tip is reachable from that
     ++	upstream. In other words, the work on the branch has already
     ++	landed on the upstream it tracks, so the local copy is no longer
     ++	needed. The option can be repeated to widen the upstream match.
     ++	Optional _<pattern>_ arguments limit which local branches are
     ++	considered, e.g. `git branch --delete-merged 'origin/*'
     ++	'topic-*'`.
      ++
      +A branch is not deleted when:
      ++
      +--
     -+* its upstream remote-tracking branch no longer exists,
     ++* its configured upstream ref no longer exists,
      +* it is checked out in any worktree, or
     -+* its push destination (`<branch>@{push}`) equals its upstream
     -+  (`<branch>@{upstream}`), so it cannot be distinguished from a
     -+  branch that just looks "fully merged" right after a pull.
     ++* pushing it by name to the remote configured by
     ++  `branch.<name>.remote` would update its upstream, so it cannot be
     ++  distinguished from a branch that just looks "fully merged" right
     ++  after a pull.
      +--
      ++
      +A branch whose work has not yet been merged into its upstream is
     @@ builtin/branch.c: static const char * const builtin_branch_usage[] = {
       	N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
       	N_("git branch [<options>] [-r | -a] [--points-at]"),
       	N_("git branch [<options>] [-r | -a] [--format]"),
     -+	N_("git branch [<options>] --delete-merged <branch>..."),
     ++	N_("git branch [<options>] (--delete-merged <branch>)... [<pattern>...]"),
       	NULL
       };
       
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
      +	strset_clear(&spared);
      +}
      +
     -+static int delete_merged_branches(int argc, const char **argv,
     -+				 unsigned int flags)
     ++static int branch_pushes_to_upstream(struct branch *branch,
     ++				     const char *upstream)
     ++{
     ++	struct remote *remote = remote_get(remote_for_branch(branch, NULL));
     ++	char *tracking = NULL;
     ++	int ret = 0;
     ++
     ++	if (remote)
     ++		tracking = apply_refspecs(&remote->fetch, branch->refname);
     ++	if (tracking && !strcmp(tracking, upstream))
     ++		ret = 1;
     ++
     ++	free(tracking);
     ++	return ret;
     ++}
     ++
     ++static int delete_merged_branches(const struct strvec *upstreams,
     ++				 const char **argv, unsigned int flags)
      +{
      +	struct ref_store *refs = get_main_ref_store(the_repository);
      +	struct ref_filter filter = REF_FILTER_INIT;
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
      +	struct strvec to_delete = STRVEC_INIT;
      +	struct hashmap_iter iter;
      +	struct strmap_entry *entry;
     -+	int i, ret = 0;
     ++	size_t i;
     ++	int ret = 0;
      +
     -+	if (!argc)
     -+		die(_("--delete-merged requires at least one <branch>"));
     -+
     -+	for (i = 0; i < argc; i++)
     -+		if (ref_filter_forked_add(&filter, argv[i]) < 0)
     -+			die(_("'%s' is not a valid branch or pattern"), argv[i]);
     ++	for (i = 0; i < upstreams->nr; i++)
     ++		if (ref_filter_forked_add(&filter, upstreams->v[i]) < 0)
     ++			die(_("'%s' is not a valid branch or pattern"),
     ++			    upstreams->v[i]);
      +
      +	filter.kind = FILTER_REFS_BRANCHES;
     ++	filter.name_patterns = argv;
      +	filter_refs(&candidates, &filter, filter.kind);
      +
     -+	for (i = 0; i < candidates.nr; i++) {
     ++	for (i = 0; i < (size_t)candidates.nr; i++) {
      +		const char *full_name = candidates.items[i]->refname;
      +		const char *short_name;
      +		struct branch *branch;
     -+		const char *upstream, *push;
     ++		const char *upstream;
      +
      +		if (!skip_prefix(full_name, "refs/heads/", &short_name))
      +			BUG("filter returned non-branch ref '%s'", full_name);
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
      +		upstream = branch_get_upstream(branch, NULL);
      +		if (!upstream || !refs_ref_exists(refs, upstream))
      +			continue;
     -+		push = branch_get_push(branch, NULL);
     -+		if (!push || !strcmp(push, upstream))
     ++		if (branch_pushes_to_upstream(branch, upstream))
      +			continue;
      +		if (check_branch_commit(short_name, short_name,
      +					&candidates.items[i]->objectname, NULL,
     @@ builtin/branch.c: int cmd_branch(int argc,
       	/* possible actions */
       	int delete = 0, rename = 0, copy = 0, list = 0,
       	    unset_upstream = 0, show_current = 0, edit_description = 0;
     -+	int delete_merged = 0;
     ++	struct strvec delete_merged = STRVEC_INIT;
       	const char *new_upstream = NULL;
       	int noncreate_actions = 0;
       	/* possible options */
     @@ builtin/branch.c: int cmd_branch(int argc,
       		OPT_BOOL(0, "create-reflog", &reflog, N_("create the branch's reflog")),
       		OPT_BOOL(0, "edit-description", &edit_description,
       			 N_("edit the description for the branch")),
     -+		OPT_BOOL(0, "delete-merged", &delete_merged,
     -+			N_("delete local branches whose upstream matches <branch> and are merged")),
     ++		OPT_CALLBACK_F(0, "delete-merged", &delete_merged, N_("branch"),
     ++			N_("delete merged branches whose upstream matches <branch> (repeatable)"),
     ++			PARSE_OPT_NONEG, parse_opt_strvec),
       		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
       		OPT_MERGED(&filter, N_("print only branches that are merged")),
       		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
     @@ builtin/branch.c: int cmd_branch(int argc,
       
       	if (!delete && !rename && !copy && !edit_description && !new_upstream &&
      -	    !show_current && !unset_upstream && argc == 0)
     -+	    !show_current && !unset_upstream && !delete_merged &&
     ++	    !show_current && !unset_upstream && !delete_merged.nr &&
      +	    argc == 0)
       		list = 1;
       
     @@ builtin/branch.c: int cmd_branch(int argc,
       	noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
       			    !!show_current + !!list + !!edit_description +
      -			    !!unset_upstream;
     -+			    !!unset_upstream + !!delete_merged;
     ++			    !!unset_upstream + !!delete_merged.nr;
       	if (noncreate_actions > 1)
       		usage_with_options(builtin_branch_usage, options);
       
     @@ builtin/branch.c: int cmd_branch(int argc,
       				      (delete > 1 ? DELETE_BRANCH_FORCE : 0) |
       				      (quiet ? DELETE_BRANCH_QUIET : 0));
       		goto out;
     -+	} else if (delete_merged) {
     -+		ret = delete_merged_branches(argc, argv,
     ++	} else if (delete_merged.nr) {
     ++		ret = delete_merged_branches(&delete_merged, argv,
      +					     quiet ? DELETE_BRANCH_QUIET : 0);
      +		goto out;
       	} else if (show_current) {
       		print_current_branch_name();
       		ret = 0;
     +@@ builtin/branch.c: int cmd_branch(int argc,
     + 	ret = 0;
     + 
     + out:
     ++	strvec_clear(&delete_merged);
     + 	string_list_clear(&sorting_options, 0);
     + 	return ret;
     + }
      
       ## t/t3200-branch.sh ##
     -@@ t/t3200-branch.sh: test_expect_success '--forked narrows a <pattern> argument' '
     - 	test_cmp expect actual
     +@@ t/t3200-branch.sh: test_expect_success '--forked requires a value' '
     + 	test_grep "requires a value" err
       '
       
      +test_expect_success '--delete-merged: setup' '
     @@ t/t3200-branch.sh: test_expect_success '--forked narrows a <pattern> argument' '
      +		cd repo &&
      +		git remote add fork ../fork &&
      +		git remote add other ../other &&
     -+		git config remote.pushDefault fork &&
      +		git config push.default current &&
      +		git fetch other
      +	)
      +}
      +
     -+merged_branch () {
     ++create_merged_branch () {
      +	(
      +		cd repo &&
     -+		git checkout -b "$1" "$2" &&
     ++		git checkout -b "$1" origin/next --track &&
      +		git commit --allow-empty -m "$1 work" &&
     -+		git push origin "$1:next" &&
     -+		git fetch origin &&
     -+		git branch --set-upstream-to="$2" "$1"
     ++		git push origin "$1:next"
      +	)
      +}
      +
     -+test_expect_success '--delete-merged deletes merged branches and spares the rest' '
     -+	test_when_finished "rm -rf repo" &&
     -+	setup_repo_for_delete_merged &&
     -+	merged_branch merged origin/next &&
     -+	(
     -+		cd repo &&
     -+		git checkout -b unmerged origin/next &&
     -+		git commit --allow-empty -m "unmerged work" &&
     -+		git branch --set-upstream-to=origin/next unmerged &&
     -+		git checkout -b tracks-other other/main &&
     -+		git branch --set-upstream-to=other/main tracks-other &&
     -+		git checkout --detach
     -+	) &&
     -+	sha=$(git -C repo rev-parse --short merged) &&
     -+
     -+	git -C repo branch --delete-merged origin/next >actual 2>&1 &&
     -+
     -+	echo "Deleted branch merged (was $sha)." >expect &&
     -+	test_cmp expect actual &&
     -+	git -C repo for-each-ref --format="%(refname:short)" refs/heads/ >actual &&
     -+	cat >expect <<-\EOF &&
     -+	main
     -+	tracks-other
     -+	unmerged
     -+	EOF
     ++check_branches () {
     ++	git for-each-ref --format="%(refname:short)" refs/heads/ >actual &&
     ++	cat >expect &&
      +	test_cmp expect actual
     -+'
     ++}
      +
     -+test_expect_success '--delete-merged deletes merged branches and spares protected ones' '
     -+	test_when_finished "rm -rf repo" &&
     ++test_expect_success '--delete-merged keeps cloned main without a default push remote' '
      +	setup_repo_for_delete_merged &&
     -+	merged_branch on-next origin/next &&
     -+	merged_branch checked-out origin/next &&
     -+	merged_branch upstream-gone origin/next &&
      +	(
      +		cd repo &&
     -+		git checkout -b mainline main &&
     -+		git checkout -b on-local mainline &&
     -+		git branch --set-upstream-to=mainline on-local &&
     -+		git update-ref refs/remotes/origin/topic refs/remotes/origin/next &&
     -+		git branch --set-upstream-to=origin/topic upstream-gone &&
     -+		git update-ref -d refs/remotes/origin/topic &&
     -+		git branch --set-upstream-to=origin/main main &&
     -+		git config branch.main.pushRemote origin &&
     -+		git checkout -b tracks-other other/main &&
     -+		git branch --set-upstream-to=other/main tracks-other &&
     -+		git checkout checked-out
     -+	) &&
     ++		git checkout --detach &&
      +
     -+	git -C repo branch --delete-merged origin/next mainline &&
     ++		git branch --delete-merged */* &&
      +
     -+	git -C repo for-each-ref --format="%(refname:short)" refs/heads/ >actual &&
     -+	cat >expect <<-\EOF &&
     -+	checked-out
     -+	main
     -+	mainline
     -+	tracks-other
     -+	upstream-gone
     -+	EOF
     -+	test_cmp expect actual
     ++		check_branches <<-\EOF
     ++		main
     ++		EOF
     ++	)
      +'
      +
     -+test_expect_success '--delete-merged requires at least one <branch>' '
     -+	test_must_fail git -C forked branch --delete-merged 2>err &&
     -+	test_grep "requires at least one <branch>" err
     ++test_expect_success '--delete-merged deletes only selected merged branches' '
     ++	setup_repo_for_delete_merged &&
     ++	create_merged_branch also-merged &&
     ++	create_merged_branch merged &&
     ++	(
     ++		cd repo &&
     ++		git checkout -b unmerged origin/next --track &&
     ++		git commit --allow-empty -m "unmerged work" &&
     ++		git checkout -b tracks-other other/main --track &&
     ++		sha=$(git rev-parse --short merged) &&
     ++
     ++		git branch --delete-merged origin/next merged >actual 2>&1 &&
     ++		echo "Deleted branch merged (was $sha)." >expect &&
     ++		test_cmp expect actual &&
     ++
     ++		check_branches <<-\EOF
     ++		also-merged
     ++		main
     ++		tracks-other
     ++		unmerged
     ++		EOF
     ++	)
      +'
      +
     -+test_expect_success '--delete-merged keeps a branch that is an upstream' '
     -+	test_when_finished "rm -rf repo" &&
     ++test_expect_success '--delete-merged keeps main despite a different default push remote' '
      +	setup_repo_for_delete_merged &&
     -+	merged_branch feature origin/next &&
     ++	create_merged_branch on-next &&
     ++	create_merged_branch checked-out &&
     ++	create_merged_branch upstream-gone &&
      +	(
      +		cd repo &&
     -+		git checkout -b topic feature &&
     -+		git commit --allow-empty -m "topic work" &&
     -+		git branch --set-upstream-to=feature topic &&
     -+		git checkout --detach
     -+	) &&
     -+
     -+	git -C repo branch --dry-run --delete-merged origin/next >out &&
     -+	test_grep ! "feature" out &&
     -+
     -+	git -C repo branch --delete-merged origin/next 2>err &&
     -+
     -+	test_must_be_empty err &&
     -+	git -C repo rev-parse --verify refs/heads/feature &&
     -+	git -C repo rev-parse --verify refs/heads/topic &&
     -+	echo origin/next >expect &&
     -+	git -C repo rev-parse --abbrev-ref feature@{upstream} >actual &&
     -+	test_cmp expect actual &&
     -+	echo feature >expect &&
     -+	git -C repo rev-parse --abbrev-ref topic@{upstream} >actual &&
     -+	test_cmp expect actual
     ++		git config remote.pushDefault fork &&
     ++		git checkout -b local-to-delete main --track &&
     ++		git update-ref refs/remotes/origin/topic refs/remotes/origin/next &&
     ++		git branch --set-upstream-to=origin/topic upstream-gone &&
     ++		git update-ref -d refs/remotes/origin/topic &&
     ++		git checkout -b tracks-other other/main --track &&
     ++		git checkout checked-out &&
     ++
     ++		git branch --delete-merged origin/* \
     ++			--delete-merged main &&
     ++
     ++		check_branches <<-\EOF
     ++		checked-out
     ++		main
     ++		tracks-other
     ++		upstream-gone
     ++		EOF
     ++	)
      +'
      +
     -+test_expect_success '--delete-merged keeps a chain of upstreams of a kept branch' '
     -+	test_when_finished "rm -rf repo" &&
     ++test_expect_success '--delete-merged keeps the upstream of a surviving branch' '
      +	setup_repo_for_delete_merged &&
     ++	create_merged_branch feature &&
      +	(
      +		cd repo &&
     -+		git branch b3 origin/next &&
     -+		git branch --set-upstream-to=origin/next b3 &&
     -+		git branch b2 origin/next &&
     -+		git branch --set-upstream-to=b3 b2 &&
     -+		git checkout -b b1 b2 &&
     -+		git commit --allow-empty -m "b1 work" &&
     -+		git branch --set-upstream-to=b2 b1 &&
     -+		git checkout --detach
     -+	) &&
     -+
     -+	git -C repo branch --delete-merged origin/next &&
     ++		git checkout -b topic feature --track &&
     ++		git commit --allow-empty -m "topic work" &&
      +
     -+	git -C repo for-each-ref --format="%(refname:short)" refs/heads/ >actual &&
     -+	cat >expect <<-\EOF &&
     -+	b1
     -+	b2
     -+	b3
     -+	main
     -+	EOF
     -+	test_cmp expect actual
     ++		git branch --delete-merged origin/next 2>err &&
     ++
     ++		test_must_be_empty err &&
     ++		check_branches <<-\EOF &&
     ++		feature
     ++		main
     ++		topic
     ++		EOF
     ++
     ++		git config --local --get-regexp "branch\\.(feature|topic)\\.(merge|remote)" >actual &&
     ++		cat >expect <<-\EOF &&
     ++		branch.feature.remote origin
     ++		branch.feature.merge refs/heads/next
     ++		branch.topic.remote .
     ++		branch.topic.merge refs/heads/feature
     ++		EOF
     ++		test_cmp expect actual
     ++	)
      +'
      +
     -+test_expect_success '--delete-merged clears the upstream of a kept base whose own base is deleted' '
     -+	test_when_finished "rm -rf repo" &&
     ++test_expect_success '--delete-merged clears the deleted upstream of a spared branch' '
      +	setup_repo_for_delete_merged &&
      +	(
      +		cd repo &&
     -+		git branch lower origin/next &&
     -+		git branch --set-upstream-to=origin/next lower &&
     -+		git branch mid origin/next &&
     -+		git branch --set-upstream-to=lower mid &&
     -+		git checkout -b tip mid &&
     ++		git config remote.pushDefault fork &&
     ++		git branch lower origin/next --track &&
     ++		git branch mid lower --track &&
     ++		git checkout -b tip mid --track &&
      +		git commit --allow-empty -m "tip work" &&
     -+		git branch --set-upstream-to=mid tip &&
     -+		git checkout --detach
     -+	) &&
     -+
     -+	git -C repo branch --delete-merged origin/next lower &&
      +
     -+	test_must_fail git -C repo rev-parse --verify refs/heads/lower &&
     -+	git -C repo rev-parse --verify refs/heads/mid &&
     -+	test_must_fail git -C repo rev-parse mid@{upstream} &&
     -+	echo mid >expect &&
     -+	git -C repo rev-parse --abbrev-ref tip@{upstream} >actual &&
     -+	test_cmp expect actual
     ++		git branch --delete-merged origin/next \
     ++			--delete-merged lower &&
     ++
     ++		check_branches <<-\EOF &&
     ++		main
     ++		mid
     ++		tip
     ++		EOF
     ++
     ++		git config --local --get-regexp "branch\\.(mid|tip)\\.(merge|remote)" >actual &&
     ++		cat >expect <<-\EOF &&
     ++		branch.tip.remote .
     ++		branch.tip.merge refs/heads/mid
     ++		EOF
     ++		test_cmp expect actual
     ++	)
      +'
      +
     ++test_expect_success '--delete-merged requires a value' '
     ++	test_must_fail git -C forked branch --delete-merged 2>err &&
     ++	test_grep "requires a value" err
     ++'
       test_done
 6:  d52d717b70 ! 6:  734d27c908 branch: add branch.<name>.deleteMerged opt-out
     @@ Documentation/git-branch.adoc
      @@ Documentation/git-branch.adoc: A branch is not deleted when:
       +
       --
     - * its upstream remote-tracking branch no longer exists,
     + * its configured upstream ref no longer exists,
      -* it is checked out in any worktree, or
      +* it is checked out in any worktree,
     - * its push destination (`<branch>@{push}`) equals its upstream
     -   (`<branch>@{upstream}`), so it cannot be distinguished from a
     --  branch that just looks "fully merged" right after a pull.
     -+  branch that just looks "fully merged" right after a pull, or
     + * pushing it by name to the remote configured by
     +   `branch.<name>.remote` would update its upstream, so it cannot be
     +   distinguished from a branch that just looks "fully merged" right
     +-  after a pull.
     ++  after a pull, or
      +* `branch.<name>.deleteMerged` is set to `false`.
       --
       +
       A branch whose work has not yet been merged into its upstream is
      
       ## builtin/branch.c ##
     -@@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
     +@@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
       	struct ref_array candidates = { 0 };
       	struct strset deletable = STRSET_INIT;
       	struct strvec to_delete = STRVEC_INIT;
      +	struct strbuf key = STRBUF_INIT;
       	struct hashmap_iter iter;
       	struct strmap_entry *entry;
     -+	bool quiet = flags & DELETE_BRANCH_QUIET;
     - 	int i, ret = 0;
     - 
     - 	if (!argc)
     -@@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
     + 	size_t i;
     +@@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
       		const char *short_name;
       		struct branch *branch;
     - 		const char *upstream, *push;
     + 		const char *upstream;
      +		int opt_out;
       
       		if (!skip_prefix(full_name, "refs/heads/", &short_name))
       			BUG("filter returned non-branch ref '%s'", full_name);
     -@@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
     +@@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
       					FILTER_REFS_BRANCHES, DELETE_BRANCH_SKIP_UNMERGED))
       			continue;
       
     @@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
      +		strbuf_addf(&key, "branch.%s.deletemerged", short_name);
      +		if (!repo_config_get_bool(the_repository, key.buf, &opt_out) &&
      +		    !opt_out) {
     -+			if (!quiet)
     ++			if (!(flags & DELETE_BRANCH_QUIET))
      +				fprintf(stderr,
      +					_("Skipping '%s' (branch.%s.deleteMerged is false)\n"),
      +					short_name, short_name);
     @@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
       		strset_add(&deletable, short_name);
       	}
       
     -@@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
     +@@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
       				      DELETE_BRANCH_NO_HEAD_FALLBACK |
       				      flags);
       
     @@ builtin/branch.c: static int delete_merged_branches(int argc, const char **argv,
       	ref_array_clear(&candidates);
      
       ## t/t3200-branch.sh ##
     -@@ t/t3200-branch.sh: test_expect_success '--delete-merged clears the upstream of a kept base whose ow
     - 	test_cmp expect actual
     +@@ t/t3200-branch.sh: test_expect_success '--delete-merged requires a value' '
     + 	test_must_fail git -C forked branch --delete-merged 2>err &&
     + 	test_grep "requires a value" err
       '
     - 
     ++
      +test_expect_success '--delete-merged honours branch.<name>.deleteMerged=false' '
     -+	test_when_finished "rm -rf repo" &&
      +	setup_repo_for_delete_merged &&
     -+	merged_branch deleted origin/next &&
     -+	merged_branch kept origin/next &&
     -+	git -C repo config branch.kept.deleteMerged false &&
     -+	git -C repo checkout --detach &&
     ++	create_merged_branch deleted &&
     ++	create_merged_branch kept &&
     ++	(
     ++		cd repo &&
     ++		git config branch.kept.deleteMerged false &&
     ++		git checkout --detach &&
      +
     -+	git -C repo branch --delete-merged origin/next 2>err &&
     ++		git branch --delete-merged origin/next 2>err &&
      +
     -+	test_grep "Skipping .kept." err &&
     -+	test_must_fail git -C repo rev-parse --verify refs/heads/deleted &&
     -+	git -C repo rev-parse --verify refs/heads/kept
     ++		test_grep "Skipping .kept." err &&
     ++		check_branches <<-\EOF
     ++		kept
     ++		main
     ++		EOF
     ++	)
      +'
      +
      +test_expect_success "branch -d still deletes a deleteMerged=false branch" '
     -+	test_when_finished "rm -rf repo" &&
      +	setup_repo_for_delete_merged &&
     -+	merged_branch kept origin/next &&
     -+	git -C repo config branch.kept.deleteMerged false &&
     -+	git -C repo checkout --detach &&
     ++	create_merged_branch kept &&
     ++	(
     ++		cd repo &&
     ++		git config branch.kept.deleteMerged false &&
     ++		git checkout --detach &&
     ++
     ++		git branch -d kept &&
      +
     -+	git -C repo branch -d kept &&
     -+	test_must_fail git -C repo rev-parse --verify refs/heads/kept
     ++		check_branches <<-\EOF
     ++		main
     ++		EOF
     ++	)
      +'
      +
       test_done
 7:  8d0323f4b3 ! 7:  7aa9d5db14 branch: add --dry-run for --delete-merged
     @@ Metadata
       ## Commit message ##
          branch: add --dry-run for --delete-merged
      
     -    With --dry-run, --delete-merged prints the local branches it would
     -    delete, one "Would delete branch <name>" line each, and exits
     -    without touching any ref. The same filtering applies, so the output
     -    is exactly the set that the real run would delete.
     +    "git branch --dry-run --delete-merged ..." prints one line per ref that
     +    would be deleted without modifying refs or branch configuration.
      
          --dry-run is only meaningful together with --delete-merged and is
          rejected otherwise.
     @@ Documentation/git-branch.adoc: git branch (-m|-M) [<old-branch>] <new-branch>
       git branch (-c|-C) [<old-branch>] <new-branch>
       git branch (-d|-D) [-r] <branch-name>...
       git branch --edit-description [<branch-name>]
     --git branch --delete-merged <branch>...
     -+git branch [--dry-run] --delete-merged <branch>...
     +-git branch (--delete-merged <branch>)... [<pattern>...]
     ++git branch [--dry-run] (--delete-merged <branch>)... [<pattern>...]
       
       DESCRIPTION
       -----------
     @@ builtin/branch.c: enum delete_branch_flags {
       };
       
       static int check_branch_commit(const char *branchname, const char *refname,
     -@@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int kinds,
     - 	bool quiet = flags & DELETE_BRANCH_QUIET;
     - 	bool skip_unmerged = flags & DELETE_BRANCH_SKIP_UNMERGED;
     - 	bool no_head_fallback = flags & DELETE_BRANCH_NO_HEAD_FALLBACK;
     -+	bool dry_run = flags & DELETE_BRANCH_DRY_RUN;
     - 	struct strbuf bname = STRBUF_INIT;
     - 	enum interpret_branch_kind allowed_interpret;
     - 	struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
      @@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int kinds,
       		free(target);
       	}
       
      -	if (refs_delete_refs(get_main_ref_store(the_repository), NULL, &refs_to_delete, REF_NO_DEREF))
     -+	if (!dry_run &&
     ++	if (!(flags & DELETE_BRANCH_DRY_RUN) &&
      +	    refs_delete_refs(get_main_ref_store(the_repository), NULL, &refs_to_delete, REF_NO_DEREF))
       		ret = 1;
       
     @@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int ki
       		char *describe_ref = item->util;
       		char *name = item->string;
      -		if (!refs_ref_exists(get_main_ref_store(the_repository), name)) {
     -+		if (dry_run) {
     -+			if (!quiet)
     ++		if (flags & DELETE_BRANCH_DRY_RUN) {
     ++			if (!(flags & DELETE_BRANCH_QUIET))
      +				printf(remote_branch
      +					? _("Would delete remote-tracking branch %s (was %s).\n")
      +					: _("Would delete branch %s (was %s).\n"),
      +					name + branch_name_pos, describe_ref);
      +		} else if (!refs_ref_exists(get_main_ref_store(the_repository), name)) {
       			char *refname = name + branch_name_pos;
     - 			if (!quiet)
     + 			if (!(flags & DELETE_BRANCH_QUIET))
       				printf(remote_branch
     +@@ builtin/branch.c: static int spare_stacked_base(const struct reference *ref, void *cb_data)
     +  * base is itself merged, so when its own upstream is also going away
     +  * (no surviving branch tracks it), clear the base's now-stale upstream.
     +  */
     +-static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable)
     ++static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable,
     ++				unsigned int flags)
     + {
     + 	struct strset spared = STRSET_INIT;
     + 	struct spare_data data = { .deletable = deletable, .spared = &spared };
     +@@ builtin/branch.c: static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable
     + 
     + 	refs_for_each_branch_ref(refs, spare_stacked_base, &data);
     + 
     +-	strset_for_each_entry(&spared, &iter, entry) {
     +-		struct branch *branch = branch_get(entry->key);
     +-		const char *upstream = branch_get_upstream(branch, NULL);
     +-		const char *up_short;
     ++	if (!(flags & DELETE_BRANCH_DRY_RUN)) {
     ++		strset_for_each_entry(&spared, &iter, entry) {
     ++			struct branch *branch = branch_get(entry->key);
     ++			const char *upstream = branch_get_upstream(branch, NULL);
     ++			const char *up_short;
     + 
     +-		if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     +-		    !strset_contains(deletable, up_short))
     +-			continue;
     ++			if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     ++			    !strset_contains(deletable, up_short))
     ++				continue;
     + 
     +-		strbuf_reset(&key);
     +-		strbuf_addf(&key, "branch.%s.merge", branch->name);
     +-		repo_config_set_gently(the_repository, key.buf, NULL);
     +-		strbuf_reset(&key);
     +-		strbuf_addf(&key, "branch.%s.remote", branch->name);
     +-		repo_config_set_gently(the_repository, key.buf, NULL);
     ++			strbuf_reset(&key);
     ++			strbuf_addf(&key, "branch.%s.merge", branch->name);
     ++			repo_config_set_gently(the_repository, key.buf, NULL);
     ++			strbuf_reset(&key);
     ++			strbuf_addf(&key, "branch.%s.remote", branch->name);
     ++			repo_config_set_gently(the_repository, key.buf, NULL);
     ++		}
     + 	}
     + 
     + 	strbuf_release(&key);
     +@@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
     + 		strset_add(&deletable, short_name);
     + 	}
     + 
     +-	spare_stacked_bases(refs, &deletable);
     ++	spare_stacked_bases(refs, &deletable, flags);
     + 
     + 	strset_for_each_entry(&deletable, &iter, entry)
     + 		strvec_push(&to_delete, entry->key);
      @@ builtin/branch.c: int cmd_branch(int argc,
       	int delete = 0, rename = 0, copy = 0, list = 0,
       	    unset_upstream = 0, show_current = 0, edit_description = 0;
     - 	int delete_merged = 0;
     + 	struct strvec delete_merged = STRVEC_INIT;
      +	int dry_run = 0;
       	const char *new_upstream = NULL;
       	int noncreate_actions = 0;
       	/* possible options */
      @@ builtin/branch.c: int cmd_branch(int argc,
     - 			 N_("edit the description for the branch")),
     - 		OPT_BOOL(0, "delete-merged", &delete_merged,
     - 			N_("delete local branches whose upstream matches <branch> and are merged")),
     + 		OPT_CALLBACK_F(0, "delete-merged", &delete_merged, N_("branch"),
     + 			N_("delete merged branches whose upstream matches <branch> (repeatable)"),
     + 			PARSE_OPT_NONEG, parse_opt_strvec),
      +		OPT_BOOL(0, "dry-run", &dry_run,
      +			N_("with --delete-merged, only print which branches would be deleted")),
       		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
     @@ builtin/branch.c: int cmd_branch(int argc,
       	if (noncreate_actions > 1)
       		usage_with_options(builtin_branch_usage, options);
       
     -+	if (dry_run && !delete_merged)
     ++	if (dry_run && !delete_merged.nr)
      +		die(_("--dry-run requires --delete-merged"));
      +
       	if (recurse_submodules_explicit) {
     @@ builtin/branch.c: int cmd_branch(int argc,
       			die(_("branch with --recurse-submodules can only be used if submodule.propagateBranches is enabled"));
      @@ builtin/branch.c: int cmd_branch(int argc,
       		goto out;
     - 	} else if (delete_merged) {
     - 		ret = delete_merged_branches(argc, argv,
     + 	} else if (delete_merged.nr) {
     + 		ret = delete_merged_branches(&delete_merged, argv,
      -					     quiet ? DELETE_BRANCH_QUIET : 0);
      +					     (quiet ? DELETE_BRANCH_QUIET : 0) |
      +					     (dry_run ? DELETE_BRANCH_DRY_RUN : 0));
     @@ builtin/branch.c: int cmd_branch(int argc,
       		print_current_branch_name();
      
       ## t/t3200-branch.sh ##
     -@@ t/t3200-branch.sh: test_expect_success '--delete-merged deletes merged branches and spares the rest
     - 	) &&
     - 	sha=$(git -C repo rev-parse --short merged) &&
     - 
     --	git -C repo branch --delete-merged origin/next >actual 2>&1 &&
     -+	git -C repo branch --dry-run --delete-merged origin/next >actual 2>&1 &&
     -+	echo "Would delete branch merged (was $sha)." >expect &&
     -+	test_cmp expect actual &&
     -+	git -C repo rev-parse --verify refs/heads/merged &&
     - 
     -+	git -C repo branch --delete-merged origin/next >actual 2>&1 &&
     - 	echo "Deleted branch merged (was $sha)." >expect &&
     - 	test_cmp expect actual &&
     - 	git -C repo for-each-ref --format="%(refname:short)" refs/heads/ >actual &&
     +@@ t/t3200-branch.sh: test_expect_success '--delete-merged deletes only selected merged branches' '
     + 		git checkout -b tracks-other other/main --track &&
     + 		sha=$(git rev-parse --short merged) &&
     + 
     ++		git branch --dry-run --delete-merged origin/next merged >actual 2>&1 &&
     ++		echo "Would delete branch merged (was $sha)." >expect &&
     ++		test_cmp expect actual &&
     ++		git rev-parse --verify refs/heads/merged &&
     ++
     ++		check_branches <<-\EOF &&
     ++		also-merged
     ++		main
     ++		merged
     ++		tracks-other
     ++		unmerged
     ++		EOF
     ++
     + 		git branch --delete-merged origin/next merged >actual 2>&1 &&
     + 		echo "Deleted branch merged (was $sha)." >expect &&
     + 		test_cmp expect actual &&
     +@@ t/t3200-branch.sh: test_expect_success '--delete-merged keeps the upstream of a surviving branch' '
     + 		git checkout -b topic feature --track &&
     + 		git commit --allow-empty -m "topic work" &&
     + 
     +-		git branch --delete-merged origin/next 2>err &&
     ++		git branch --dry-run --delete-merged origin/next >out &&
     ++		test_grep ! "feature" out &&
     + 
     ++		git branch --delete-merged origin/next 2>err &&
     + 		test_must_be_empty err &&
     ++
     + 		check_branches <<-\EOF &&
     + 		feature
     + 		main
     +@@ t/t3200-branch.sh: test_expect_success '--delete-merged clears the deleted upstream of a spared bra
     + 		git checkout -b tip mid --track &&
     + 		git commit --allow-empty -m "tip work" &&
     + 
     ++		git branch --dry-run --delete-merged origin/next \
     ++			--delete-merged lower &&
     ++
     ++		git config --local --get-regexp "branch\\.(mid|tip)\\.(merge|remote)" >actual &&
     ++		cat >expect <<-\EOF &&
     ++		branch.mid.remote .
     ++		branch.mid.merge refs/heads/lower
     ++		branch.tip.remote .
     ++		branch.tip.merge refs/heads/mid
     ++		EOF
     ++		test_cmp expect actual &&
     ++
     + 		git branch --delete-merged origin/next \
     + 			--delete-merged lower &&
     + 
      @@ t/t3200-branch.sh: test_expect_success "branch -d still deletes a deleteMerged=false branch" '
     - 	test_must_fail git -C repo rev-parse --verify refs/heads/kept
     + 	)
       '
       
      +test_expect_success '--dry-run without --delete-merged is rejected' '

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a --forked option to "git branch" list mode that lists only branches whose configured upstream matches <branch>. The argument can be a ref (e.g. "origin/main", "master"), a remote name like "origin" for the branch its origin/HEAD points at, or a shell glob (e.g. "origin/*"), and may be repeated to widen the filter.

It is an ordinary list filter, so it combines with the others:

    git branch --merged origin/main --forked 'origin/*'

lists branches forked from origin that are already merged into origin/main, and --no-merged inverts the question.

This is the building block for --delete-merged, which deletes the listed branches once they have landed on their upstream.

---
 Documentation/git-branch.adoc |  12 +++-
 builtin/branch.c              |  18 +++++-
 ref-filter.c                  |  70 ++++++++++++++++++++
 ref-filter.h                  |  10 +++
 t/t3200-branch.sh             | 117 ++++++++++++++++++++++++++++++++++
 5 files changed, 224 insertions(+), 3 deletions(-)

index c0afddc424..b0d66a6deb 100644
@@ -13,6 +13,7 @@ git branch [--color[=<when>] | --no-color] [--show-current]
 	   [--column[=<options>] | --no-column] [--sort=<key>]
 	   [--merged [<commit>]] [--no-merged [<commit>]]
 	   [--contains [<commit>]] [--no-contains [<commit>]]
+	   [(--forked <branch>)...]
 	   [--points-at <object>] [--format=<format>]
 	   [(-r|--remotes) | (-a|--all)]
 	   [--list] [<pattern>...]

@@ -51,7 +52,8 @@ merged into the named commit (i.e. the branches whose tip commits are
 reachable from the named commit) will be listed.  With `--no-merged` only
 branches not merged into the named commit will be listed.  If the _<commit>_
 argument is missing it defaults to `HEAD` (i.e. the tip of the current
-branch).
+branch).  With `--forked`, only branches whose configured upstream matches
+the given branch or pattern will be listed.
 
 The command's second form creates a new branch head named _<branch-name>_
 which points to the current `HEAD`, or _<start-point>_ if given. As a

@@ -311,6 +313,14 @@ superproject's "origin/main", but tracks the submodule's "origin/main".
 	Only list branches whose tips are not reachable from
 	_<commit>_ (`HEAD` if not specified). Implies `--list`.
 
+`--forked <branch>`::
+	Only list branches whose configured upstream matches
+	_<branch>_. The argument can be a ref (e.g. `origin/main`,
+	`master`), a remote name like `origin` for the branch its
+	`origin/HEAD` points at, or a shell-style glob (e.g.
+	`'origin/*'`). The option can be repeated to widen the
+	filter. Implies `--list`.
+
 `--points-at <object>`::
 	Only list branches of _<object>_.
 

index 1572a4f9ef..c159f45b4c 100644
@@ -30,7 +30,7 @@
 #include "commit-reach.h"
 
 static const char * const builtin_branch_usage[] = {
-	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),
+	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged] [(--forked <branch>)...]"),
 	N_("git branch [<options>] [-f] [--recurse-submodules] <branch-name> [<start-point>]"),
 	N_("git branch [<options>] [-l] [<pattern>...]"),
 	N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."),

@@ -673,6 +673,16 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
 	free_worktrees(worktrees);
 }
 
+static int parse_opt_forked(const struct option *opt, const char *arg, int unset)
+{
+	struct ref_filter *filter = opt->value;
+
+	BUG_ON_OPT_NEG(unset);
+	if (ref_filter_forked_add(filter, arg) < 0)
+		die(_("'%s' is not a valid branch or pattern"), arg);
+	return 0;
+}
+
 static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
 
 static int edit_branch_description(const char *branch_name)

@@ -770,6 +780,9 @@ int cmd_branch(int argc,
 		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
 		OPT_MERGED(&filter, N_("print only branches that are merged")),
 		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
+		OPT_CALLBACK_F(0, "forked", &filter, N_("branch"),
+			N_("print only branches whose upstream matches <branch> (repeatable)"),
+			PARSE_OPT_NONEG, parse_opt_forked),
 		OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
 		OPT_REF_SORT(&sorting_options),
 		OPT_CALLBACK(0, "points-at", &filter.points_at, N_("object"),

@@ -815,7 +828,8 @@ int cmd_branch(int argc,
 		list = 1;
 
 	if (filter.with_commit || filter.no_commit ||
-	    filter.reachable_from || filter.unreachable_from || filter.points_at.nr)
+	    filter.reachable_from || filter.unreachable_from ||
+	    filter.points_at.nr || filter.forked.nr)
 		list = 1;
 
 	noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +

index 120221b47f..9361296e2a 100644
@@ -67,6 +67,7 @@ struct ref_filter {
 	const char **name_patterns;
 	const char *start_after;
 	struct strvec exclude;
+	struct strvec forked;
 	struct oid_array points_at;
 	struct commit_list *with_commit;
 	struct commit_list *no_commit;

@@ -110,6 +111,7 @@ struct ref_format {
 #define REF_FILTER_INIT { \
 	.points_at = OID_ARRAY_INIT, \
 	.exclude = STRVEC_INIT, \
+	.forked = STRVEC_INIT, \
 }
 #define REF_FORMAT_INIT {             \
 	.use_color = GIT_COLOR_UNKNOWN, \

@@ -172,6 +174,14 @@ void ref_sorting_release(struct ref_sorting *);
 struct ref_sorting *ref_sorting_options(struct string_list *);
 /*  Function to parse --merged and --no-merged options */
 int parse_opt_merge_filter(const struct option *opt, const char *arg, int unset);
+/*
+ * Register a --forked <branch> pattern on the filter. The argument is
+ * either a ref, which is resolved to its full refname, or a shell-style
+ * glob. Branches are kept only when their configured upstream matches
+ * one of the registered patterns. Returns -1 if the argument is not a
+ * valid ref or pattern.
+ */
+int ref_filter_forked_add(struct ref_filter *filter, const char *arg);
 /*  Get the current HEAD's description */
 char *get_head_description(void);
 /*  Set up translated strings in the output. */

gitgitgadget

From: Harald Nordgren <[email protected]>

delete_branches() takes separate force and quiet parameters, while check_branch_commit() takes force. The next commits would grow this collection further. Replace them with a single unsigned flags argument and an enum.

Test the FORCE and QUIET bits directly from flags at each use site so that mutating or forwarding flags cannot leave cached values stale.

No change in behavior.

---
 builtin/branch.c | 40 ++++++++++++++++++++++++----------------
 1 file changed, 24 insertions(+), 16 deletions(-)

index c159f45b4c..e905a13a95 100644
@@ -189,16 +189,22 @@ static int branch_merged(int kind, const char *name,
 	return merged;
 }
 
+enum delete_branch_flags {
+	DELETE_BRANCH_FORCE = (1 << 0),
+	DELETE_BRANCH_QUIET = (1 << 1),
+};
+
 static int check_branch_commit(const char *branchname, const char *refname,
 			       const struct object_id *oid, struct commit *head_rev,
-			       int kinds, int force)
+			       int kinds, unsigned int flags)
 {
 	struct commit *rev = lookup_commit_reference(the_repository, oid);
-	if (!force && !rev) {
+	if (!(flags & DELETE_BRANCH_FORCE) && !rev) {
 		error(_("couldn't look up commit object for '%s'"), refname);
 		return -1;
 	}
-	if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
+	if (!(flags & DELETE_BRANCH_FORCE) &&
+	    !branch_merged(kinds, branchname, rev, head_rev)) {
 		error(_("the branch '%s' is not fully merged"), branchname);
 		advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
 				  _("If you are sure you want to delete it, "

@@ -217,8 +223,8 @@ static void delete_branch_config(const char *branchname)
 	strbuf_release(&buf);
 }
 
-static int delete_branches(int argc, const char **argv, int force, int kinds,
-			   int quiet)
+static int delete_branches(int argc, const char **argv, int kinds,
+			   unsigned int flags)
 {
 	struct commit *head_rev = NULL;
 	struct object_id oid;

@@ -241,7 +247,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 		remote_branch = 1;
 		allowed_interpret = INTERPRET_BRANCH_REMOTE;
 
-		force = 1;
+		flags |= DELETE_BRANCH_FORCE;
 		break;
 	case FILTER_REFS_BRANCHES:
 		fmt = "refs/heads/%s";

@@ -252,12 +258,12 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 	}
 	branch_name_pos = strcspn(fmt, "%");
 
-	if (!force)
+	if (!(flags & DELETE_BRANCH_FORCE))
 		head_rev = lookup_commit_reference(the_repository, &head_oid);
 
 	for (i = 0; i < argc; i++, strbuf_reset(&bname)) {
 		char *target = NULL;
-		int flags = 0;
+		int ref_flags = 0;
 
 		copy_branchname(&bname, argv[i], allowed_interpret);
 		free(name);

@@ -279,7 +285,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 					     RESOLVE_REF_READING
 					     | RESOLVE_REF_NO_RECURSE
 					     | RESOLVE_REF_ALLOW_BAD_NAME,
-					     &oid, &flags);
+					     &oid, &ref_flags);
 		if (!target) {
 			if (remote_branch) {
 				error(_("remote-tracking branch '%s' not found"), bname.buf);

@@ -291,7 +297,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 									   | RESOLVE_REF_NO_RECURSE
 									   | RESOLVE_REF_ALLOW_BAD_NAME,
 									   &oid,
-									   &flags);
+									   &ref_flags);
 				FREE_AND_NULL(virtual_name);
 
 				if (virtual_target)

@@ -306,16 +312,16 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 			continue;
 		}
 
-		if (!(flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
+		if (!(ref_flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
 		    check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
-					force)) {
+					flags)) {
 			ret = 1;
 			goto next;
 		}
 
 		item = string_list_append(&refs_to_delete, name);
-		item->util = xstrdup((flags & REF_ISBROKEN) ? "broken"
-				    : (flags & REF_ISSYMREF) ? target
+		item->util = xstrdup((ref_flags & REF_ISBROKEN) ? "broken"
+				    : (ref_flags & REF_ISSYMREF) ? target
 				    : repo_find_unique_abbrev(the_repository, &oid, DEFAULT_ABBREV));
 
 	next:

@@ -330,7 +336,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 		char *name = item->string;
 		if (!refs_ref_exists(get_main_ref_store(the_repository), name)) {
 			char *refname = name + branch_name_pos;
-			if (!quiet)
+			if (!(flags & DELETE_BRANCH_QUIET))
 				printf(remote_branch
 					? _("Deleted remote-tracking branch %s (was %s).\n")
 					: _("Deleted branch %s (was %s).\n"),

@@ -872,7 +878,9 @@ int cmd_branch(int argc,
 	if (delete) {
 		if (!argc)
 			die(_("branch name required"));
-		ret = delete_branches(argc, argv, delete > 1, filter.kind, quiet);
+		ret = delete_branches(argc, argv, filter.kind,
+				      (delete > 1 ? DELETE_BRANCH_FORCE : 0) |
+				      (quiet ? DELETE_BRANCH_QUIET : 0));
 		goto out;
 	} else if (show_current) {
 		print_current_branch_name();

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a skip-unmerged mode to delete_branches() and check_branch_commit() so a bulk caller can silently skip branches that are not fully merged and carry on, rather than erroring with the "use 'git branch -D'" advice that the plain "git branch -d" path emits. Existing callers are unaffected.

---
 builtin/branch.c | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

index e905a13a95..568ae817d6 100644
@@ -192,6 +192,7 @@ static int branch_merged(int kind, const char *name,
 enum delete_branch_flags {
 	DELETE_BRANCH_FORCE = (1 << 0),
 	DELETE_BRANCH_QUIET = (1 << 1),
+	DELETE_BRANCH_SKIP_UNMERGED = (1 << 2),
 };
 
 static int check_branch_commit(const char *branchname, const char *refname,

@@ -205,10 +206,13 @@ static int check_branch_commit(const char *branchname, const char *refname,
 	}
 	if (!(flags & DELETE_BRANCH_FORCE) &&
 	    !branch_merged(kinds, branchname, rev, head_rev)) {
-		error(_("the branch '%s' is not fully merged"), branchname);
-		advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
-				  _("If you are sure you want to delete it, "
-				  "run 'git branch -D %s'"), branchname);
+		if (!(flags & DELETE_BRANCH_SKIP_UNMERGED)) {
+			error(_("the branch '%s' is not fully merged"),
+			      branchname);
+			advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
+					  _("If you are sure you want to delete it, "
+					  "run 'git branch -D %s'"), branchname);
+		}
 		return -1;
 	}
 	return 0;

@@ -315,7 +319,8 @@ static int delete_branches(int argc, const char **argv, int kinds,
 		if (!(ref_flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
 		    check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
 					flags)) {
-			ret = 1;
+			if (!(flags & DELETE_BRANCH_SKIP_UNMERGED))
+				ret = 1;
 			goto next;
 		}
 

gitgitgadget

From: Harald Nordgren <[email protected]>

Teach delete_branches() a new mode for the upcoming --delete-merged caller that checks whether a branch is merged into its upstream without falling back to HEAD when there is no upstream. Existing callers keep their current behavior.

---
 builtin/branch.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

index 568ae817d6..23b2b7107c 100644
@@ -168,10 +168,13 @@ static int branch_merged(int kind, const char *name,
 	 * upstream, if any, otherwise with HEAD", we should just
 	 * return the result of the repo_in_merge_bases() above without
 	 * any of the following code, but during the transition period,
-	 * a gentle reminder is in order.
+	 * a gentle reminder is in order.  Callers that opt out of the
+	 * HEAD fallback by passing head_rev=NULL are not interested in
+	 * the reminder either: they have already established that the
+	 * branch has an upstream, so HEAD is irrelevant to the decision.
 	 */
-	if (head_rev != reference_rev) {
-		int expect = head_rev ? repo_in_merge_bases(the_repository, rev, head_rev) : 0;
+	if (head_rev && head_rev != reference_rev) {
+		int expect = repo_in_merge_bases(the_repository, rev, head_rev);
 		if (expect < 0)
 			exit(128);
 		if (expect == merged)

@@ -193,6 +196,7 @@ enum delete_branch_flags {
 	DELETE_BRANCH_FORCE = (1 << 0),
 	DELETE_BRANCH_QUIET = (1 << 1),
 	DELETE_BRANCH_SKIP_UNMERGED = (1 << 2),
+	DELETE_BRANCH_NO_HEAD_FALLBACK = (1 << 3),
 };
 
 static int check_branch_commit(const char *branchname, const char *refname,

@@ -262,7 +266,8 @@ static int delete_branches(int argc, const char **argv, int kinds,
 	}
 	branch_name_pos = strcspn(fmt, "%");
 
-	if (!(flags & DELETE_BRANCH_FORCE))
+	if (!(flags & DELETE_BRANCH_FORCE) &&
+	    !(flags & DELETE_BRANCH_NO_HEAD_FALLBACK))
 		head_rev = lookup_commit_reference(the_repository, &head_oid);
 
 	for (i = 0; i < argc; i++, strbuf_reset(&bname)) {

gitgitgadget

From: Harald Nordgren <[email protected]>

    git branch (--delete-merged <branch>)... [<pattern>...]

deletes local branches matching the optional patterns when their configured upstream matches one of the --delete-merged arguments and their tip is reachable from that upstream. The work has already landed on the upstream they track, so the local copy is no longer needed.

The option can be repeated to widen the upstream match. Keeping the candidate patterns as positional arguments lets users bound the set of local branches that may be deleted independently of the upstream selection.

A branch is not deleted when:

* it is checked out in any worktree
* its configured upstream ref no longer exists, since a missing upstream is not by itself a sign of integration
* pushing it by name to the remote configured by branch.<name>.remote would update its upstream, as determined by mapping the branch ref through that remote's fetch refspec. For example, a local "main" that tracks "origin/main" is kept even when remote.pushDefault names a fork. Right after a pull it merely looks fully merged.

A branch whose work is not yet merged into its upstream is silently skipped, so one unmerged topic does not abort the whole sweep.

A branch that another, surviving branch tracks as its upstream is also kept, so a branch is never deleted out from under one stacked on top of it. Such a kept branch is itself merged, so when its own upstream is being deleted, clear its now-stale upstream config.

---
 Documentation/git-branch.adoc |  31 +++++++
 builtin/branch.c              | 164 ++++++++++++++++++++++++++++++++-
 t/t3200-branch.sh             | 166 ++++++++++++++++++++++++++++++++++
 3 files changed, 359 insertions(+), 2 deletions(-)

index b0d66a6deb..cee3904cfd 100644
@@ -25,6 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
 git branch (-c|-C) [<old-branch>] <new-branch>
 git branch (-d|-D) [-r] <branch-name>...
 git branch --edit-description [<branch-name>]
+git branch (--delete-merged <branch>)... [<pattern>...]
 
 DESCRIPTION
 -----------

@@ -201,6 +202,36 @@ This option is only applicable in non-verbose mode.
 	Print the name of the current branch. In detached `HEAD` state,
 	nothing is printed.
 
+`--delete-merged <branch>`::
+	Delete local branches whose configured upstream matches
+	_<branch>_, but only when their tip is reachable from that
+	upstream. In other words, the work on the branch has already
+	landed on the upstream it tracks, so the local copy is no longer
+	needed. The option can be repeated to widen the upstream match.
+	Optional _<pattern>_ arguments limit which local branches are
+	considered, e.g. `git branch --delete-merged 'origin/*'
+	'topic-*'`.
++
+A branch is not deleted when:
++
+--
+* its configured upstream ref no longer exists,
+* it is checked out in any worktree, or
+* pushing it by name to the remote configured by
+  `branch.<name>.remote` would update its upstream, so it cannot be
+  distinguished from a branch that just looks "fully merged" right
+  after a pull.
+--
++
+A branch whose work has not yet been merged into its upstream is
+silently skipped. Delete it with `git branch -D` if you want to
+remove it anyway.
++
+A branch that another, surviving branch tracks as its upstream is
+kept, so a branch is never deleted out from under one stacked on top
+of it. If that kept branch in turn tracks a branch that is being
+deleted, its now-stale upstream configuration is cleared.
+
 `-v`::
 `-vv`::
 `--verbose`::

gitgitgadget

I think I can fix this with

```
    -+  if (strset_contains(data->deletable, ref->name))
    ++  if (strset_contains(data->deletable, ref->name) ||
    ++      strset_contains(data->spared, ref->name))
```

I used your example to write a test about it as well.

Harald

I do not claim that the single example I gave covers all the issues that arise from failing to analyze the dependency graph, or from attempting to solve the problem sequentially, which makes the solution depend on the order in which branches are visited.

I have a suspicion that it may be unavoidable to employ a multi-pass approach that iteratively identifies all branches transitively needed by any surviving branch, though that is merely a hunch, unsupported by any proof.

Thanks.

I think it would certainly be easier to reason about if we did not mutate data->deletable in spare_stacked_base() in removed the spared branches with

	strset_for_each_entry(&spared, &iter, entry)
		strset_remove(&deletable, entry);

after the call to refs_for_each_branch_ref() returns in spare_stacked_branches().

I'll try and have a proper look at this iteration in the comming week.

Thanks

Phillip

From: Harald Nordgren <[email protected]>

Setting branch.<name>.deleteMerged=false exempts that branch from "git branch --delete-merged", which is useful for a topic you want to keep developing after an early round of it has been merged upstream. Unless --quiet is given, each skip is reported so the user knows why their topic was kept.

Explicit deletion with "git branch -d" still uses the normal merge check and ignores this setting.

---
 Documentation/config/branch.adoc |  7 +++++++
 Documentation/git-branch.adoc    |  5 +++--
 builtin/branch.c                 | 14 +++++++++++++
 t/t3200-branch.sh                | 36 ++++++++++++++++++++++++++++++++
 4 files changed, 60 insertions(+), 2 deletions(-)

index a4db9fa5c8..d8483acb4f 100644
@@ -102,3 +102,10 @@ for details).
 	`git branch --edit-description`. Branch description is
 	automatically added to the `format-patch` cover letter or
 	`request-pull` summary.
+
+`branch.<name>.deleteMerged`::
+	If set to `false`, branch _<name>_ is exempt from
+	`git branch --delete-merged`.  Useful for a topic branch you
+	intend to develop further after an initial round has been
+	merged upstream.  Defaults to true.  Explicit deletion via
+	`git branch -d` is unaffected.

index cee3904cfd..ffb39811ab 100644
@@ -216,11 +216,12 @@ A branch is not deleted when:
 +
 --
 * its configured upstream ref no longer exists,
-* it is checked out in any worktree, or
+* it is checked out in any worktree,
 * pushing it by name to the remote configured by
   `branch.<name>.remote` would update its upstream, so it cannot be
   distinguished from a branch that just looks "fully merged" right
-  after a pull.
+  after a pull, or
+* `branch.<name>.deleteMerged` is set to `false`.
 --
 +
 A branch whose work has not yet been merged into its upstream is

index 8ce8840fa7..61f414b3c7 100644
@@ -791,6 +791,7 @@ static int delete_merged_branches(const struct strvec *upstreams,
 	struct ref_array candidates = { 0 };
 	struct strset deletable = STRSET_INIT;
 	struct strvec to_delete = STRVEC_INIT;
+	struct strbuf key = STRBUF_INIT;
 	struct hashmap_iter iter;
 	struct strmap_entry *entry;
 	size_t i;

@@ -810,6 +811,7 @@ static int delete_merged_branches(const struct strvec *upstreams,
 		const char *short_name;
 		struct branch *branch;
 		const char *upstream;
+		int opt_out;
 
 		if (!skip_prefix(full_name, "refs/heads/", &short_name))
 			BUG("filter returned non-branch ref '%s'", full_name);

@@ -827,6 +829,17 @@ static int delete_merged_branches(const struct strvec *upstreams,
 					FILTER_REFS_BRANCHES, DELETE_BRANCH_SKIP_UNMERGED))
 			continue;
 
+		strbuf_reset(&key);
+		strbuf_addf(&key, "branch.%s.deletemerged", short_name);
+		if (!repo_config_get_bool(the_repository, key.buf, &opt_out) &&
+		    !opt_out) {
+			if (!(flags & DELETE_BRANCH_QUIET))
+				fprintf(stderr,
+					_("Skipping '%s' (branch.%s.deleteMerged is false)\n"),
+					short_name, short_name);
+			continue;
+		}
+
 		strset_add(&deletable, short_name);
 	}
 

@@ -842,6 +855,7 @@ static int delete_merged_branches(const struct strvec *upstreams,
 				      DELETE_BRANCH_NO_HEAD_FALLBACK |
 				      flags);
 
+	strbuf_release(&key);
 	strvec_clear(&to_delete);
 	strset_clear(&deletable);
 	ref_array_clear(&candidates);

index fa8a60c9e7..54292bfbdf 100755
@@ -2000,4 +2000,40 @@ test_expect_success '--delete-merged requires a value' '
 	test_must_fail git -C forked branch --delete-merged 2>err &&
 	test_grep "requires a value" err
 '
+
+test_expect_success '--delete-merged honours branch.<name>.deleteMerged=false' '
+	setup_repo_for_delete_merged &&
+	create_merged_branch deleted &&
+	create_merged_branch kept &&
+	(
+		cd repo &&
+		git config branch.kept.deleteMerged false &&
+		git checkout --detach &&
+
+		git branch --delete-merged origin/next 2>err &&
+
+		test_grep "Skipping .kept." err &&
+		check_branches <<-\EOF
+		kept
+		main
+		EOF
+	)
+'
+
+test_expect_success "branch -d still deletes a deleteMerged=false branch" '
+	setup_repo_for_delete_merged &&
+	create_merged_branch kept &&
+	(
+		cd repo &&
+		git config branch.kept.deleteMerged false &&
+		git checkout --detach &&
+
+		git branch -d kept &&
+
+		check_branches <<-\EOF
+		main
+		EOF
+	)
+'
+
 test_done

gitgitgadget

From: Harald Nordgren <[email protected]>

"git branch --dry-run --delete-merged ..." prints one line per ref that would be deleted without modifying refs or branch configuration.

--dry-run is only meaningful together with --delete-merged and is rejected otherwise.

---
 Documentation/git-branch.adoc |  8 +++++-
 builtin/branch.c              | 54 +++++++++++++++++++++++------------
 t/t3200-branch.sh             | 35 ++++++++++++++++++++++-
 3 files changed, 77 insertions(+), 20 deletions(-)

index ffb39811ab..633031f248 100644
@@ -25,7 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
 git branch (-c|-C) [<old-branch>] <new-branch>
 git branch (-d|-D) [-r] <branch-name>...
 git branch --edit-description [<branch-name>]
-git branch (--delete-merged <branch>)... [<pattern>...]
+git branch [--dry-run] (--delete-merged <branch>)... [<pattern>...]
 
 DESCRIPTION
 -----------

@@ -233,6 +233,12 @@ kept, so a branch is never deleted out from under one stacked on top
 of it. If that kept branch in turn tracks a branch that is being
 deleted, its now-stale upstream configuration is cleared.
 
+`--dry-run`::
+	With `--delete-merged`, print which branches would be
+	deleted and exit without touching any ref.  Useful for
+	sanity-checking a wide pattern like `'origin/*'` before
+	committing to the deletion.
+
 `-v`::
 `-vv`::
 `--verbose`::

index 54292bfbdf..c055bc8287 100755
@@ -1900,6 +1900,19 @@ test_expect_success '--delete-merged deletes only selected merged branches' '
 		git checkout -b tracks-other other/main --track &&
 		sha=$(git rev-parse --short merged) &&
 
+		git branch --dry-run --delete-merged origin/next merged >actual 2>&1 &&
+		echo "Would delete branch merged (was $sha)." >expect &&
+		test_cmp expect actual &&
+		git rev-parse --verify refs/heads/merged &&
+
+		check_branches <<-\EOF &&
+		also-merged
+		main
+		merged
+		tracks-other
+		unmerged
+		EOF
+
 		git branch --delete-merged origin/next merged >actual 2>&1 &&
 		echo "Deleted branch merged (was $sha)." >expect &&
 		test_cmp expect actual &&

@@ -1948,9 +1961,12 @@ test_expect_success '--delete-merged keeps the upstream of a surviving branch' '
 		git checkout -b topic feature --track &&
 		git commit --allow-empty -m "topic work" &&
 
-		git branch --delete-merged origin/next 2>err &&
+		git branch --dry-run --delete-merged origin/next >out &&
+		test_grep ! "feature" out &&
 
+		git branch --delete-merged origin/next 2>err &&
 		test_must_be_empty err &&
+
 		check_branches <<-\EOF &&
 		feature
 		main

@@ -1978,6 +1994,18 @@ test_expect_success '--delete-merged clears the deleted upstream of a spared bra
 		git checkout -b tip mid --track &&
 		git commit --allow-empty -m "tip work" &&
 
+		git branch --dry-run --delete-merged origin/next \
+			--delete-merged lower &&
+
+		git config --local --get-regexp "branch\\.(mid|tip)\\.(merge|remote)" >actual &&
+		cat >expect <<-\EOF &&
+		branch.mid.remote .
+		branch.mid.merge refs/heads/lower
+		branch.tip.remote .
+		branch.tip.merge refs/heads/mid
+		EOF
+		test_cmp expect actual &&
+
 		git branch --delete-merged origin/next \
 			--delete-merged lower &&
 

@@ -2036,4 +2064,9 @@ test_expect_success "branch -d still deletes a deleteMerged=false branch" '
 	)
 '
 
+test_expect_success '--dry-run without --delete-merged is rejected' '
+	test_must_fail git -C forked branch --dry-run 2>err &&
+	test_grep "requires --delete-merged" err
+'
+
 test_done

gitgitgadget

Delete branches that have already been merged on upstream.

Changes in v20:

* Protect branches transitively required by a surviving local upstream stack. Traverse upstream chains once and defer delete-set mutation until traversal completes.
* Make stacked-branch handling independent of ref iteration order and update the documentation accordingly.
* Clarify variable names with regards to branch names (short) to reduce confusion.

Changes in v19:

* Fix bug where dry-run would still remove config, added test coverage.
* Redesigned --delete-merged as a repeatable upstream selector with optional positional patterns limiting deletion scope.
* Protect same-name upstream branches independently of push-default configuration.
* Simplified flags handling where local caching became complicated when mutating values.
* Clarified assertions in tests.

Changes in v18:

* Instead of keeping the whole chain of upstream branches, keep only the ones an unmerged branch still needs. When a kept (merged) branch in turn tracks a branch that is being deleted, clear its now-stale upstream config.
* Rework spare_stacked_bases() to record the kept bases and, in a second pass, clear the upstream of any whose own base is going away. Build the to-delete list with strset_for_each_entry() instead of re-walking the candidate array.

Changes in v17:

* Keep a merged branch when another surviving branch still tracks it as its upstream, so --delete-merged no longer deletes a branch out from under one stacked on top of it.
* Move the --dry-run and branch.<name>.deleteMerged opt-out fully into their own commits.

Changes in v16:

* Convert delete_merged_branches() to take an unsigned int flags argument instead of separate quiet/dry_run booleans, matching delete_branches()
* Reuse the strbuf across the skip-config loop (strbuf_reset per iteration, single strbuf_release after) instead of allocating and freeing it each time
* Rewrite the --delete-merged tests as integration tests: branches that land commits upstream, with deletion and the checked-out, upstream-gone, and push-equals-upstream safety cases exercised together in one run and output asserted via test_cmp
* Collapse the many per-aspect test repos into a single reused repo set up by a setup_repo_for_delete_merged helper, and rename helpers off the old pm_/prune naming
* Nest single-repo setup sequences in ( cd ... ) subshells instead of prefixing every command with -C

Changes in v15:

* Renamed --prune-merged to --delete-merged throughout. Not necessarily final, but something to advance the discussion.
* --delete-merged now silently skips not-yet-merged branches instead of warning.
* Initialized the delete_branches() flag locals where declared. Only force stays deferred.
* delete_branches()/check_branch_commit() doc and code cleanups: redundant branch NULL checks dropped, ref_array candidates = { 0 }, a BUG() for the unreachable non-branch ref, and reworked --delete-merged doc wording.
* Broadened the --forked tests (local commits for realism, remote add -f, --forked coverage), renamed the misleading trunk fixture, and replaced the misnamed detached branch with git checkout --detach.

Changes in v14:

* Fixed a git branch -d -r regression (broke t5404/t5505/t5514): the remotes path set a local force but not the DELETE_BRANCH_FORCE bit that check_branch_commit() reads, so it wrongly ran the merge check.
* Made flags the single source of truth in delete_branches() so the bit and the derived locals can't disagree.
* Works locally, but GitHub CI has problems that are there for other branches too, hopefully not related
(https://github.com/git/git/pull/2285).

Changes in v13:

* Reworked --forked into a real ref-filter applied in apply_ref_filter() instead of a post-pass, so non-matching branches are never allocated.
* Match exact --forked patterns on full refnames (only globs use the abbreviated upstream), and dropped the old helper machinery, forward declaration, and string_list in favor of a strvec.
* Replaced the boolean parameters of delete_branches()/check_branch_commit() with a single unsigned int flags.
* --prune-merged now collects candidates via filter_refs() rather than its own branch walk.
* --prune-merged now takes its patterns as positional arguments (e.g. git branch --prune-merged origin/main 'feature*') instead of repeating the option.

Changes in v12:

* Reworked --forked from a standalone action into a --list-mode filter.
* Switched --forked and --prune-merged to repeatable OPT_STRING_LIST options.
* Dropped the bare-remote-name resolution for --forked, the argument is now a ref or a glob.

Changes in v11:

* The flags now take a branch, not a remote. --forked and --prune-merged accept a literal upstream short name like origin/main or a wildmatch pattern like origin/. The old --all-remotes flag is gone, since origin/ covers that case.
* The prune guard now compares @{push} against @{upstream}. A branch is spared when these are equal. That is the trunk like case, such as local main tracking and pushing to origin/main, where "fully merged to upstream" cannot be told apart from "just pulled". Only branches that push somewhere other than their upstream, typically fork based topics, are candidates. The earlier /HEAD by name guard that the reviewer rejected is gone.
* New --dry-run for --prune-merged.

Changes in v10:

* --forked / --prune-merged now take a branch glob instead of a remote name — origin, origin/*, origin/release-- all work. This replaces the remote-only form and subsumes the old --all-remotes flag, which has been dropped.
* New --dry-run for --prune-merged.

Changes in v9:

* --force no longer has special meaning with --prune-merged; reachability is always enforced. Use git branch -D to delete an unmerged branch. Matches how git branch's other read/safe actions treat --force.
* Synopsis drops [-f]; "not fully merged" hint points at git branch -D.
* Dropped the --prune-merged --force tests.

Changes in v8:

* Delete only when the branch's work is actually reachable from its upstream
* Skip branches whose upstream is gone (even with --force)
* Simplified the internal safety flag to live in one place

Changes in v7:

* --prune-merged now checks if a branch is merged into its own upstream first. If the upstream is gone, it checks against the remote's default branch instead. If neither exists, the branch is refused (use --force to delete anyway).

Changes in v6:

* --prune-merged now measures merged-ness against the remote's default branch instead of the candidate's upstream — so the decision no longer depends on which branch happens to be checked out locally.
* delete_branches() / check_branch_commit() gained a per-candidate override that lets a caller substitute a different "what counts as merged" reference (or skip the check). branch -d callers pass NULL and keep their existing semantics.
* prune_merged_branches() resolves each candidate's push-remote HEAD and threads it through, so --prune-merged --all-remotes measures each candidate against its own remote rather than a single global reference.

Changes in v5:

* Drop commit 'fetch: add --prune-merged'

Changes in v4:

* Resolve each remote's HEAD and collect the targets into a protected_default_refs set in collect_forked_set.
* In prune_merged_branches, skip a candidate when its upstream is a protected default ref and the local branch name matches the default branch's leaf name (so a local main tracking origin/main is spared, but a renamed trunk tracking origin/main is not).
* Also skip when the candidate's push ref points at a protected default ref, so a topic branch configured to push to origin/main is never pruned.
* Tests: spare the local default branch; only protect by matching leaf name (not by upstream alone); spare a branch whose push ref is the remote default.

Changes in v3:

* s/remote-tracking refs/remote-tracking branches/g

Changes in v2:

* The whole feature moved out of git fetch and into git branch. git fetch --prune-merged now just calls git branch --prune-merged after fetching.
* The fetch.pruneLocalBranches and remote..pruneLocalBranches config options are gone, replaced by per-branch opt-out via branch..pruneMerged.
* New git branch --forked lists local branches whose upstream lives on the given remote (read-only building block).
* New git branch --prune-merged deletes those branches, but only if their tip is reachable from the upstream tracking ref; --force skips that safety check.
* New git branch --all-remotes lets --forked/--prune-merged operate across every configured remote at once.
* The currently checked-out branch in any worktree is always preserved.
* branch..pruneMerged=false lets you exempt a branch (e.g. a long-running topic branch) even with --force; doesn't affect explicit git branch -d.
* delete_branches() got a warn_only mode so bulk deletion prints a one-line warning per skipped branch instead of the noisy four-line hint that git branch -d shows.
* New section in git-branch docs; git-fetch docs trimmed to just mention --prune-merged.
* New tests in t3200-branch.sh for the new branch flags; t5510-fetch.sh shrunk since most logic moved.

Harald Nordgren (7):
branch: add --forked filter for --list mode
branch: convert delete_branches() to a flags argument
branch: let delete_branches skip unmerged branches on bulk refusal
branch: prepare delete_branches for a bulk caller
branch: add --delete-merged <branch>
branch: add branch.<name>.deleteMerged opt-out
branch: add --dry-run for --delete-merged

 Documentation/config/branch.adoc |   7 +
 Documentation/git-branch.adoc    |  49 +++-
 builtin/branch.c                 | 276 +++++++++++++++++++---
 ref-filter.c                     |  70 ++++++
 ref-filter.h                     |  10 +
 t/t3200-branch.sh                | 393 +++++++++++++++++++++++++++++++
 6 files changed, 774 insertions(+), 31 deletions(-)

base-commit: 5d2e7709234afea1b6ddb25cd4f60d3d5fb3c200
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2285%2FHaraldNordgren%2Ffetch-prune-local-branches-v20
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2285/HaraldNordgren/fetch-prune-local-branches-v20
Pull-Request: https://github.com/git/git/pull/2285

Range-diff vs v19:

 1:  562648132d = 1:  51c1c9d075 branch: add --forked filter for --list mode
 2:  c7ebd9344c = 2:  711574b2e5 branch: convert delete_branches() to a flags argument
 3:  0c4f3358e3 = 3:  47c5975dc7 branch: let delete_branches skip unmerged branches on bulk refusal
 4:  64a202526a = 4:  46268acec5 branch: prepare delete_branches for a bulk caller
 5:  a6caa5b397 ! 5:  ef9f57e735 branch: add --delete-merged <branch>
     @@ Commit message
          A branch whose work is not yet merged into its upstream is silently
          skipped, so one unmerged topic does not abort the whole sweep.
      
     -    A branch that another, surviving branch tracks as its upstream is
     -    also kept, so a branch is never deleted out from under one stacked
     -    on top of it. Such a kept branch is itself merged, so when its own
     -    upstream is being deleted, clear its now-stale upstream config.
     +    A branch that a surviving branch depends on through a chain of local
     +    upstreams is also kept, so no branch is deleted out from under stacked
     +    work. Collect this transitive set without changing the candidate set
     +    during ref iteration: walk upstream chains from surviving branches,
     +    visit each branch at most once, and remove the collected bases only
     +    after the iteration completes. This makes the result independent of
     +    ref iteration order without repeated full scans.
      
          Signed-off-by: Harald Nordgren <[email protected]>
      
     @@ Documentation/git-branch.adoc: This option is only applicable in non-verbose mod
      +silently skipped. Delete it with `git branch -D` if you want to
      +remove it anyway.
      ++
     -+A branch that another, surviving branch tracks as its upstream is
     -+kept, so a branch is never deleted out from under one stacked on top
     -+of it. If that kept branch in turn tracks a branch that is being
     -+deleted, its now-stale upstream configuration is cleared.
     ++A branch that a surviving branch depends on through a chain of local
     ++upstreams is kept, so a branch is never deleted out from under stacked
     ++work.
      +
       `-v`::
       `-vv`::
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
       	return 0;
       }
       
     -+struct spare_data {
     -+	struct strset *deletable;
     -+	struct strset *spared;
     ++struct stacked_branch_data {
     ++	struct strset *deletable_branch_names;
     ++	struct strset *protected_branch_names;
     ++	struct strset *visited_branch_names;
      +};
      +
     -+/*
     -+ * A surviving branch stacked on a deletion candidate would lose its
     -+ * upstream, so drop that candidate from the delete set and remember it
     -+ * in "spared" so its own upstream can be tidied up afterwards.
     -+ */
     -+static int spare_stacked_base(const struct reference *ref, void *cb_data)
     ++static int collect_stacked_branch_bases(const struct reference *ref,
     ++					void *cb_data)
      +{
     -+	struct spare_data *data = cb_data;
     -+	struct branch *branch;
     -+	const char *upstream, *up_short;
     ++	struct stacked_branch_data *data = cb_data;
     ++	const char *branch_name;
      +
     -+	if (strset_contains(data->deletable, ref->name))
     -+		return 0;
     -+	branch = branch_get(ref->name);
     -+	upstream = branch_get_upstream(branch, NULL);
     -+	if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     -+	    !strset_contains(data->deletable, up_short))
     ++	if (!skip_prefix(ref->name, "refs/heads/", &branch_name))
     ++		BUG("expected local branch ref, got '%s'", ref->name);
     ++	if (strset_contains(data->deletable_branch_names, branch_name))
      +		return 0;
      +
     -+	strset_remove(data->deletable, up_short);
     -+	strset_add(data->spared, up_short);
     ++	while (strset_add(data->visited_branch_names, branch_name)) {
     ++		struct branch *branch = branch_get(branch_name);
     ++		const char *upstream_refname = branch_get_upstream(branch, NULL);
     ++		const char *upstream_branch_name;
     ++
     ++		if (!upstream_refname ||
     ++		    !skip_prefix(upstream_refname, "refs/heads/",
     ++				 &upstream_branch_name) ||
     ++		    !strset_contains(data->deletable_branch_names,
     ++				    upstream_branch_name))
     ++			break;
     ++
     ++		strset_add(data->protected_branch_names, upstream_branch_name);
     ++		branch_name = upstream_branch_name;
     ++	}
     ++
      +	return 0;
      +}
      +
     -+/*
     -+ * Keep any branch that a surviving branch tracks as its upstream, so we
     -+ * never delete a branch out from under one stacked on top of it.  Such a
     -+ * base is itself merged, so when its own upstream is also going away
     -+ * (no surviving branch tracks it), clear the base's now-stale upstream.
     -+ */
     -+static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable)
     ++static void protect_stacked_branch_bases(struct ref_store *refs,
     ++					 struct strset *deletable_branch_names)
      +{
     -+	struct strset spared = STRSET_INIT;
     -+	struct spare_data data = { .deletable = deletable, .spared = &spared };
     -+	struct strbuf key = STRBUF_INIT;
     ++	struct strset protected_branch_names = STRSET_INIT;
     ++	struct strset visited_branch_names = STRSET_INIT;
     ++	struct stacked_branch_data data = {
     ++		.deletable_branch_names = deletable_branch_names,
     ++		.protected_branch_names = &protected_branch_names,
     ++		.visited_branch_names = &visited_branch_names,
     ++	};
     ++	struct refs_for_each_ref_options opts = {
     ++		.prefix = "refs/heads/",
     ++	};
      +	struct hashmap_iter iter;
      +	struct strmap_entry *entry;
      +
     -+	refs_for_each_branch_ref(refs, spare_stacked_base, &data);
     -+
     -+	strset_for_each_entry(&spared, &iter, entry) {
     -+		struct branch *branch = branch_get(entry->key);
     -+		const char *upstream = branch_get_upstream(branch, NULL);
     -+		const char *up_short;
     -+
     -+		if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     -+		    !strset_contains(deletable, up_short))
     -+			continue;
     ++	refs_for_each_ref_ext(refs, collect_stacked_branch_bases, &data, &opts);
      +
     -+		strbuf_reset(&key);
     -+		strbuf_addf(&key, "branch.%s.merge", branch->name);
     -+		repo_config_set_gently(the_repository, key.buf, NULL);
     -+		strbuf_reset(&key);
     -+		strbuf_addf(&key, "branch.%s.remote", branch->name);
     -+		repo_config_set_gently(the_repository, key.buf, NULL);
     -+	}
     ++	strset_for_each_entry(&protected_branch_names, &iter, entry)
     ++		strset_remove(deletable_branch_names, entry->key);
      +
     -+	strbuf_release(&key);
     -+	strset_clear(&spared);
     ++	strset_clear(&visited_branch_names);
     ++	strset_clear(&protected_branch_names);
      +}
      +
      +static int branch_pushes_to_upstream(struct branch *branch,
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
      +	struct ref_store *refs = get_main_ref_store(the_repository);
      +	struct ref_filter filter = REF_FILTER_INIT;
      +	struct ref_array candidates = { 0 };
     -+	struct strset deletable = STRSET_INIT;
     -+	struct strvec to_delete = STRVEC_INIT;
     ++	struct strset deletable_branch_names = STRSET_INIT;
     ++	struct strvec branches_to_delete = STRVEC_INIT;
      +	struct hashmap_iter iter;
      +	struct strmap_entry *entry;
      +	size_t i;
     @@ builtin/branch.c: static int parse_opt_forked(const struct option *opt, const ch
      +	filter_refs(&candidates, &filter, filter.kind);
      +
      +	for (i = 0; i < (size_t)candidates.nr; i++) {
     -+		const char *full_name = candidates.items[i]->refname;
     -+		const char *short_name;
     ++		const char *branch_refname = candidates.items[i]->refname;
     ++		const char *branch_name;
      +		struct branch *branch;
     -+		const char *upstream;
     ++		const char *upstream_refname;
      +
     -+		if (!skip_prefix(full_name, "refs/heads/", &short_name))
     -+			BUG("filter returned non-branch ref '%s'", full_name);
     -+		if (branch_checked_out(full_name))
     ++		if (!skip_prefix(branch_refname, "refs/heads/", &branch_name))
     ++			BUG("filter returned non-branch ref '%s'", branch_refname);
     ++		if (branch_checked_out(branch_refname))
      +			continue;
      +
     -+		branch = branch_get(short_name);
     -+		upstream = branch_get_upstream(branch, NULL);
     -+		if (!upstream || !refs_ref_exists(refs, upstream))
     ++		branch = branch_get(branch_name);
     ++		upstream_refname = branch_get_upstream(branch, NULL);
     ++		if (!upstream_refname || !refs_ref_exists(refs, upstream_refname))
      +			continue;
     -+		if (branch_pushes_to_upstream(branch, upstream))
     ++		if (branch_pushes_to_upstream(branch, upstream_refname))
      +			continue;
     -+		if (check_branch_commit(short_name, short_name,
     ++		if (check_branch_commit(branch_name, branch_name,
      +					&candidates.items[i]->objectname, NULL,
      +					FILTER_REFS_BRANCHES, DELETE_BRANCH_SKIP_UNMERGED))
      +			continue;
      +
     -+		strset_add(&deletable, short_name);
     ++		strset_add(&deletable_branch_names, branch_name);
      +	}
      +
     -+	spare_stacked_bases(refs, &deletable);
     ++	protect_stacked_branch_bases(refs, &deletable_branch_names);
      +
     -+	strset_for_each_entry(&deletable, &iter, entry)
     -+		strvec_push(&to_delete, entry->key);
     ++	strset_for_each_entry(&deletable_branch_names, &iter, entry)
     ++		strvec_push(&branches_to_delete, entry->key);
      +
     -+	if (to_delete.nr)
     -+		ret = delete_branches(to_delete.nr, to_delete.v,
     ++	if (branches_to_delete.nr)
     ++		ret = delete_branches(branches_to_delete.nr, branches_to_delete.v,
      +				      FILTER_REFS_BRANCHES,
      +				      DELETE_BRANCH_SKIP_UNMERGED |
      +				      DELETE_BRANCH_NO_HEAD_FALLBACK |
      +				      flags);
      +
     -+	strvec_clear(&to_delete);
     -+	strset_clear(&deletable);
     ++	strvec_clear(&branches_to_delete);
     ++	strset_clear(&deletable_branch_names);
      +	ref_array_clear(&candidates);
      +	ref_filter_clear(&filter);
      +	return ret;
     @@ t/t3200-branch.sh: test_expect_success '--forked requires a value' '
      +	)
      +'
      +
     -+test_expect_success '--delete-merged clears the deleted upstream of a spared branch' '
     ++test_expect_success '--delete-merged keeps the upstream chain of a surviving branch' '
      +	setup_repo_for_delete_merged &&
      +	(
      +		cd repo &&
     @@ t/t3200-branch.sh: test_expect_success '--forked requires a value' '
      +		git commit --allow-empty -m "tip work" &&
      +
      +		git branch --delete-merged origin/next \
     -+			--delete-merged lower &&
     ++			--delete-merged lower >actual 2>&1 &&
     ++		test_must_be_empty actual &&
      +
      +		check_branches <<-\EOF &&
     ++		lower
      +		main
      +		mid
      +		tip
      +		EOF
      +
     -+		git config --local --get-regexp "branch\\.(mid|tip)\\.(merge|remote)" >actual &&
     ++		git config --local --get-regexp "branch\\.(lower|mid|tip)\\.(merge|remote)" >actual &&
      +		cat >expect <<-\EOF &&
     ++		branch.lower.remote origin
     ++		branch.lower.merge refs/heads/next
     ++		branch.mid.remote .
     ++		branch.mid.merge refs/heads/lower
      +		branch.tip.remote .
      +		branch.tip.merge refs/heads/mid
      +		EOF
     @@ t/t3200-branch.sh: test_expect_success '--forked requires a value' '
      +	)
      +'
      +
     ++test_expect_success '--delete-merged result is independent of stacked branch names' '
     ++	setup_repo_for_delete_merged &&
     ++	(
     ++		cd repo &&
     ++		git branch c-lower origin/next --track &&
     ++		git branch b-mid c-lower --track &&
     ++		git checkout -b a-tip b-mid --track &&
     ++		git commit --allow-empty -m "tip work" &&
     ++
     ++		git branch --delete-merged origin/next \
     ++			--delete-merged "c-*" &&
     ++
     ++		check_branches <<-\EOF &&
     ++		a-tip
     ++		b-mid
     ++		c-lower
     ++		main
     ++		EOF
     ++
     ++		git branch --delete-merged origin/next \
     ++			--delete-merged "c-*" >actual 2>&1 &&
     ++		test_must_be_empty actual &&
     ++
     ++		check_branches <<-\EOF
     ++		a-tip
     ++		b-mid
     ++		c-lower
     ++		main
     ++		EOF
     ++	)
     ++'
     ++
      +test_expect_success '--delete-merged requires a value' '
      +	test_must_fail git -C forked branch --delete-merged 2>err &&
      +	test_grep "requires a value" err
 6:  734d27c908 ! 6:  fa70108611 branch: add branch.<name>.deleteMerged opt-out
     @@ Documentation/git-branch.adoc: A branch is not deleted when:
       ## builtin/branch.c ##
      @@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
       	struct ref_array candidates = { 0 };
     - 	struct strset deletable = STRSET_INIT;
     - 	struct strvec to_delete = STRVEC_INIT;
     + 	struct strset deletable_branch_names = STRSET_INIT;
     + 	struct strvec branches_to_delete = STRVEC_INIT;
      +	struct strbuf key = STRBUF_INIT;
       	struct hashmap_iter iter;
       	struct strmap_entry *entry;
       	size_t i;
      @@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
     - 		const char *short_name;
     + 		const char *branch_name;
       		struct branch *branch;
     - 		const char *upstream;
     + 		const char *upstream_refname;
      +		int opt_out;
       
     - 		if (!skip_prefix(full_name, "refs/heads/", &short_name))
     - 			BUG("filter returned non-branch ref '%s'", full_name);
     + 		if (!skip_prefix(branch_refname, "refs/heads/", &branch_name))
     + 			BUG("filter returned non-branch ref '%s'", branch_refname);
      @@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
       					FILTER_REFS_BRANCHES, DELETE_BRANCH_SKIP_UNMERGED))
       			continue;
       
      +		strbuf_reset(&key);
     -+		strbuf_addf(&key, "branch.%s.deletemerged", short_name);
     ++		strbuf_addf(&key, "branch.%s.deletemerged", branch_name);
      +		if (!repo_config_get_bool(the_repository, key.buf, &opt_out) &&
      +		    !opt_out) {
      +			if (!(flags & DELETE_BRANCH_QUIET))
      +				fprintf(stderr,
      +					_("Skipping '%s' (branch.%s.deleteMerged is false)\n"),
     -+					short_name, short_name);
     ++					branch_name, branch_name);
      +			continue;
      +		}
      +
     - 		strset_add(&deletable, short_name);
     + 		strset_add(&deletable_branch_names, branch_name);
       	}
       
      @@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
     @@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstrea
       				      flags);
       
      +	strbuf_release(&key);
     - 	strvec_clear(&to_delete);
     - 	strset_clear(&deletable);
     + 	strvec_clear(&branches_to_delete);
     + 	strset_clear(&deletable_branch_names);
       	ref_array_clear(&candidates);
      
       ## t/t3200-branch.sh ##
 7:  7aa9d5db14 ! 7:  13bac431a3 branch: add --dry-run for --delete-merged
     @@ Documentation/git-branch.adoc: git branch (-m|-M) [<old-branch>] <new-branch>
       
       DESCRIPTION
       -----------
     -@@ Documentation/git-branch.adoc: kept, so a branch is never deleted out from under one stacked on top
     - of it. If that kept branch in turn tracks a branch that is being
     - deleted, its now-stale upstream configuration is cleared.
     +@@ Documentation/git-branch.adoc: A branch that a surviving branch depends on through a chain of local
     + upstreams is kept, so a branch is never deleted out from under stacked
     + work.
       
      +`--dry-run`::
      +	With `--delete-merged`, print which branches would be
     @@ builtin/branch.c: static int delete_branches(int argc, const char **argv, int ki
       			char *refname = name + branch_name_pos;
       			if (!(flags & DELETE_BRANCH_QUIET))
       				printf(remote_branch
     -@@ builtin/branch.c: static int spare_stacked_base(const struct reference *ref, void *cb_data)
     -  * base is itself merged, so when its own upstream is also going away
     -  * (no surviving branch tracks it), clear the base's now-stale upstream.
     -  */
     --static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable)
     -+static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable,
     -+				unsigned int flags)
     - {
     - 	struct strset spared = STRSET_INIT;
     - 	struct spare_data data = { .deletable = deletable, .spared = &spared };
     -@@ builtin/branch.c: static void spare_stacked_bases(struct ref_store *refs, struct strset *deletable
     - 
     - 	refs_for_each_branch_ref(refs, spare_stacked_base, &data);
     - 
     --	strset_for_each_entry(&spared, &iter, entry) {
     --		struct branch *branch = branch_get(entry->key);
     --		const char *upstream = branch_get_upstream(branch, NULL);
     --		const char *up_short;
     -+	if (!(flags & DELETE_BRANCH_DRY_RUN)) {
     -+		strset_for_each_entry(&spared, &iter, entry) {
     -+			struct branch *branch = branch_get(entry->key);
     -+			const char *upstream = branch_get_upstream(branch, NULL);
     -+			const char *up_short;
     - 
     --		if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     --		    !strset_contains(deletable, up_short))
     --			continue;
     -+			if (!upstream || !skip_prefix(upstream, "refs/heads/", &up_short) ||
     -+			    !strset_contains(deletable, up_short))
     -+				continue;
     - 
     --		strbuf_reset(&key);
     --		strbuf_addf(&key, "branch.%s.merge", branch->name);
     --		repo_config_set_gently(the_repository, key.buf, NULL);
     --		strbuf_reset(&key);
     --		strbuf_addf(&key, "branch.%s.remote", branch->name);
     --		repo_config_set_gently(the_repository, key.buf, NULL);
     -+			strbuf_reset(&key);
     -+			strbuf_addf(&key, "branch.%s.merge", branch->name);
     -+			repo_config_set_gently(the_repository, key.buf, NULL);
     -+			strbuf_reset(&key);
     -+			strbuf_addf(&key, "branch.%s.remote", branch->name);
     -+			repo_config_set_gently(the_repository, key.buf, NULL);
     -+		}
     - 	}
     - 
     - 	strbuf_release(&key);
     -@@ builtin/branch.c: static int delete_merged_branches(const struct strvec *upstreams,
     - 		strset_add(&deletable, short_name);
     - 	}
     - 
     --	spare_stacked_bases(refs, &deletable);
     -+	spare_stacked_bases(refs, &deletable, flags);
     - 
     - 	strset_for_each_entry(&deletable, &iter, entry)
     - 		strvec_push(&to_delete, entry->key);
      @@ builtin/branch.c: int cmd_branch(int argc,
       	int delete = 0, rename = 0, copy = 0, list = 0,
       	    unset_upstream = 0, show_current = 0, edit_description = 0;
     @@ t/t3200-branch.sh: test_expect_success '--delete-merged keeps the upstream of a
       		check_branches <<-\EOF &&
       		feature
       		main
     -@@ t/t3200-branch.sh: test_expect_success '--delete-merged clears the deleted upstream of a spared bra
     +@@ t/t3200-branch.sh: test_expect_success '--delete-merged keeps the upstream chain of a surviving bra
       		git checkout -b tip mid --track &&
       		git commit --allow-empty -m "tip work" &&
       
      +		git branch --dry-run --delete-merged origin/next \
     -+			--delete-merged lower &&
     ++			--delete-merged lower >actual 2>&1 &&
     ++		test_must_be_empty actual &&
      +
     -+		git config --local --get-regexp "branch\\.(mid|tip)\\.(merge|remote)" >actual &&
     ++		git config --local --get-regexp "branch\\.(lower|mid|tip)\\.(merge|remote)" >actual &&
      +		cat >expect <<-\EOF &&
     ++		branch.lower.remote origin
     ++		branch.lower.merge refs/heads/next
      +		branch.mid.remote .
      +		branch.mid.merge refs/heads/lower
      +		branch.tip.remote .
     @@ t/t3200-branch.sh: test_expect_success '--delete-merged clears the deleted upstr
      +		test_cmp expect actual &&
      +
       		git branch --delete-merged origin/next \
     - 			--delete-merged lower &&
     - 
     + 			--delete-merged lower >actual 2>&1 &&
     + 		test_must_be_empty actual &&
      @@ t/t3200-branch.sh: test_expect_success "branch -d still deletes a deleteMerged=false branch" '
       	)
       '

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a --forked option to "git branch" list mode that lists only branches whose configured upstream matches <branch>. The argument can be a ref (e.g. "origin/main", "master"), a remote name like "origin" for the branch its origin/HEAD points at, or a shell glob (e.g. "origin/*"), and may be repeated to widen the filter.

It is an ordinary list filter, so it combines with the others:

    git branch --merged origin/main --forked 'origin/*'

lists branches forked from origin that are already merged into origin/main, and --no-merged inverts the question.

This is the building block for --delete-merged, which deletes the listed branches once they have landed on their upstream.

---
 Documentation/git-branch.adoc |  12 +++-
 builtin/branch.c              |  18 +++++-
 ref-filter.c                  |  70 ++++++++++++++++++++
 ref-filter.h                  |  10 +++
 t/t3200-branch.sh             | 117 ++++++++++++++++++++++++++++++++++
 5 files changed, 224 insertions(+), 3 deletions(-)

index c0afddc424..b0d66a6deb 100644
@@ -13,6 +13,7 @@ git branch [--color[=<when>] | --no-color] [--show-current]
 	   [--column[=<options>] | --no-column] [--sort=<key>]
 	   [--merged [<commit>]] [--no-merged [<commit>]]
 	   [--contains [<commit>]] [--no-contains [<commit>]]
+	   [(--forked <branch>)...]
 	   [--points-at <object>] [--format=<format>]
 	   [(-r|--remotes) | (-a|--all)]
 	   [--list] [<pattern>...]

@@ -51,7 +52,8 @@ merged into the named commit (i.e. the branches whose tip commits are
 reachable from the named commit) will be listed.  With `--no-merged` only
 branches not merged into the named commit will be listed.  If the _<commit>_
 argument is missing it defaults to `HEAD` (i.e. the tip of the current
-branch).
+branch).  With `--forked`, only branches whose configured upstream matches
+the given branch or pattern will be listed.
 
 The command's second form creates a new branch head named _<branch-name>_
 which points to the current `HEAD`, or _<start-point>_ if given. As a

@@ -311,6 +313,14 @@ superproject's "origin/main", but tracks the submodule's "origin/main".
 	Only list branches whose tips are not reachable from
 	_<commit>_ (`HEAD` if not specified). Implies `--list`.
 
+`--forked <branch>`::
+	Only list branches whose configured upstream matches
+	_<branch>_. The argument can be a ref (e.g. `origin/main`,
+	`master`), a remote name like `origin` for the branch its
+	`origin/HEAD` points at, or a shell-style glob (e.g.
+	`'origin/*'`). The option can be repeated to widen the
+	filter. Implies `--list`.
+
 `--points-at <object>`::
 	Only list branches of _<object>_.
 

index dede60d27b..3ac1272d7e 100644
@@ -30,7 +30,7 @@
 #include "commit-reach.h"
 
 static const char * const builtin_branch_usage[] = {
-	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),
+	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged] [(--forked <branch>)...]"),
 	N_("git branch [<options>] [-f] [--recurse-submodules] <branch-name> [<start-point>]"),
 	N_("git branch [<options>] [-l] [<pattern>...]"),
 	N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."),

@@ -673,6 +673,16 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
 	free_worktrees(worktrees);
 }
 
+static int parse_opt_forked(const struct option *opt, const char *arg, int unset)
+{
+	struct ref_filter *filter = opt->value;
+
+	BUG_ON_OPT_NEG(unset);
+	if (ref_filter_forked_add(filter, arg) < 0)
+		die(_("'%s' is not a valid branch or pattern"), arg);
+	return 0;
+}
+
 static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
 
 static int edit_branch_description(const char *branch_name)

@@ -793,6 +803,9 @@ int cmd_branch(int argc,
 		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
 		OPT_MERGED(&filter, N_("print only branches that are merged")),
 		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
+		OPT_CALLBACK_F(0, "forked", &filter, N_("branch"),
+			N_("print only branches whose upstream matches <branch> (repeatable)"),
+			PARSE_OPT_NONEG, parse_opt_forked),
 		OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
 		OPT_REF_SORT(&sorting_options),
 		OPT_CALLBACK(0, "points-at", &filter.points_at, N_("object"),

@@ -838,7 +851,8 @@ int cmd_branch(int argc,
 		list = 1;
 
 	if (filter.with_commit || filter.no_commit ||
-	    filter.reachable_from || filter.unreachable_from || filter.points_at.nr)
+	    filter.reachable_from || filter.unreachable_from ||
+	    filter.points_at.nr || filter.forked.nr)
 		list = 1;
 
 	noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +

index 120221b47f..9361296e2a 100644
@@ -67,6 +67,7 @@ struct ref_filter {
 	const char **name_patterns;
 	const char *start_after;
 	struct strvec exclude;
+	struct strvec forked;
 	struct oid_array points_at;
 	struct commit_list *with_commit;
 	struct commit_list *no_commit;

@@ -110,6 +111,7 @@ struct ref_format {
 #define REF_FILTER_INIT { \
 	.points_at = OID_ARRAY_INIT, \
 	.exclude = STRVEC_INIT, \
+	.forked = STRVEC_INIT, \
 }
 #define REF_FORMAT_INIT {             \
 	.use_color = GIT_COLOR_UNKNOWN, \

@@ -172,6 +174,14 @@ void ref_sorting_release(struct ref_sorting *);
 struct ref_sorting *ref_sorting_options(struct string_list *);
 /*  Function to parse --merged and --no-merged options */
 int parse_opt_merge_filter(const struct option *opt, const char *arg, int unset);
+/*
+ * Register a --forked <branch> pattern on the filter. The argument is
+ * either a ref, which is resolved to its full refname, or a shell-style
+ * glob. Branches are kept only when their configured upstream matches
+ * one of the registered patterns. Returns -1 if the argument is not a
+ * valid ref or pattern.
+ */
+int ref_filter_forked_add(struct ref_filter *filter, const char *arg);
 /*  Get the current HEAD's description */
 char *get_head_description(void);
 /*  Set up translated strings in the output. */

gitgitgadget

From: Harald Nordgren <[email protected]>

delete_branches() takes separate force and quiet parameters, while check_branch_commit() takes force. The next commits would grow this collection further. Replace them with a single unsigned flags argument and an enum.

Test the FORCE and QUIET bits directly from flags at each use site so that mutating or forwarding flags cannot leave cached values stale.

No change in behavior.

---
 builtin/branch.c | 40 ++++++++++++++++++++++++----------------
 1 file changed, 24 insertions(+), 16 deletions(-)

index 3ac1272d7e..09631f93f7 100644
@@ -189,16 +189,22 @@ static int branch_merged(int kind, const char *name,
 	return merged;
 }
 
+enum delete_branch_flags {
+	DELETE_BRANCH_FORCE = (1 << 0),
+	DELETE_BRANCH_QUIET = (1 << 1),
+};
+
 static int check_branch_commit(const char *branchname, const char *refname,
 			       const struct object_id *oid, struct commit *head_rev,
-			       int kinds, int force)
+			       int kinds, unsigned int flags)
 {
 	struct commit *rev = lookup_commit_reference(the_repository, oid);
-	if (!force && !rev) {
+	if (!(flags & DELETE_BRANCH_FORCE) && !rev) {
 		error(_("couldn't look up commit object for '%s'"), refname);
 		return -1;
 	}
-	if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
+	if (!(flags & DELETE_BRANCH_FORCE) &&
+	    !branch_merged(kinds, branchname, rev, head_rev)) {
 		error(_("the branch '%s' is not fully merged"), branchname);
 		advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
 				  _("If you are sure you want to delete it, "

@@ -217,8 +223,8 @@ static void delete_branch_config(const char *branchname)
 	strbuf_release(&buf);
 }
 
-static int delete_branches(int argc, const char **argv, int force, int kinds,
-			   int quiet)
+static int delete_branches(int argc, const char **argv, int kinds,
+			   unsigned int flags)
 {
 	struct commit *head_rev = NULL;
 	struct object_id oid;

@@ -241,7 +247,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 		remote_branch = 1;
 		allowed_interpret = INTERPRET_BRANCH_REMOTE;
 
-		force = 1;
+		flags |= DELETE_BRANCH_FORCE;
 		break;
 	case FILTER_REFS_BRANCHES:
 		fmt = "refs/heads/%s";

@@ -252,12 +258,12 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 	}
 	branch_name_pos = strcspn(fmt, "%");
 
-	if (!force)
+	if (!(flags & DELETE_BRANCH_FORCE))
 		head_rev = lookup_commit_reference(the_repository, &head_oid);
 
 	for (i = 0; i < argc; i++, strbuf_reset(&bname)) {
 		char *target = NULL;
-		int flags = 0;
+		int ref_flags = 0;
 
 		copy_branchname(&bname, argv[i], allowed_interpret);
 		free(name);

@@ -279,7 +285,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 					     RESOLVE_REF_READING
 					     | RESOLVE_REF_NO_RECURSE
 					     | RESOLVE_REF_ALLOW_BAD_NAME,
-					     &oid, &flags);
+					     &oid, &ref_flags);
 		if (!target) {
 			if (remote_branch) {
 				error(_("remote-tracking branch '%s' not found"), bname.buf);

@@ -291,7 +297,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 									   | RESOLVE_REF_NO_RECURSE
 									   | RESOLVE_REF_ALLOW_BAD_NAME,
 									   &oid,
-									   &flags);
+									   &ref_flags);
 				FREE_AND_NULL(virtual_name);
 
 				if (virtual_target)

@@ -306,16 +312,16 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 			continue;
 		}
 
-		if (!(flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
+		if (!(ref_flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
 		    check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
-					force)) {
+					flags)) {
 			ret = 1;
 			goto next;
 		}
 
 		item = string_list_append(&refs_to_delete, name);
-		item->util = xstrdup((flags & REF_ISBROKEN) ? "broken"
-				    : (flags & REF_ISSYMREF) ? target
+		item->util = xstrdup((ref_flags & REF_ISBROKEN) ? "broken"
+				    : (ref_flags & REF_ISSYMREF) ? target
 				    : repo_find_unique_abbrev(the_repository, &oid, DEFAULT_ABBREV));
 
 	next:

@@ -330,7 +336,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
 		char *name = item->string;
 		if (!refs_ref_exists(get_main_ref_store(the_repository), name)) {
 			char *refname = name + branch_name_pos;
-			if (!quiet)
+			if (!(flags & DELETE_BRANCH_QUIET))
 				printf(remote_branch
 					? _("Deleted remote-tracking branch %s (was %s).\n")
 					: _("Deleted branch %s (was %s).\n"),

@@ -895,7 +901,9 @@ int cmd_branch(int argc,
 	if (delete) {
 		if (!argc)
 			die(_("branch name required"));
-		ret = delete_branches(argc, argv, delete > 1, filter.kind, quiet);
+		ret = delete_branches(argc, argv, filter.kind,
+				      (delete > 1 ? DELETE_BRANCH_FORCE : 0) |
+				      (quiet ? DELETE_BRANCH_QUIET : 0));
 		goto out;
 	} else if (show_current) {
 		print_current_branch_name();

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a skip-unmerged mode to delete_branches() and check_branch_commit() so a bulk caller can silently skip branches that are not fully merged and carry on, rather than erroring with the "use 'git branch -D'" advice that the plain "git branch -d" path emits. Existing callers are unaffected.

---
 builtin/branch.c | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

index 09631f93f7..504117d1c3 100644
@@ -192,6 +192,7 @@ static int branch_merged(int kind, const char *name,
 enum delete_branch_flags {
 	DELETE_BRANCH_FORCE = (1 << 0),
 	DELETE_BRANCH_QUIET = (1 << 1),
+	DELETE_BRANCH_SKIP_UNMERGED = (1 << 2),
 };
 
 static int check_branch_commit(const char *branchname, const char *refname,

@@ -205,10 +206,13 @@ static int check_branch_commit(const char *branchname, const char *refname,
 	}
 	if (!(flags & DELETE_BRANCH_FORCE) &&
 	    !branch_merged(kinds, branchname, rev, head_rev)) {
-		error(_("the branch '%s' is not fully merged"), branchname);
-		advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
-				  _("If you are sure you want to delete it, "
-				  "run 'git branch -D %s'"), branchname);
+		if (!(flags & DELETE_BRANCH_SKIP_UNMERGED)) {
+			error(_("the branch '%s' is not fully merged"),
+			      branchname);
+			advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
+					  _("If you are sure you want to delete it, "
+					  "run 'git branch -D %s'"), branchname);
+		}
 		return -1;
 	}
 	return 0;

@@ -315,7 +319,8 @@ static int delete_branches(int argc, const char **argv, int kinds,
 		if (!(ref_flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
 		    check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
 					flags)) {
-			ret = 1;
+			if (!(flags & DELETE_BRANCH_SKIP_UNMERGED))
+				ret = 1;
 			goto next;
 		}
 

gitgitgadget

From: Harald Nordgren <[email protected]>

Teach delete_branches() a new mode for the upcoming --delete-merged caller that checks whether a branch is merged into its upstream without falling back to HEAD when there is no upstream. Existing callers keep their current behavior.

---
 builtin/branch.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

index 504117d1c3..1ef8362c12 100644
@@ -168,10 +168,13 @@ static int branch_merged(int kind, const char *name,
 	 * upstream, if any, otherwise with HEAD", we should just
 	 * return the result of the repo_in_merge_bases() above without
 	 * any of the following code, but during the transition period,
-	 * a gentle reminder is in order.
+	 * a gentle reminder is in order.  Callers that opt out of the
+	 * HEAD fallback by passing head_rev=NULL are not interested in
+	 * the reminder either: they have already established that the
+	 * branch has an upstream, so HEAD is irrelevant to the decision.
 	 */
-	if (head_rev != reference_rev) {
-		int expect = head_rev ? repo_in_merge_bases(the_repository, rev, head_rev) : 0;
+	if (head_rev && head_rev != reference_rev) {
+		int expect = repo_in_merge_bases(the_repository, rev, head_rev);
 		if (expect < 0)
 			exit(128);
 		if (expect == merged)

@@ -193,6 +196,7 @@ enum delete_branch_flags {
 	DELETE_BRANCH_FORCE = (1 << 0),
 	DELETE_BRANCH_QUIET = (1 << 1),
 	DELETE_BRANCH_SKIP_UNMERGED = (1 << 2),
+	DELETE_BRANCH_NO_HEAD_FALLBACK = (1 << 3),
 };
 
 static int check_branch_commit(const char *branchname, const char *refname,

@@ -262,7 +266,8 @@ static int delete_branches(int argc, const char **argv, int kinds,
 	}
 	branch_name_pos = strcspn(fmt, "%");
 
-	if (!(flags & DELETE_BRANCH_FORCE))
+	if (!(flags & DELETE_BRANCH_FORCE) &&
+	    !(flags & DELETE_BRANCH_NO_HEAD_FALLBACK))
 		head_rev = lookup_commit_reference(the_repository, &head_oid);
 
 	for (i = 0; i < argc; i++, strbuf_reset(&bname)) {

gitgitgadget

From: Harald Nordgren <[email protected]>

    git branch (--delete-merged <branch>)... [<pattern>...]

deletes local branches matching the optional patterns when their configured upstream matches one of the --delete-merged arguments and their tip is reachable from that upstream. The work has already landed on the upstream they track, so the local copy is no longer needed.

The option can be repeated to widen the upstream match. Keeping the candidate patterns as positional arguments lets users bound the set of local branches that may be deleted independently of the upstream selection.

A branch is not deleted when:

* it is checked out in any worktree
* its configured upstream ref no longer exists, since a missing upstream is not by itself a sign of integration
* pushing it by name to the remote configured by branch.<name>.remote would update its upstream, as determined by mapping the branch ref through that remote's fetch refspec. For example, a local "main" that tracks "origin/main" is kept even when remote.pushDefault names a fork. Right after a pull it merely looks fully merged.

A branch whose work is not yet merged into its upstream is silently skipped, so one unmerged topic does not abort the whole sweep.

A branch that a surviving branch depends on through a chain of local upstreams is also kept, so no branch is deleted out from under stacked work. Collect this transitive set without changing the candidate set during ref iteration: walk upstream chains from surviving branches, visit each branch at most once, and remove the collected bases only after the iteration completes. This makes the result independent of ref iteration order without repeated full scans.

---
 Documentation/git-branch.adoc |  30 +++++
 builtin/branch.c              | 159 +++++++++++++++++++++++++-
 t/t3200-branch.sh             | 204 ++++++++++++++++++++++++++++++++++
 3 files changed, 391 insertions(+), 2 deletions(-)

index b0d66a6deb..2a96cd7253 100644
@@ -25,6 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
 git branch (-c|-C) [<old-branch>] <new-branch>
 git branch (-d|-D) [-r] <branch-name>...
 git branch --edit-description [<branch-name>]
+git branch (--delete-merged <branch>)... [<pattern>...]
 
 DESCRIPTION
 -----------

@@ -201,6 +202,35 @@ This option is only applicable in non-verbose mode.
 	Print the name of the current branch. In detached `HEAD` state,
 	nothing is printed.
 
+`--delete-merged <branch>`::
+	Delete local branches whose configured upstream matches
+	_<branch>_, but only when their tip is reachable from that
+	upstream. In other words, the work on the branch has already
+	landed on the upstream it tracks, so the local copy is no longer
+	needed. The option can be repeated to widen the upstream match.
+	Optional _<pattern>_ arguments limit which local branches are
+	considered, e.g. `git branch --delete-merged 'origin/*'
+	'topic-*'`.
++
+A branch is not deleted when:
++
+--
+* its configured upstream ref no longer exists,
+* it is checked out in any worktree, or
+* pushing it by name to the remote configured by
+  `branch.<name>.remote` would update its upstream, so it cannot be
+  distinguished from a branch that just looks "fully merged" right
+  after a pull.
+--
++
+A branch whose work has not yet been merged into its upstream is
+silently skipped. Delete it with `git branch -D` if you want to
+remove it anyway.
++
+A branch that a surviving branch depends on through a chain of local
+upstreams is kept, so a branch is never deleted out from under stacked
+work.
+
 `-v`::
 `-vv`::
 `--verbose`::

gitgitgadget

From: Harald Nordgren <[email protected]>

Setting branch.<name>.deleteMerged=false exempts that branch from "git branch --delete-merged", which is useful for a topic you want to keep developing after an early round of it has been merged upstream. Unless --quiet is given, each skip is reported so the user knows why their topic was kept.

Explicit deletion with "git branch -d" still uses the normal merge check and ignores this setting.

---
 Documentation/config/branch.adoc |  7 +++++++
 Documentation/git-branch.adoc    |  5 +++--
 builtin/branch.c                 | 14 +++++++++++++
 t/t3200-branch.sh                | 36 ++++++++++++++++++++++++++++++++
 4 files changed, 60 insertions(+), 2 deletions(-)

index a4db9fa5c8..d8483acb4f 100644
@@ -102,3 +102,10 @@ for details).
 	`git branch --edit-description`. Branch description is
 	automatically added to the `format-patch` cover letter or
 	`request-pull` summary.
+
+`branch.<name>.deleteMerged`::
+	If set to `false`, branch _<name>_ is exempt from
+	`git branch --delete-merged`.  Useful for a topic branch you
+	intend to develop further after an initial round has been
+	merged upstream.  Defaults to true.  Explicit deletion via
+	`git branch -d` is unaffected.