Merge branch 'jc/refs-symref-referent'

The refs API has been taught to give symref target information to
the users of ref iterators, allowing for-each-ref and friends to
avoid an extra ref_resolve_* API call per a symbolic ref.

* jc/refs-symref-referent:
  ref-filter: populate symref from iterator
  refs: add referent to each_ref_fn
  refs: keep track of unresolved reference value in iterators

diff --cc builtin/checkout.c
Simple merge

diff --cc builtin/describe.c
Simple merge

diff --cc builtin/name-rev.c
Simple merge

diff --cc builtin/remote.c
Simple merge

diff --cc builtin/rev-parse.c
Simple merge

diff --cc builtin/show-branch.c
Simple merge

diff --cc builtin/show-ref.c
Simple merge

diff --cc builtin/submodule--helper.c
Simple merge

diff --cc builtin/worktree.c
Simple merge

diff --cc log-tree.c
Simple merge

diff --cc object-name.c
Simple merge

diff --cc ref-filter.c
Simple merge

diff --cc reflog.c
Simple merge

diff --cc refs.c
Simple merge

diff --cc refs.h
Simple merge

diff --cc refs/files-backend.c
index 6380dff4436ae37be1ba9724c9a5a8e5e2205f96,94d1ed0e1c71010b25276b5935eb6d8cd7068500..68a3f71f70e6e6be60dca5686dc5cfdc71d26dc3
--- 1/refs/files-backend.c
--- 2/refs/files-backend.c
+++ b/refs/files-backend.c
@@@ -244,10 -245,13 +244,13 @@@ static void loose_fill_ref_dir_regular_
  {
        struct object_id oid;
        int flag;
+       const char *referent = refs_resolve_ref_unsafe(&refs->base,
+                                                      refname,
+                                                      RESOLVE_REF_READING,
+                                                      &oid, &flag);
  
-       if (!refs_resolve_ref_unsafe(&refs->base, refname, RESOLVE_REF_READING,
-                                    &oid, &flag)) {
+       if (!referent) {
 -              oidclr(&oid, the_repository->hash_algo);
 +              oidclr(&oid, refs->base.repo->hash_algo);
                flag |= REF_ISBROKEN;
        } else if (is_null_oid(&oid)) {
                /*
@@@ -264,10 -268,14 +267,14 @@@
        if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
                if (!refname_is_safe(refname))
                        die("loose refname is dangerous: %s", refname);
 -              oidclr(&oid, the_repository->hash_algo);
 +              oidclr(&oid, refs->base.repo->hash_algo);
                flag |= REF_BAD_NAME | REF_ISBROKEN;
        }
-       add_entry_to_dir(dir, create_ref_entry(refname, &oid, flag));
+ 
+       if (!(flag & REF_ISSYMREF))
+               referent = NULL;
+ 
+       add_entry_to_dir(dir, create_ref_entry(refname, referent, &oid, flag));
  }
  
  /*

diff --cc refs/refs-internal.h
Simple merge

diff --cc refs/reftable-backend.c
index bf4446afd3c571e38216527cb976337626e51f3a,50a072b97b027aafda39672796ebb59490016d00..db2ae1dfcbc8c47f4153c94e0b9748eb493b979f
--- 1/refs/reftable-backend.c
--- 2/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@@ -490,12 -492,16 +491,15 @@@ static int reftable_ref_iterator_advanc
                        break;
                case REFTABLE_REF_VAL2:
                        oidread(&iter->oid, iter->ref.value.val2.value,
 -                              the_repository->hash_algo);
 +                              refs->base.repo->hash_algo);
                        break;
                case REFTABLE_REF_SYMREF:
-                       if (!refs_resolve_ref_unsafe(&iter->refs->base, iter->ref.refname,
-                                                    RESOLVE_REF_READING, &iter->oid, &flags))
+                       referent = refs_resolve_ref_unsafe(&iter->refs->base,
 -                                                                    iter->ref.refname,
 -                                                                    RESOLVE_REF_READING,
 -                                                                    &iter->oid,
 -                                                                    &flags);
++                                                         iter->ref.refname,
++                                                         RESOLVE_REF_READING,
++                                                         &iter->oid, &flags);
+                       if (!referent)
 -                              oidclr(&iter->oid, the_repository->hash_algo);
 +                              oidclr(&iter->oid, refs->base.repo->hash_algo);
                        break;
                default:
                        BUG("unhandled reference value type %d", iter->ref.value_type);

diff --cc submodule.c
Simple merge