From: D. Ben Knoble Date: Sat, 24 Oct 2026 15:08:45 GMT Subject: Re: [PATCH v10 2/5] fetch: extract collect_upstream_from_remote() helper Message-ID: In-Reply-To: On Tue, Oct 20, 2026 at 9:43 AM Harald Nordgren via GitGitGadget wrote: > > From: Harald Nordgren > > When a fetch has no refspec to work from, we fall back to guessing > what to fetch: the remote's configured fetch refspec if there is one, > and separately, whether the current branch's upstream lives on this > remote. It took me a couple tries to parse this because the 2 halves ("[one], and separately, [two]") are 2 different kinds of objects! I think what you are trying to tell me is …we fall back to guessing what to fetch: the remote's … separately, the current branch's upstream if it lives on the fetched remote. That way [two] is also a "thing to fetch" in the same class of objects as [one]? Or have I misunderstood? > The latter is independent of the former on purpose: a narrow > refspec (for example from "git remote add -t") can leave the current > branch's own upstream uncovered, and we still need to be able to fetch > it. I don't really understand the meaning here. I can guess that you mean something like "A remote with a narrow refspec, like what you get from 'git remote add -t', can omit a branch's upstream from the remote's fetch refspec, and we still want to fetch that upstream." But it's taken me a while to put that together (after puzzling out the above) after first not knowing what "uncovered" meant. I think the whole thing would be clearer with an example: """ Imagine a remote with a narrow refspec: git remote add -t main colleague and a branch whose upstream points at that remote, but isn't part of the remote's refspec: git fetch colleague work:refs/remotes/colleague/work git switch -c work colleague/work When we "git fetch colleague" without a refspec, we decide what to fetch by combining the remote's refspec (main -> remote-tracking branch, in this case) and the current branch's upstream, if it was based on that remote (work -> remote-tracking branch, in this case). """ Note: we aren't "guessing" what to fetch! > That "does this branch build on this remote" check was inlined for > just the current branch. Move it into its own function, > collect_upstream_from_remote(), so the same logic can be reused for > branches other than just the current one. And then this maybe comes next. Personally I appreciate the extra explanation, but if it exists elsewhere we could also refer to the implementing commit? I've also made some assumptions about how that "current branch" check works, since I'm not sure how to make sense of it without this manually created remote-tracking branch? > Signed-off-by: Harald Nordgren > --- > builtin/fetch.c | 23 ++++++++++++++--------- > remote.c | 15 +++++++++++++++ > remote.h | 9 +++++++++ > 3 files changed, 38 insertions(+), 9 deletions(-) > > diff --git a/builtin/fetch.c b/builtin/fetch.c > index ffcb5ba29a..136a59154a 100644 > --- a/builtin/fetch.c > +++ b/builtin/fetch.c > @@ -1979,7 +1979,8 @@ static int do_fetch(struct transport *transport, > if (rs->nr) { > refspec_ref_prefixes(rs, &transport_ls_refs_options.ref_prefixes); > } else { > - struct branch *branch = branch_get(NULL); > + struct string_list tracked = STRING_LIST_INIT_DUP; > + struct string_list_item *item; > > if (transport->remote->fetch.nr) { > refspec_ref_prefixes(&transport->remote->fetch, > @@ -1995,14 +1996,18 @@ static int do_fetch(struct transport *transport, > else > follow_remote_head = BUILTIN_FOLLOW_REMOTE_HEAD_DFLT; > } > - if (branch && branch_has_merge_config(branch) && > - !strcmp(branch->remote_name, transport->remote->name)) { > - int i; > - for (i = 0; i < branch->merge_nr; i++) { > - strvec_push(&transport_ls_refs_options.ref_prefixes, > - branch->merge[i]->src); > - } > - } > + > + /* > + * The configured refspec may not cover the current > + * branch's upstream (e.g. a narrowed -t refspec), so > + * make sure we can still fetch it regardless. > + */ > + collect_upstream_from_remote(the_repository, &tracked, > + transport->remote, NULL); > + for_each_string_list_item(item, &tracked) > + strvec_push(&transport_ls_refs_options.ref_prefixes, > + item->string); > + string_list_clear(&tracked, 0); > > /* > * If there are no refs specified to fetch, then we just > diff --git a/remote.c b/remote.c > index c9252a90f4..965e42ff52 100644 > --- a/remote.c > +++ b/remote.c > @@ -1891,6 +1891,21 @@ int branch_merge_matches(struct branch *branch, > return refname_match(branch->merge[i]->src, refname); > } > > +void collect_upstream_from_remote(struct repository *repo, > + struct string_list *tracked, > + struct remote *remote, > + const char *refname) I'm not sure if we have guidance about where in the parameter list "out" parameters should go, but I would expect them to be last? Idk. Should the "inputs" be const to better communicate that we aren't going to modify them? I'm not really sure of the const semantics of C anyway, and I know there have been topics in the recent past around const-modifier lints and so on. > +{ > + struct branch *branch = repo_branch_get(repo, refname); > + > + if (!branch_has_merge_config(branch) || > + strcmp(branch->remote_name, remote->name)) > + return; > + > + for (int i = 0; i < branch->merge_nr; i++) > + string_list_insert(tracked, branch->merge[i]->src); > +} We do trade some performance now, right? We first collect a string_list, then push them into a strvec, which has some overhead relative to skipping the intermediate step. Plus, string_lists sort, which the original didn't do. And the caller uses the DUP version of string_list (and IIUC strvec_push strdup's as well), so we end up copying twice? If we used a strvec instead, we could use strvec_pushv, perhaps, being a bit more efficient? (It would be nice if we had an ownership-taking strvec_appendv or something?) But stepping back, if the caller just provides a strvec instead of a string_list, we can push to it directly, since that's what happens anyway! We don't do any filtering or anything in the new caller. > __attribute__((format (printf,2,3))) > static char *error_buf(struct strbuf *err, const char *fmt, ...) > { > diff --git a/remote.h b/remote.h > index ac485a584d..7c86c529b6 100644 > --- a/remote.h > +++ b/remote.h > @@ -359,6 +359,15 @@ int branch_has_merge_config(struct branch *branch); > > int branch_merge_matches(struct branch *, int n, const char *); > > +/* > + * If refname's branch builds on remote, add its upstream on remote to > + * tracked. A NULL refname means the current branch. > + */ > +void collect_upstream_from_remote(struct repository *repo, > + struct string_list *tracked, > + struct remote *remote, > + const char *refname); > + > /* list of the remote in a group as configured */ > struct remote_group_data { > const char *name; > -- > gitgitgadget > -- D. Ben Knoble