refs: unify parse_worktree_ref() and ref_type()

From: Han-Wen Nienhuys <[email protected]>

The logic to handle worktree refs (worktrees/NAME/REF and main-worktree/REF) existed in two places:

* ref_type() in refs.c

* parse_worktree_ref() in worktree.c

Collapse this logic together in one function parse_worktree_ref():
this avoids having to cross-check the result of parse_worktree_ref() and ref_type().

Introduce enum ref_worktree_type, which is slightly different from enum ref_type. The latter is a misleading name (one would think that 'ref_type' would have the symref option).

Instead, enum ref_worktree_type only makes explicit how a refname relates to a worktree. From this point of view, HEAD and refs/bisect/abc are the same: they specify the current worktree implicitly.

The files-backend must avoid packing refs/bisect/* and friends into packed-refs, so expose is_per_worktree_ref() separately.

---
refs: unify parse_worktree_ref() and ref_type()

The logic to handle worktree refs (worktrees/NAME/REF and main-worktree/REF) existed in two places:

* ref_type() in refs.c

* parse_worktree_ref() in worktree.c

Collapse this logic together in one function parse_worktree_ref(): this avoids having to cross-check the result of parse_worktree_ref() and ref_type().

Introduce enum ref_worktree_type, which is slightly different from enum ref_type. The latter is a misleading name (one would think that 'ref_type' would have the symref option).

Instead, enum ref_worktree_type only makes explicit how a refname relates to a worktree. From this point of view, HEAD and refs/bisect/abc are the same: they specify the current worktree implicitly.

The files-backend must avoid packing refs/bisect/* and friends into packed-refs, so expose is_per_worktree_ref() separately.

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-1325%2Fhanwen%2Fparse-worktree-ref-v1
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-1325/hanwen/parse-worktree-ref-v1
Pull-Request: https://github.com/git/git/pull/1325

 builtin/reflog.c      |  3 +-
 reflog.c              | 13 ++-----
 refs.c                | 75 ++++++++++++++++++++++++++--------------
 refs.h                | 29 ++++++++++++----
 refs/files-backend.c  | 80 +++++++++++++++++++------------------------
 refs/packed-backend.c |  2 +-
 worktree.c            | 59 ++++---------------------------
 worktree.h            | 10 ------
 8 files changed, 120 insertions(+), 151 deletions(-)

index 9407f835cb6..bd568d2d931 100644
@@ -26,7 +26,8 @@ static int collect_reflog(const char *ref, const struct object_id *oid, int unus
 	 * Avoid collecting the same shared ref multiple times because
 	 * they are available via all worktrees.
 	 */
-	if (!worktree->is_current && ref_type(ref) == REF_TYPE_NORMAL)
+	if (!worktree->is_current &&
+	    parse_worktree_ref(ref, NULL, NULL, NULL) == REF_WORKTREE_SHARED)
 		return 0;
 
 	strbuf_worktree_ref(worktree, &newref, ref);

index 47ba8620c56..0b8b767f97c 100644
@@ -310,16 +310,9 @@ static int push_tip_to_list(const char *refname, const struct object_id *oid,
 
 static int is_head(const char *refname)
 {
-	switch (ref_type(refname)) {
-	case REF_TYPE_OTHER_PSEUDOREF:
-	case REF_TYPE_MAIN_PSEUDOREF:
-		if (parse_worktree_ref(refname, NULL, NULL, &refname))
-			BUG("not a worktree ref: %s", refname);
-		break;
-	default:
-		break;
-	}
-	return !strcmp(refname, "HEAD");
+	const char *stripped_refname;
+	parse_worktree_ref(refname, NULL, NULL, &stripped_refname);
+	return !strcmp(stripped_refname, "HEAD");
 }
 
 void reflog_expiry_prepare(const char *refname,

index 23479c7ee09..9e40efc4787 100644
@@ -825,15 +825,30 @@ int parse_hide_refs_config(const char *var, const char *value, const char *);
  */
 int ref_is_hidden(const char *, const char *);
 
-enum ref_type {
-	REF_TYPE_PER_WORKTREE,	  /* refs inside refs/ but not shared       */
-	REF_TYPE_PSEUDOREF,	  /* refs outside refs/ in current worktree */
-	REF_TYPE_MAIN_PSEUDOREF,  /* pseudo refs from the main worktree     */
-	REF_TYPE_OTHER_PSEUDOREF, /* pseudo refs from other worktrees       */
-	REF_TYPE_NORMAL,	  /* normal/shared refs inside refs/        */
+/* Is this a per-worktree ref living in the refs/ namespace? */
+int is_per_worktree_ref(const char *refname);
+
+/* Describes how a refname relates to worktrees */
+enum ref_worktree_type {
+	REF_WORKTREE_CURRENT, /* implicitly per worktree, eg. HEAD or
+				 refs/bisect/SOMETHING */
+	REF_WORKTREE_MAIN, /* explicitly in main worktree, eg.
+			      refs/main-worktree/HEAD */
+	REF_WORKTREE_OTHER, /* explicitly in named worktree, eg.
+			       refs/worktrees/bla/HEAD */
+	REF_WORKTREE_SHARED, /* the default, eg. refs/heads/main */
 };
 
-enum ref_type ref_type(const char *refname);
+/* Parse a ref that possibly explicitly refers to a worktree ref
+ * (ie. either REFNAME, main-worktree/REFNAME or
+ * worktree/WORKTREE/REFNAME). If the name references a worktree
+ * implicitly or explicitly, return what kind it was. The
+ * worktree_name, worktree_name_length and refname argument maybe NULL.
+ */
+enum ref_worktree_type parse_worktree_ref(const char *maybe_worktree_ref,
+					  const char **worktree_name,
+					  int *worktree_name_length,
+					  const char **refname);
 
 enum expire_reflog_flags {
 	EXPIRE_REFLOGS_DRY_RUN = 1 << 0,

index 66c4574c99d..bf0e63ae70c 100644
@@ -862,7 +862,7 @@ static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator)
 
 	while ((ok = next_record(iter)) == ITER_OK) {
 		if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY &&
-		    ref_type(iter->base.refname) != REF_TYPE_PER_WORKTREE)
+		    !is_per_worktree_ref(iter->base.refname))
 			continue;
 
 		if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&

index e9e839926b0..9dcea6fc8c1 100644
@@ -166,16 +166,6 @@ const char *worktree_git_path(const struct worktree *wt,
 			      const char *fmt, ...)
 	__attribute__((format (printf, 2, 3)));
 
-/*
- * Parse a worktree ref (i.e. with prefix main-worktree/ or
- * worktrees/) and return the position of the worktree's name and
- * length (or NULL and zero if it's main worktree), and ref.
- *
- * All name, name_length and ref arguments could be NULL.
- */
-int parse_worktree_ref(const char *worktree_ref, const char **name,
-		       int *name_length, const char **ref);
-
 /*
  * Return a refname suitable for access from the current ref store.
  */

base-commit: 805e0a68082a217f0112db9ee86a022227a9c81b

gitgitgadget

A sensible goal.

This makes me wonder...

I wonder if it makes the resulting code clearer to go fully recursive, unlike the posted code that says "if a recursive call says it is for current, that means it is for main worktree, and otherwise pretend as if the input did not have the prefix".

That is, something like

parse_worktree_ref(...) {

	... prepare name, name_len and ref ...

	if (skip_prefix(worktree_ref, "main-worktree/", &worktree_ref)) {
		parsed = parse_worktree_ref(worktree_ref, name, name_len, ref);
        	switch (parsed) {
		case REF_WORKTREE_CURRENT:
                case REF_WORKTREE_MAIN:
			return REF_WORKTREE_MAIN;
		case REF_WORKTREE_OTHER:
		case REF_WORKTREE_SHARED:
			return parsed;
		}
	}

	if (skip_prefix(worktree_ref, "worktrees/", &worktree_ref)) {
		slash = strchr(worktree_ref, '/');

		parsed = parse_worktree_ref(slash + 1, name, name_len, ref);
        	switch (parsed) {
		case REF_WORKTREE_CURRENT:
			return WORKTREE_OTHER; /* iffy */
                case REF_WORKTREE_MAIN:
			return REF_WORKTREE_MAIN;
		case REF_WORKTREE_OTHER:
		case REF_WORKTREE_SHARED:
			return parsed;
		}
	}

	/* Otherwise the input is like HEAD, MERGE_HEAD, refs/$BLAH */
	... do whatever for these trivial cases ...

}

And while composing this follow-up, I found another thing that is iffy. When you ask for "worktrees/foo/refs/bisect/good", the recursive call in "worktrees/foo" for the remainder says "current", and the posted patch and the above pseudocode would take CURRENT to mean "that other worktree's", and turns it into OTHER i.e. "not ours". But the code does so without even checking what our worktree is called. What happens if we are the owner of the "worktrees/foo" namespace? The same thing for "The main worktree says the given ref is 'current', so we can turn that into 'main'"---if our worktree is 'main', it is also 'current' and does not have to be turned into 'main' (even though it does not hurt).

The above may be a wrong suggestion, as it was solely guided by my reading of the posted code that looked as if it wanted to support something like "main-worktree/worktrees/foo/refs/heads/main". If that wasn't the intention, and we only want to support

1. a ref spelled in the traditional way before multiple worktree feature,
2. 1., with "main-worktree/" prefixed, or
3. 1., with "worktrees/<worktreename>/" prefixed

then a better approach would be to have a small helper parse_local_worktree_ref() and make the primary one into something like

parse_worktree_ref()

{
        if (begins with "main-worktree/") {	
		strip main-worktree/ prefix;
		switch (parse_local_worktree_ref(input minus prefix)) {
		... the same switch to turn "ours" into "main's" ...
		... but we probably want to special case if we are ...
		... the main worktree ...
		}
	}
	else if (begins with "worktrees/") {
		strip worktrees/ prefix and learn worktree name;
		switch (parse_local_worktree_ref(input minus prefix)) {
		... the same switch to turn "ours" into "theirs" ...
		... but we probably want to special case if we are ...
		... the worktree in question ...
		}
	}
	return parse_local_worktree_ref(input);
}

and have parse_local_worktree_ref() handle psuedorefs, per-worktree-refs.

Thanks, good idea. I'm sending you a v2.

Han-Wen Nienhuys - Google Munich
I work 80%. Don't expect answers from me on Fridays.
--
Google Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich
Registergericht und -nummer: Hamburg, HRB 86891
Sitz der Gesellschaft: Hamburg
Geschäftsführer: Paul Manicle, Liana Sebastian

Hmph, is that "v2" <[email protected]> or is there another version of it?

I think so.

Did I do something wrong?

Han-Wen Nienhuys - Google Munich
I work 80%. Don't expect answers from me on Fridays.
--
Google Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich
Registergericht und -nummer: Hamburg, HRB 86891
Sitz der Gesellschaft: Hamburg
Geschäftsführer: Paul Manicle, Liana Sebastian

Not "wrong" per-se, but I was surprised by the patch that looked quite different from what I expected from your response to the "small helper" suggestion.

From: Han-Wen Nienhuys <[email protected]>

The logic to handle worktree refs (worktrees/NAME/REF and main-worktree/REF) existed in two places:

* ref_type() in refs.c

* parse_worktree_ref() in worktree.c

Collapse this logic together in one function parse_worktree_ref():
this avoids having to cross-check the result of parse_worktree_ref() and ref_type().

Introduce enum ref_worktree_type, which is slightly different from enum ref_type. The latter is a misleading name (one would think that 'ref_type' would have the symref option).

Instead, enum ref_worktree_type only makes explicit how a refname relates to a worktree. From this point of view, HEAD and refs/bisect/abc are the same: they specify the current worktree implicitly.

The files-backend must avoid packing refs/bisect/* and friends into packed-refs, so expose is_per_worktree_ref() separately.

---
refs: unify parse_worktree_ref() and ref_type()

The logic to handle worktree refs (worktrees/NAME/REF and main-worktree/REF) existed in two places:

* ref_type() in refs.c

* parse_worktree_ref() in worktree.c

Collapse this logic together in one function parse_worktree_ref(): this avoids having to cross-check the result of parse_worktree_ref() and ref_type().

Introduce enum ref_worktree_type, which is slightly different from enum ref_type. The latter is a misleading name (one would think that 'ref_type' would have the symref option).

Instead, enum ref_worktree_type only makes explicit how a refname relates to a worktree. From this point of view, HEAD and refs/bisect/abc are the same: they specify the current worktree implicitly.

The files-backend must avoid packing refs/bisect/* and friends into packed-refs, so expose is_per_worktree_ref() separately.

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-1325%2Fhanwen%2Fparse-worktree-ref-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-1325/hanwen/parse-worktree-ref-v2
Pull-Request: https://github.com/git/git/pull/1325

Range-diff vs v1:

1: e2d19b80f76 ! 1: b1e6dc0edc7 refs: unify parse_worktree_ref() and ref_type()

     @@ refs.c: static int is_pseudoref_syntax(const char *refname)
       			return 0;
       	}
       
     -+	/* HEAD is not a pseudoref, but it certainly uses the
     -+	 * pseudoref syntax. */
     ++	/*
     ++	 * HEAD is not a pseudoref, but it certainly uses the
     ++	 * pseudoref syntax.
     ++	 */
       	return 1;
       }
       
      -static int is_main_pseudoref_syntax(const char *refname)
     -+enum ref_worktree_type parse_worktree_ref(const char *worktree_ref,
     -+					  const char **name, int *name_length,
     -+					  const char **ref)
     - {
     +-{
      -	return skip_prefix(refname, "main-worktree/", &refname) &&
      -		*refname &&
      -		is_pseudoref_syntax(refname);
     --}
     -+	const char *name_dummy;
     -+	int name_length_dummy;
     -+	const char *ref_dummy;
     -+	if (!name)
     -+		name = &name_dummy;
     -+	if (!name_length)
     -+		name_length = &name_length_dummy;
     -+	if (!ref)
     -+		ref = &ref_dummy;
     ++static int is_current_worktree_ref(const char *ref) {
     ++	return is_pseudoref_syntax(ref) || is_per_worktree_ref(ref);
     + }
       
      -static int is_other_pseudoref_syntax(const char *refname)
     --{
     ++enum ref_worktree_type parse_worktree_ref(const char *maybe_worktree_ref,
     ++					  const char **worktree_name, int *worktree_name_length,
     ++					  const char **bare_refname)
     + {
      -	if (!skip_prefix(refname, "worktrees/", &refname))
      -		return 0;
      -	refname = strchr(refname, '/');
     @@ refs.c: static int is_pseudoref_syntax(const char *refname)
      -		return 0;
      -	return is_pseudoref_syntax(refname + 1);
      -}
     -+	*ref = worktree_ref;
     -+	if (is_pseudoref_syntax(worktree_ref)) {
     -+		return REF_WORKTREE_CURRENT;
     -+	}
     ++	const char *name_dummy;
     ++	int name_length_dummy;
     ++	const char *ref_dummy;
       
      -enum ref_type ref_type(const char *refname)
      -{
     @@ refs.c: static int is_pseudoref_syntax(const char *refname)
      -	if (is_other_pseudoref_syntax(refname))
      -		return REF_TYPE_OTHER_PSEUDOREF;
      -	return REF_TYPE_NORMAL;
     -+	if (is_per_worktree_ref(worktree_ref)) {
     -+		return REF_WORKTREE_CURRENT;
     -+	}
     ++	if (!worktree_name)
     ++		worktree_name = &name_dummy;
     ++	if (!worktree_name_length)
     ++		worktree_name_length = &name_length_dummy;
     ++	if (!bare_refname)
     ++		bare_refname = &ref_dummy;
      +
     -+	if (skip_prefix(worktree_ref, "main-worktree/", &worktree_ref)) {
     -+		if (!*worktree_ref)
     -+			return -1;
     -+		*name = NULL;
     -+		*name_length = 0;
     -+		*ref = worktree_ref;
     ++	if (skip_prefix(maybe_worktree_ref, "worktrees/", bare_refname)) {
     ++		const char *slash = strchr(*bare_refname, '/');
      +
     -+		if (parse_worktree_ref(*ref, NULL, NULL, NULL) ==
     -+		    REF_WORKTREE_CURRENT)
     -+			return REF_WORKTREE_MAIN;
     -+	}
     -+	if (skip_prefix(worktree_ref, "worktrees/", &worktree_ref)) {
     -+		const char *slash = strchr(worktree_ref, '/');
     ++		*worktree_name = *bare_refname;
     ++		if (!slash) {
     ++			*worktree_name_length = strlen(*worktree_name);
      +
     -+		if (!slash || slash == worktree_ref || !slash[1])
     -+			return -1;
     -+		*name = worktree_ref;
     -+		*name_length = slash - worktree_ref;
     -+		*ref = slash + 1;
     ++			/* This is an error condition, and the caller tell because the bare_refname is "" */
     ++			*bare_refname = *worktree_name + *worktree_name_length;
     ++			return REF_WORKTREE_OTHER;
     ++		}
     ++
     ++		*worktree_name_length = slash - *bare_refname;
     ++		*bare_refname = slash + 1;
      +
     -+		if (parse_worktree_ref(*ref, NULL, NULL, NULL) ==
     -+		    REF_WORKTREE_CURRENT)
     ++		if (is_current_worktree_ref(*bare_refname))
      +			return REF_WORKTREE_OTHER;
      +	}
      +
     ++	*worktree_name = NULL;
     ++	*worktree_name_length = 0;
     ++
     ++	if (skip_prefix(maybe_worktree_ref, "main-worktree/", bare_refname)
     ++	    && is_current_worktree_ref(*bare_refname))
     ++		return REF_WORKTREE_MAIN;
     ++
     ++	*bare_refname = maybe_worktree_ref;
     ++	if (is_current_worktree_ref(maybe_worktree_ref))
     ++		return REF_WORKTREE_CURRENT;
     ++
      +	return REF_WORKTREE_SHARED;
       }
       
     @@ refs.h: int parse_hide_refs_config(const char *var, const char *value, const cha
      +	REF_WORKTREE_CURRENT, /* implicitly per worktree, eg. HEAD or
      +				 refs/bisect/SOMETHING */
      +	REF_WORKTREE_MAIN, /* explicitly in main worktree, eg.
     -+			      refs/main-worktree/HEAD */
     ++			      main-worktree/HEAD */
      +	REF_WORKTREE_OTHER, /* explicitly in named worktree, eg.
     -+			       refs/worktrees/bla/HEAD */
     ++			       worktrees/bla/HEAD */
      +	REF_WORKTREE_SHARED, /* the default, eg. refs/heads/main */
       };
       
      -enum ref_type ref_type(const char *refname);
     -+/* Parse a ref that possibly explicitly refers to a worktree ref
     -+ * (ie. either REFNAME, main-worktree/REFNAME or
     -+ * worktree/WORKTREE/REFNAME). If the name references a worktree
     -+ * implicitly or explicitly, return what kind it was. The
     -+ * worktree_name, worktree_name_length and refname argument maybe NULL.
     ++/*
     ++ * Parse a `maybe_worktree_ref` as a ref that possibly refers to a worktree ref
     ++ * (ie. either REFNAME, main-worktree/REFNAME or worktree/WORKTREE/REFNAME). It
     ++ * returns what kind of ref was found, and in case of REF_WORKTREE_OTHER, the
     ++ * worktree name is returned in `worktree_name` (pointing into
     ++ * `maybe_worktree_ref`) and `worktree_name_length`. The bare refname (the
     ++ * refname stripped of prefixes) is returned in `bare_refname`. The
     ++ * `worktree_name`, `worktree_name_length` and `bare_refname` arguments may be
     ++ * NULL.
      + */
      +enum ref_worktree_type parse_worktree_ref(const char *maybe_worktree_ref,
      +					  const char **worktree_name,
      +					  int *worktree_name_length,
     -+					  const char **refname);
     ++					  const char **bare_refname);
       
       enum expire_reflog_flags {
       	EXPIRE_REFLOGS_DRY_RUN = 1 << 0,

 builtin/reflog.c      |  3 +-
 reflog.c              | 13 ++-----
 refs.c                | 76 ++++++++++++++++++++++++++--------------
 refs.h                | 33 ++++++++++++++----
 refs/files-backend.c  | 80 +++++++++++++++++++------------------------
 refs/packed-backend.c |  2 +-
 worktree.c            | 59 ++++---------------------------
 worktree.h            | 10 ------
 8 files changed, 126 insertions(+), 150 deletions(-)

index 9407f835cb6..bd568d2d931 100644
@@ -26,7 +26,8 @@ static int collect_reflog(const char *ref, const struct object_id *oid, int unus
 	 * Avoid collecting the same shared ref multiple times because
 	 * they are available via all worktrees.
 	 */
-	if (!worktree->is_current && ref_type(ref) == REF_TYPE_NORMAL)
+	if (!worktree->is_current &&
+	    parse_worktree_ref(ref, NULL, NULL, NULL) == REF_WORKTREE_SHARED)
 		return 0;
 
 	strbuf_worktree_ref(worktree, &newref, ref);

index 47ba8620c56..0b8b767f97c 100644
@@ -310,16 +310,9 @@ static int push_tip_to_list(const char *refname, const struct object_id *oid,
 
 static int is_head(const char *refname)
 {
-	switch (ref_type(refname)) {
-	case REF_TYPE_OTHER_PSEUDOREF:
-	case REF_TYPE_MAIN_PSEUDOREF:
-		if (parse_worktree_ref(refname, NULL, NULL, &refname))
-			BUG("not a worktree ref: %s", refname);
-		break;
-	default:
-		break;
-	}
-	return !strcmp(refname, "HEAD");
+	const char *stripped_refname;
+	parse_worktree_ref(refname, NULL, NULL, &stripped_refname);
+	return !strcmp(stripped_refname, "HEAD");
 }
 
 void reflog_expiry_prepare(const char *refname,

index 23479c7ee09..a42957a7917 100644
@@ -825,15 +825,34 @@ int parse_hide_refs_config(const char *var, const char *value, const char *);
  */
 int ref_is_hidden(const char *, const char *);
 
-enum ref_type {
-	REF_TYPE_PER_WORKTREE,	  /* refs inside refs/ but not shared       */
-	REF_TYPE_PSEUDOREF,	  /* refs outside refs/ in current worktree */
-	REF_TYPE_MAIN_PSEUDOREF,  /* pseudo refs from the main worktree     */
-	REF_TYPE_OTHER_PSEUDOREF, /* pseudo refs from other worktrees       */
-	REF_TYPE_NORMAL,	  /* normal/shared refs inside refs/        */
+/* Is this a per-worktree ref living in the refs/ namespace? */
+int is_per_worktree_ref(const char *refname);
+
+/* Describes how a refname relates to worktrees */
+enum ref_worktree_type {
+	REF_WORKTREE_CURRENT, /* implicitly per worktree, eg. HEAD or
+				 refs/bisect/SOMETHING */
+	REF_WORKTREE_MAIN, /* explicitly in main worktree, eg.
+			      main-worktree/HEAD */
+	REF_WORKTREE_OTHER, /* explicitly in named worktree, eg.
+			       worktrees/bla/HEAD */
+	REF_WORKTREE_SHARED, /* the default, eg. refs/heads/main */
 };
 
-enum ref_type ref_type(const char *refname);
+/*
+ * Parse a `maybe_worktree_ref` as a ref that possibly refers to a worktree ref
+ * (ie. either REFNAME, main-worktree/REFNAME or worktree/WORKTREE/REFNAME). It
+ * returns what kind of ref was found, and in case of REF_WORKTREE_OTHER, the
+ * worktree name is returned in `worktree_name` (pointing into
+ * `maybe_worktree_ref`) and `worktree_name_length`. The bare refname (the
+ * refname stripped of prefixes) is returned in `bare_refname`. The
+ * `worktree_name`, `worktree_name_length` and `bare_refname` arguments may be
+ * NULL.
+ */
+enum ref_worktree_type parse_worktree_ref(const char *maybe_worktree_ref,
+					  const char **worktree_name,
+					  int *worktree_name_length,
+					  const char **bare_refname);
 
 enum expire_reflog_flags {
 	EXPIRE_REFLOGS_DRY_RUN = 1 << 0,

index 66c4574c99d..bf0e63ae70c 100644
@@ -862,7 +862,7 @@ static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator)
 
 	while ((ok = next_record(iter)) == ITER_OK) {
 		if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY &&
-		    ref_type(iter->base.refname) != REF_TYPE_PER_WORKTREE)
+		    !is_per_worktree_ref(iter->base.refname))
 			continue;
 
 		if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&

index e9e839926b0..9dcea6fc8c1 100644
@@ -166,16 +166,6 @@ const char *worktree_git_path(const struct worktree *wt,
 			      const char *fmt, ...)
 	__attribute__((format (printf, 2, 3)));
 
-/*
- * Parse a worktree ref (i.e. with prefix main-worktree/ or
- * worktrees/) and return the position of the worktree's name and
- * length (or NULL and zero if it's main worktree), and ref.
- *
- * All name, name_length and ref arguments could be NULL.
- */
-int parse_worktree_ref(const char *worktree_ref, const char **name,
-		       int *name_length, const char **ref);
-
 /*
  * Return a refname suitable for access from the current ref store.
  */

base-commit: 805e0a68082a217f0112db9ee86a022227a9c81b

gitgitgadget