"Harald Nordgren via GitGitGadget" [off-list ref] writes:

This function originally was to see if "git branch -d <derived>" is
allowed to remove it by calling branch_merged(), which uses the
upstream association of <derived>, falling back to head_rev.  For
our purpose of "--forked" check, we are not deleting, so existing
calls to error() and the phrasing used in its messages that talks
about deletion are not appropriate.  Hence we introduce the
warn_only mode to just state the fact the branch is not fully merged
to its upstream.

It is inherited from the original code, and it is outside the scope
of this series, but after the dust settles, we may want to consider
saying what other branch this branch is expected to be merged to
(i.e. "not fully merged to %s").

It is unclear how n_not_merged would be useful.  Wouldn't the caller
be capable to count the failure returns from this function?

It is strange to see any need to touch delete_branches() when the
only thing you are adding is the "--forked" option.  For that
matter, the change to check_branch_commit() is also suspect.

In short, this does a lot more than necessary to add "--forked".
Why such a split in the series?

+static void parse_forked_args(int argc, const char **argv,
+			      struct string_list *upstream_patterns)
+{
+	int i;
+
+	for (i = 0; i < argc; i++) {
+		const char *arg = argv[i];
+		struct object_id oid;
+		char *full_ref = NULL;
+		const char *short_ref;
+
+		if (has_glob_specials(arg)) {
+			string_list_insert(upstream_patterns, arg);
+			continue;
+		}
+
+		if (repo_dwim_ref(the_repository, arg, strlen(arg), &oid,
+				  &full_ref, 0) == 1 &&
+		    (skip_prefix(full_ref, "refs/heads/", &short_ref) ||
+		     skip_prefix(full_ref, "refs/remotes/", &short_ref))) {
+			string_list_insert(upstream_patterns, short_ref);
+			free(full_ref);
+			continue;
+		}
+		free(full_ref);
+
+		die(_("'%s' is not a valid branch or pattern"), arg);
+	}
+}

This one does look like very much relevant to "--forked".

+struct forked_cb {
+	const struct string_list *upstream_patterns;
+	struct string_list *out;
+};

So does this.

+static int collect_forked_branch(const struct reference *ref, void *cb_data)
+{
+	struct forked_cb *cb = cb_data;
+	struct branch *branch;
+	const char *upstream, *short_upstream;
+	const struct string_list_item *item;
+
+	if (ref->flags & REF_ISSYMREF)
+		return 0;
+	branch = branch_get(ref->name);
+	if (!branch)
+		return 0;
+	upstream = branch_get_upstream(branch, NULL);
+	if (!upstream)
+		return 0;
+	short_upstream = upstream;
+	(void)(skip_prefix(short_upstream, "refs/heads/", &short_upstream) ||
+	       skip_prefix(short_upstream, "refs/remotes/", &short_upstream));
+
+	for_each_string_list_item(item, cb->upstream_patterns)

Sholdn't each element of upstream_patterns remember if it is
suitable for wildmatch or not when it gets parsed in the earlier
function we saw, so that this loop can refrain from calling
wildmatch() for non-wildcard elements?

+		if (!wildmatch(item->string, short_upstream, WM_PATHNAME)) {
+			string_list_append(cb->out, ref->name)->util =
+				xstrdup(upstream);
+			return 0;
+		}
+	return 0;
+}
+
+static void collect_forked_set(int argc, const char **argv,
+			       struct string_list *out)
+{
+	struct string_list upstream_patterns = STRING_LIST_INIT_DUP;
+	struct forked_cb cb = {
+		.upstream_patterns = &upstream_patterns,
+		.out = out,
+	};
+
+	parse_forked_args(argc, argv, &upstream_patterns);
+
+	refs_for_each_branch_ref(get_main_ref_store(the_repository),
+				 collect_forked_branch, &cb);
+
+	string_list_clear(&upstream_patterns, 0);
+}
+
+static int list_forked_branches(int argc, const char **argv)
+{
+	struct string_list out = STRING_LIST_INIT_DUP;
+	struct string_list_item *item;
+
+	if (!argc)
+		die(_("--forked requires at least one <branch>"));
+
+	collect_forked_set(argc, argv, &out);
+	for_each_string_list_item(item, &out)
+		puts(item->string);
+
+	string_list_clear(&out, 1);
+	return 0;
+}

Up to point the changes are very much appropriate for adding the
"--forked" option.

This does not belong to "--forked" as far as I can tell.

+	} else if (forked) {
+		ret = list_forked_branches(argc, argv);
 		goto out;
 	} else if (show_current) {
 		print_current_branch_name();