Re: [PATCH v2 2/7] fetch: backfill tags before setting upstream

Patrick Steinhardt [off-list ref] writes:

The fetch code flow is a bit hard to understand right now:

    1. We optionally prune all references which have vanished on the
       remote side.
    2. We fetch and update all other references locally.
    3. We update the upstream branch in the gitconfig.
    4. We backfill tags pointing into the history we have just fetched.

It is quite confusing that we fetch objects and update references in
both (2) and (4), which is further stressed by the point that we use a
`skip` goto label to jump from (3) to (4) in case we fail to update the
gitconfig as expected.

Reorder the code to first update all local references, and only after we
have done so update the upstream branch information. This improves the
code flow and furthermore makes it easier to refactor the way we update
references together.

OK, as "setting upsream" is more or less unrelated to the act of
actual fetching the refs and objects reachable from them, moving it
outside the main code that is about fetching does make sense.

 static int do_fetch(struct transport *transport,
 		    struct refspec *rs)
 {
-	struct ref *ref_map;
+	struct ref *ref_map = NULL;

This is needed because we will always do free_refs() on the variable
after this patch, and one early "goto cleanup" happens even before
we touch ref_map, when truncate_fetch_head() fails.

And because we always free_refs(ref_map), we can lose a call here.
OK.

+	/*
+	 * If neither --no-tags nor --tags was specified, do automated tag
+	 * following.
+	 */
+	if (tags == TAGS_DEFAULT && autotags) {
+		struct ref *tags_ref_map = NULL, **tail = &tags_ref_map;
+
+		find_non_local_tags(remote_refs, &tags_ref_map, &tail);
+		if (tags_ref_map)
+			backfill_tags(transport, tags_ref_map, worktrees);
+
+		free_refs(tags_ref_map);
+	}

Here, the new code uses a local and separete tags_ref_map variable
and free it before we leave, instead of reusing ref_map variable.

OK.