Adjust naming: referenced lid -> target lid.

12 files changed, 151 insertions, 151 deletions

diff --git a/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp b/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp
index 07fb14c809b..def939aa725 100644
--- a/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp
+++ b/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp
@@ -133,24 +133,24 @@ struct Fixture
         EXPECT_EQUAL(toGid(str), *gid);
     }
 
-    void assertRefLid(uint32_t doc, uint32_t expReferencedLid) {
+    void assertTargetLid(uint32_t doc, uint32_t expTargetLid) {
         auto ref = getRef(doc);
         EXPECT_TRUE(ref != nullptr);
-        EXPECT_EQUAL(expReferencedLid, ref->lid());
-        EXPECT_EQUAL(expReferencedLid, _attr->getReferencedLid(doc));
+        EXPECT_EQUAL(expTargetLid, ref->lid());
+        EXPECT_EQUAL(expTargetLid, _attr->getTargetLid(doc));
     }
 
-    void assertNoRefLid(uint32_t doc) {
+    void assertNoTargetLid(uint32_t doc) {
         auto ref = getRef(doc);
         EXPECT_TRUE(ref == nullptr);
-        EXPECT_EQUAL(0u, _attr->getReferencedLid(doc));
+        EXPECT_EQUAL(0u, _attr->getTargetLid(doc));
     }
 
-    void assertLids(uint32_t referencedLid, std::vector<uint32_t> expLids)
+    void assertLids(uint32_t targetLid, std::vector<uint32_t> expLids)
     {
         std::vector<uint32_t> lids;
         LidCollector collector(lids);
-        _attr->foreach_lid(referencedLid, collector);
+        _attr->foreach_lid(targetLid, collector);
         EXPECT_EQUAL(expLids, lids);
     }
 
@@ -190,7 +190,7 @@ struct Fixture
     }
     void setGidToLidMapperFactory(std::shared_ptr<MyGidToLidMapperFactory> factory) {
         _attr->setGidToLidMapperFactory(factory);
-        _attr->populateReferencedLids();
+        _attr->populateTargetLids();
     }
     uint32_t getUniqueGids() {
         return getStatus().getNumUniqueValues();
@@ -290,7 +290,7 @@ TEST_F("require that we can save and load attribute", Fixture)
     EXPECT_TRUE(vespalib::unlink("test.udat"));
 }
 
-TEST_F("require that update() uses gid-mapper to set referenced lid", Fixture)
+TEST_F("require that update() uses gid-mapper to set target lid", Fixture)
 {
     f.ensureDocIdLimit(6);
     auto factory = std::make_shared<MyGidToLidMapperFactory>();
@@ -300,11 +300,11 @@ TEST_F("require that update() uses gid-mapper to set referenced lid", Fixture)
     f.set(4, toGid(doc1));
     f.set(5, toGid(doc3));
     f.commit();
-    TEST_DO(f.assertRefLid(1, 10));
-    TEST_DO(f.assertRefLid(2, 17));
-    TEST_DO(f.assertNoRefLid(3));
-    TEST_DO(f.assertRefLid(4, 10));
-    TEST_DO(f.assertRefLid(5, 0));
+    TEST_DO(f.assertTargetLid(1, 10));
+    TEST_DO(f.assertTargetLid(2, 17));
+    TEST_DO(f.assertNoTargetLid(3));
+    TEST_DO(f.assertTargetLid(4, 10));
+    TEST_DO(f.assertTargetLid(5, 0));
 }
 
 TEST_F("require that notifyReferencedPut() updates lid-2-lid mapping", Fixture)
@@ -314,20 +314,20 @@ TEST_F("require that notifyReferencedPut() updates lid-2-lid mapping", Fixture)
     f.set(2, toGid(doc2));
     f.set(3, toGid(doc1));
     f.commit();
-    TEST_DO(f.assertRefLid(1, 0));
-    TEST_DO(f.assertRefLid(2, 0));
-    TEST_DO(f.assertRefLid(3, 0));
+    TEST_DO(f.assertTargetLid(1, 0));
+    TEST_DO(f.assertTargetLid(2, 0));
+    TEST_DO(f.assertTargetLid(3, 0));
     f.notifyReferencedPut(toGid(doc1), 10);
     f.notifyReferencedPut(toGid(doc2), 20);
     f.notifyReferencedPut(toGid(doc3), 30);
-    TEST_DO(f.assertRefLid(1, 10));
-    TEST_DO(f.assertRefLid(2, 20));
-    TEST_DO(f.assertRefLid(3, 10));
+    TEST_DO(f.assertTargetLid(1, 10));
+    TEST_DO(f.assertTargetLid(2, 20));
+    TEST_DO(f.assertTargetLid(3, 10));
 }
 
 namespace {
 
-void preparePopulateReferencedLids(Fixture &f)
+void preparePopulateTargetLids(Fixture &f)
 {
     f.ensureDocIdLimit(6);
     f.set(1, toGid(doc1));
@@ -335,22 +335,22 @@ void preparePopulateReferencedLids(Fixture &f)
     f.set(3, toGid(doc1));
     f.set(4, toGid(doc3));
     f.commit();
-    TEST_DO(f.assertRefLid(1, 0));
-    TEST_DO(f.assertRefLid(2, 0));
-    TEST_DO(f.assertRefLid(3, 0));
-    TEST_DO(f.assertRefLid(4, 0));
-    TEST_DO(f.assertNoRefLid(5));
+    TEST_DO(f.assertTargetLid(1, 0));
+    TEST_DO(f.assertTargetLid(2, 0));
+    TEST_DO(f.assertTargetLid(3, 0));
+    TEST_DO(f.assertTargetLid(4, 0));
+    TEST_DO(f.assertNoTargetLid(5));
 }
 
-void checkPopulateReferencedLids(Fixture &f)
+void checkPopulateTargetLids(Fixture &f)
 {
     auto factory = std::make_shared<MyGidToLidMapperFactory>();
     f.setGidToLidMapperFactory(factory);
-    TEST_DO(f.assertRefLid(1, 10));
-    TEST_DO(f.assertRefLid(2, 17));
-    TEST_DO(f.assertRefLid(3, 10));
-    TEST_DO(f.assertRefLid(4, 0));
-    TEST_DO(f.assertNoRefLid(5));
+    TEST_DO(f.assertTargetLid(1, 10));
+    TEST_DO(f.assertTargetLid(2, 17));
+    TEST_DO(f.assertTargetLid(3, 10));
+    TEST_DO(f.assertTargetLid(4, 0));
+    TEST_DO(f.assertNoTargetLid(5));
     TEST_DO(f.assertLids(0, { }));
     TEST_DO(f.assertLids(10, { 1, 3}));
     TEST_DO(f.assertLids(17, { 2 }));
@@ -359,25 +359,25 @@ void checkPopulateReferencedLids(Fixture &f)
 
 }
 
-TEST_F("require that populateReferencedLids() uses gid-mapper to update lid-2-lid mapping", Fixture)
+TEST_F("require that populateTargetLids() uses gid-mapper to update lid-2-lid mapping", Fixture)
 {
-    TEST_DO(preparePopulateReferencedLids(f));
-    TEST_DO(checkPopulateReferencedLids(f));
+    TEST_DO(preparePopulateTargetLids(f));
+    TEST_DO(checkPopulateTargetLids(f));
 }
 
-TEST_F("require that populateReferencedLids() uses gid-mapper to update lid-2-lid mapping after load", Fixture)
+TEST_F("require that populateTargetLids() uses gid-mapper to update lid-2-lid mapping after load", Fixture)
 {
-    TEST_DO(preparePopulateReferencedLids(f));
+    TEST_DO(preparePopulateTargetLids(f));
     f.save();
     f.load();
-    TEST_DO(checkPopulateReferencedLids(f));
+    TEST_DO(checkPopulateTargetLids(f));
     EXPECT_TRUE(vespalib::unlink("test.dat"));
     EXPECT_TRUE(vespalib::unlink("test.udat"));
 }
 
 TEST_F("Require that notifyReferencedPut and notifyReferencedRemove changes reverse mapping", Fixture)
 {
-    TEST_DO(preparePopulateReferencedLids(f));
+    TEST_DO(preparePopulateTargetLids(f));
     TEST_DO(f.assertLids(10, { }));
     TEST_DO(f.assertLids(11, { }));
     f.notifyReferencedPut(toGid(doc1), 10);
@@ -400,21 +400,21 @@ TEST_F("Require that we track unique gids", Fixture)
     f.set(1, toGid(doc1));
     f.commit();
     EXPECT_EQUAL(1u, f.getUniqueGids());
-    TEST_DO(f.assertRefLid(1, 10));
+    TEST_DO(f.assertTargetLid(1, 10));
     TEST_DO(f.assertLids(10, { 1 }));
     f.set(2, toGid(doc2));
     f.commit();
     EXPECT_EQUAL(2u, f.getUniqueGids());
-    TEST_DO(f.assertRefLid(2, 0));
+    TEST_DO(f.assertTargetLid(2, 0));
     f.notifyReferencedPut(toGid(doc2), 17);
     EXPECT_EQUAL(2u, f.getUniqueGids());
-    TEST_DO(f.assertRefLid(2, 17));
+    TEST_DO(f.assertTargetLid(2, 17));
     TEST_DO(f.assertLids(17, { 2 }));
     f.clear(1);
     f.notifyReferencedRemove(toGid(doc2));
     EXPECT_EQUAL(2u, f.getUniqueGids());
-    TEST_DO(f.assertNoRefLid(1));
-    TEST_DO(f.assertRefLid(2, 0));
+    TEST_DO(f.assertNoTargetLid(1));
+    TEST_DO(f.assertTargetLid(2, 0));
     TEST_DO(f.assertLids(10, { }));
     TEST_DO(f.assertLids(17, { }));
     f.clear(2);
diff --git a/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.cpp b/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.cpp
index 05bc4c7c275..e6dacde3600 100644
--- a/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.cpp
@@ -15,13 +15,13 @@ ImportedAttributeVectorReadGuard::ImportedAttributeVectorReadGuard(
     : AttributeReadGuard(this),
       _target_document_meta_store_read_guard(imported_attribute.getTargetDocumentMetaStore()->getReadGuard()),
       _imported_attribute(imported_attribute),
-      _referencedLids(),
+      _targetLids(),
       _reference_attribute_guard(imported_attribute.getReferenceAttribute()),
       _target_attribute_guard(imported_attribute.getTargetAttribute()->makeReadGuard(stableEnumGuard)),
       _reference_attribute(*imported_attribute.getReferenceAttribute()),
       _target_attribute(*_target_attribute_guard->attribute())
 {
-    _referencedLids = _reference_attribute.getReferencedLids();
+    _targetLids = _reference_attribute.getTargetLids();
 }
 
 ImportedAttributeVectorReadGuard::~ImportedAttributeVectorReadGuard() {
@@ -36,7 +36,7 @@ uint32_t ImportedAttributeVectorReadGuard::getNumDocs() const {
 }
 
 uint32_t ImportedAttributeVectorReadGuard::getValueCount(uint32_t doc) const {
-    return _target_attribute.getValueCount(getReferencedLid(doc));
+    return _target_attribute.getValueCount(getTargetLid(doc));
 }
 
 uint32_t ImportedAttributeVectorReadGuard::getMaxValueCount() const {
@@ -44,55 +44,55 @@ uint32_t ImportedAttributeVectorReadGuard::getMaxValueCount() const {
 }
 
 IAttributeVector::largeint_t ImportedAttributeVectorReadGuard::getInt(DocId doc) const {
-    return _target_attribute.getInt(getReferencedLid(doc));
+    return _target_attribute.getInt(getTargetLid(doc));
 }
 
 double ImportedAttributeVectorReadGuard::getFloat(DocId doc) const {
-    return _target_attribute.getFloat(getReferencedLid(doc));
+    return _target_attribute.getFloat(getTargetLid(doc));
 }
 
 const char *ImportedAttributeVectorReadGuard::getString(DocId doc, char *buffer, size_t sz) const {
-    return _target_attribute.getString(getReferencedLid(doc), buffer, sz);
+    return _target_attribute.getString(getTargetLid(doc), buffer, sz);
 }
 
 IAttributeVector::EnumHandle ImportedAttributeVectorReadGuard::getEnum(DocId doc) const {
-    return _target_attribute.getEnum(getReferencedLid(doc));
+    return _target_attribute.getEnum(getTargetLid(doc));
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, largeint_t *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, double *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, const char **buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, EnumHandle *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, WeightedInt *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, WeightedFloat *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, WeightedString *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, WeightedConstChar *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 uint32_t ImportedAttributeVectorReadGuard::get(DocId docId, WeightedEnum *buffer, uint32_t sz) const {
-    return _target_attribute.get(getReferencedLid(docId), buffer, sz);
+    return _target_attribute.get(getTargetLid(docId), buffer, sz);
 }
 
 bool ImportedAttributeVectorReadGuard::findEnum(const char *value, EnumHandle &e) const {
@@ -153,14 +153,14 @@ long ImportedAttributeVectorReadGuard::onSerializeForAscendingSort(DocId doc,
                                                                    void *serTo,
                                                                    long available,
                                                                    const common::BlobConverter *bc) const {
-    return _target_attribute.serializeForAscendingSort(getReferencedLid(doc), serTo, available, bc);
+    return _target_attribute.serializeForAscendingSort(getTargetLid(doc), serTo, available, bc);
 }
 
 long ImportedAttributeVectorReadGuard::onSerializeForDescendingSort(DocId doc,
                                                                     void *serTo,
                                                                     long available,
                                                                     const common::BlobConverter *bc) const {
-    return _target_attribute.serializeForDescendingSort(getReferencedLid(doc), serTo, available, bc);
+    return _target_attribute.serializeForDescendingSort(getTargetLid(doc), serTo, available, bc);
 }
 
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.h b/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.h
index 07ea472cab0..2622f091cf1 100644
--- a/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.h
+++ b/searchlib/src/vespa/searchlib/attribute/imported_attribute_vector_read_guard.h
@@ -19,20 +19,20 @@ class ReferenceAttribute;
  *
  * Read guards are held on
  * - target attribute, to ensure that reads are safe.
- * - target document meta store, to avoid referenced lids being reused.
+ * - target document meta store, to avoid target lids being reused.
  * - reference attribute, to ensure that access to lid mapping is safe.
  *
- * Extra information for direct lid to referenced lid mapping with
+ * Extra information for direct lid to target lid mapping with
  * boundary check is setup during construction.
  */
 class ImportedAttributeVectorReadGuard : public IAttributeVector,
                                          public AttributeReadGuard
 {
 private:
-    using ReferencedLids = vespalib::ConstArrayRef<uint32_t>;
+    using TargetLids = vespalib::ConstArrayRef<uint32_t>;
     IDocumentMetaStoreContext::IReadGuard::UP _target_document_meta_store_read_guard;
     const ImportedAttributeVector   &_imported_attribute;
-    ReferencedLids                   _referencedLids;
+    TargetLids                       _targetLids;
     AttributeGuard                   _reference_attribute_guard;
     std::unique_ptr<attribute::AttributeReadGuard> _target_attribute_guard;
     const ReferenceAttribute        &_reference_attribute;
@@ -40,8 +40,8 @@ protected:
     const IAttributeVector          &_target_attribute;
 
 protected:
-    uint32_t getReferencedLid(uint32_t lid) const {
-        return _referencedLids[lid];
+    uint32_t getTargetLid(uint32_t lid) const {
+        return _targetLids[lid];
     }
 
 public:
diff --git a/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp b/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
index 6a78a87e20b..aac6727ca9f 100644
--- a/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
@@ -36,7 +36,7 @@ ImportedSearchContext::ImportedSearchContext(
       _reference_attribute(*_imported_attribute.getReferenceAttribute()),
       _target_attribute(target_attribute),
       _target_search_context(_target_attribute.createSearchContext(std::move(term), params)),
-      _referencedLids(_reference_attribute.getReferencedLids()),
+      _targetLids(_reference_attribute.getTargetLids()),
       _merger(_reference_attribute.getCommittedDocIdLimit()),
       _fetchPostingsDone(false)
 {
diff --git a/searchlib/src/vespa/searchlib/attribute/imported_search_context.h b/searchlib/src/vespa/searchlib/attribute/imported_search_context.h
index e7f4c89fc46..f8b434d4c6c 100644
--- a/searchlib/src/vespa/searchlib/attribute/imported_search_context.h
+++ b/searchlib/src/vespa/searchlib/attribute/imported_search_context.h
@@ -26,7 +26,7 @@ class SearchContextParams;
  * considered a match.
  */
 class ImportedSearchContext : public ISearchContext {
-    using ReferencedLids = vespalib::ConstArrayRef<uint32_t>;
+    using TargetLids = vespalib::ConstArrayRef<uint32_t>;
     const ImportedAttributeVector&                  _imported_attribute;
     vespalib::string                                _queryTerm;
     bool                                            _useSearchCache;
@@ -35,12 +35,12 @@ class ImportedSearchContext : public ISearchContext {
     const ReferenceAttribute&                       _reference_attribute;
     const IAttributeVector                         &_target_attribute;
     std::unique_ptr<ISearchContext>                 _target_search_context;
-    ReferencedLids                                  _referencedLids;
+    TargetLids                                      _targetLids;
     PostingListMerger<int32_t>                      _merger;
     bool                                            _fetchPostingsDone;
 
-    uint32_t getReferencedLid(uint32_t lid) const {
-        return _referencedLids[lid];
+    uint32_t getTargetLid(uint32_t lid) const {
+        return _targetLids[lid];
     }
 
     void makeMergedPostings(bool isFilter);
@@ -65,11 +65,11 @@ public:
     using DocId = IAttributeVector::DocId;
 
     bool cmp(DocId docId, int32_t& weight) const {
-        return _target_search_context->cmp(getReferencedLid(docId), weight);
+        return _target_search_context->cmp(getTargetLid(docId), weight);
     }
 
     bool cmp(DocId docId) const {
-        return _target_search_context->cmp(getReferencedLid(docId));
+        return _target_search_context->cmp(getTargetLid(docId));
     }
 
     bool onCmp(uint32_t docId, int32_t &weight) const override { return cmp(docId, weight); }
diff --git a/searchlib/src/vespa/searchlib/attribute/reference.h b/searchlib/src/vespa/searchlib/attribute/reference.h
index db8c94b4a11..8d482c7c3c9 100644
--- a/searchlib/src/vespa/searchlib/attribute/reference.h
+++ b/searchlib/src/vespa/searchlib/attribute/reference.h
@@ -14,7 +14,7 @@ class Reference {
     using EntryRef = search::datastore::EntryRef;
     using GlobalId = document::GlobalId;
     GlobalId _gid;
-    mutable uint32_t _lid;  // referenced lid
+    mutable uint32_t _lid;  // target lid
     mutable EntryRef _revMapIdx; // map from gid to lids referencing gid
 public:
     Reference()
@@ -35,7 +35,7 @@ public:
     const GlobalId &gid() const { return _gid; }
     uint32_t lid() const { return _lid; }
     EntryRef revMapIdx() const { return _revMapIdx; }
-    void setLid(uint32_t referencedLid) const { _lid = referencedLid; }
+    void setLid(uint32_t targetLid) const { _lid = targetLid; }
     void setRevMapIdx(EntryRef newRevMapIdx) const { _revMapIdx = newRevMapIdx; }
 };
 
diff --git a/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp b/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp
index f286d7a5fa4..1566ca47eb1 100644
--- a/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp
@@ -317,22 +317,22 @@ ReferenceAttribute::setGidToLidMapperFactory(std::shared_ptr<IGidToLidMapperFact
 }
 
 void
-ReferenceAttribute::notifyReferencedPutNoCommit(const GlobalId &gid, DocId referencedLid)
+ReferenceAttribute::notifyReferencedPutNoCommit(const GlobalId &gid, DocId targetLid)
 {
-    assert(referencedLid != 0);
+    assert(targetLid != 0);
     EntryRef ref = _store.find(gid);
     if (!ref.valid() || _store.get(ref).lid() == 0) {
         Reference refToAdd(gid);
         ref = _store.add(refToAdd).ref();
     }
     const auto &entry = _store.get(ref);
-    _referenceMappings.notifyReferencedPut(entry, referencedLid);
+    _referenceMappings.notifyReferencedPut(entry, targetLid);
 }
 
 void
-ReferenceAttribute::notifyReferencedPut(const GlobalId &gid, DocId referencedLid)
+ReferenceAttribute::notifyReferencedPut(const GlobalId &gid, DocId targetLid)
 {
-    notifyReferencedPutNoCommit(gid, referencedLid);
+    notifyReferencedPutNoCommit(gid, targetLid);
     commit();
 }
 
@@ -342,9 +342,9 @@ ReferenceAttribute::notifyReferencedRemove(const GlobalId &gid)
     EntryRef ref = _store.find(gid);
     if (ref.valid()) {
         const auto &entry = _store.get(ref);
-        uint32_t oldReferencedLid = entry.lid();
+        uint32_t oldTargetLid = entry.lid();
         _referenceMappings.notifyReferencedRemove(entry);
-        if (oldReferencedLid != 0) {
+        if (oldTargetLid != 0) {
             _store.remove(ref);
         }
         commit();
@@ -353,16 +353,16 @@ ReferenceAttribute::notifyReferencedRemove(const GlobalId &gid)
 
 namespace {
 
-class ReferencedLidPopulator : public IGidToLidMapperVisitor
+class TargetLidPopulator : public IGidToLidMapperVisitor
 {
     ReferenceAttribute &_attr;
 public:
-    ReferencedLidPopulator(ReferenceAttribute &attr)
+    TargetLidPopulator(ReferenceAttribute &attr)
         : IGidToLidMapperVisitor(),
           _attr(attr)
     {
     }
-    virtual ~ReferencedLidPopulator() override { }
+    virtual ~TargetLidPopulator() override { }
     virtual void visit(const document::GlobalId &gid, uint32_t lid) const override {
         _attr.notifyReferencedPutNoCommit(gid, lid);
     }
@@ -371,12 +371,12 @@ public:
 }
 
 void
-ReferenceAttribute::populateReferencedLids()
+ReferenceAttribute::populateTargetLids()
 {
     if (_gidToLidMapperFactory) {
         std::unique_ptr<IGidToLidMapper> mapperUP = _gidToLidMapperFactory->getMapper();
         const IGidToLidMapper &mapper = *mapperUP;
-        ReferencedLidPopulator populator(*this);
+        TargetLidPopulator populator(*this);
         mapper.foreach(populator);
     }
     commit();
diff --git a/searchlib/src/vespa/searchlib/attribute/reference_attribute.h b/searchlib/src/vespa/searchlib/attribute/reference_attribute.h
index 7387c13fc50..65fa0e129cb 100644
--- a/searchlib/src/vespa/searchlib/attribute/reference_attribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/reference_attribute.h
@@ -17,8 +17,8 @@ namespace search::attribute {
  * and their local document ids counterpart.
  *
  * The lid-2-lid mapping is updated as follows:
- * 1) In populateReferencedLids() all referenced lids are set by using the gid-2-lid mapper.
- * 1) In update() a new lid-gid pair is set and the referenced lid is set by using gid-2-lid mapper.
+ * 1) In populateTargetLids() all target lids are set by using the gid-2-lid mapper.
+ * 1) In update() a new lid-gid pair is set and the target lid is set by using gid-2-lid mapper.
  * 2) In notifyGidToLidChange() a gid-reference-lid pair is set explicitly.
  */
 class ReferenceAttribute : public NotImplementedAttribute
@@ -35,7 +35,7 @@ public:
                                              std::less<uint32_t>,
                                              btree::BTreeDefaultTraits,
                                              btree::NoAggrCalc>;
-    using ReferencedLids = ReferenceMappings::ReferencedLids;
+    using TargetLids = ReferenceMappings::TargetLids;
     using ReverseMappingRefs = ReferenceMappings::ReverseMappingRefs;
 private:
     ReferenceStore _store;
@@ -73,22 +73,22 @@ public:
     const Reference *getReference(DocId doc);
     void setGidToLidMapperFactory(std::shared_ptr<IGidToLidMapperFactory> gidToLidMapperFactory);
     std::shared_ptr<IGidToLidMapperFactory> getGidToLidMapperFactory() const { return _gidToLidMapperFactory; }
-    ReferencedLids getReferencedLids() const { return _referenceMappings.getReferencedLids(); }
-    DocId getReferencedLid(DocId doc) const { return _referenceMappings.getReferencedLid(doc); }
+    TargetLids getTargetLids() const { return _referenceMappings.getTargetLids(); }
+    DocId getTargetLid(DocId doc) const { return _referenceMappings.getTargetLid(doc); }
     ReverseMappingRefs getReverseMappingRefs() const { return _referenceMappings.getReverseMappingRefs(); }
     const ReverseMapping &getReverseMapping() const { return _referenceMappings.getReverseMapping(); }
 
-    void notifyReferencedPutNoCommit(const GlobalId &gid, DocId referencedLid);
-    void notifyReferencedPut(const GlobalId &gid, DocId referencedLid);
+    void notifyReferencedPutNoCommit(const GlobalId &gid, DocId targetLid);
+    void notifyReferencedPut(const GlobalId &gid, DocId targetLid);
     void notifyReferencedRemove(const GlobalId &gid);
-    void populateReferencedLids();
+    void populateTargetLids();
     virtual void clearDocs(DocId lidLow, DocId lidLimit) override;
     virtual void onShrinkLidSpace() override;
 
     template <typename FunctionType>
     void
-    foreach_lid(uint32_t referencedLid, FunctionType &&func) const {
-        _referenceMappings.foreach_lid(referencedLid, std::forward<FunctionType>(func));
+    foreach_lid(uint32_t targetLid, FunctionType &&func) const {
+        _referenceMappings.foreach_lid(targetLid, std::forward<FunctionType>(func));
     }
 };
 
diff --git a/searchlib/src/vespa/searchlib/attribute/reference_mappings.cpp b/searchlib/src/vespa/searchlib/attribute/reference_mappings.cpp
index 41a2c52de1c..c473e2a40d7 100644
--- a/searchlib/src/vespa/searchlib/attribute/reference_mappings.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/reference_mappings.cpp
@@ -9,9 +9,9 @@ namespace search::attribute {
 
 ReferenceMappings::ReferenceMappings(GenerationHolder &genHolder, const uint32_t &committedDocIdLimit)
     : _reverseMappingIndices(genHolder),
-      _referencedLidLimit(0),
+      _targetLidLimit(0),
       _reverseMapping(),
-      _referencedLids(genHolder),
+      _targetLids(genHolder),
       _committedDocIdLimit(committedDocIdLimit)
 {
 }
@@ -32,24 +32,24 @@ ReferenceMappings::clearMapping(const Reference &entry)
 void
 ReferenceMappings::syncForwardMapping(const Reference &entry)
 {
-    uint32_t referencedLid = entry.lid();
+    uint32_t targetLid = entry.lid();
     EntryRef revMapIdx = entry.revMapIdx();
-    auto &referencedLids = _referencedLids;
+    auto &targetLids = _targetLids;
     _reverseMapping.foreach_unfrozen_key(revMapIdx,
-                                         [&referencedLids, referencedLid](uint32_t lid)
-                                         { referencedLids[lid] = referencedLid; });
+                                         [&targetLids, targetLid](uint32_t lid)
+                                         { targetLids[lid] = targetLid; });
 }
 
 void
 ReferenceMappings::syncReverseMappingIndices(const Reference &entry)
 {
-    uint32_t referencedLid = entry.lid();
-    if (referencedLid != 0u) {
-        _reverseMappingIndices.ensure_size(referencedLid + 1);
-        _reverseMappingIndices[referencedLid] = entry.revMapIdx();
-        if (referencedLid >= _referencedLidLimit) {
+    uint32_t targetLid = entry.lid();
+    if (targetLid != 0u) {
+        _reverseMappingIndices.ensure_size(targetLid + 1);
+        _reverseMappingIndices[targetLid] = entry.revMapIdx();
+        if (targetLid >= _targetLidLimit) {
             std::atomic_thread_fence(std::memory_order_release);
-            _referencedLidLimit = referencedLid + 1;
+            _targetLidLimit = targetLid + 1;
         }
     }
 }
@@ -62,7 +62,7 @@ ReferenceMappings::removeReverseMapping(const Reference &entry, uint32_t lid)
     std::atomic_thread_fence(std::memory_order_release);
     entry.setRevMapIdx(revMapIdx);
     syncReverseMappingIndices(entry);
-    _referencedLids[lid] = 0; // forward mapping
+    _targetLids[lid] = 0; // forward mapping
 }
 
 void
@@ -74,7 +74,7 @@ ReferenceMappings::addReverseMapping(const Reference &entry, uint32_t lid)
     std::atomic_thread_fence(std::memory_order_release);
     entry.setRevMapIdx(revMapIdx);
     syncReverseMappingIndices(entry);
-    _referencedLids[lid] = entry.lid(); // forward mapping
+    _targetLids[lid] = entry.lid(); // forward mapping
 }
 
 void
@@ -87,14 +87,14 @@ ReferenceMappings::buildReverseMapping(const Reference &entry, const std::vector
 }
 
 void
-ReferenceMappings::notifyReferencedPut(const Reference &entry, uint32_t referencedLid)
+ReferenceMappings::notifyReferencedPut(const Reference &entry, uint32_t targetLid)
 {
-    uint32_t oldReferencedLid = entry.lid();
-    if (oldReferencedLid != referencedLid) {
-        if (oldReferencedLid != 0u && oldReferencedLid < _reverseMappingIndices.size()) {
-            _reverseMappingIndices[oldReferencedLid] = EntryRef();
+    uint32_t oldTargetLid = entry.lid();
+    if (oldTargetLid != targetLid) {
+        if (oldTargetLid != 0u && oldTargetLid < _reverseMappingIndices.size()) {
+            _reverseMappingIndices[oldTargetLid] = EntryRef();
         }
-        entry.setLid(referencedLid);
+        entry.setLid(targetLid);
     }
     syncReverseMappingIndices(entry);
     syncForwardMapping(entry);
@@ -103,10 +103,10 @@ ReferenceMappings::notifyReferencedPut(const Reference &entry, uint32_t referenc
 void
 ReferenceMappings::notifyReferencedRemove(const Reference &entry)
 {
-    uint32_t oldReferencedLid = entry.lid();
-    if (oldReferencedLid != 0) {
-        if (oldReferencedLid < _reverseMappingIndices.size()) {
-            _reverseMappingIndices[oldReferencedLid] = EntryRef();
+    uint32_t oldTargetLid = entry.lid();
+    if (oldTargetLid != 0) {
+        if (oldTargetLid < _reverseMappingIndices.size()) {
+            _reverseMappingIndices[oldTargetLid] = EntryRef();
         }
         entry.setLid(0);
     }
@@ -117,27 +117,27 @@ ReferenceMappings::notifyReferencedRemove(const Reference &entry)
 void
 ReferenceMappings::onAddDocs(uint32_t docIdLimit)
 {
-    _referencedLids.reserve(docIdLimit);
+    _targetLids.reserve(docIdLimit);
 }
 
 void
 ReferenceMappings::addDoc()
 {
-    _referencedLids.push_back(0);
+    _targetLids.push_back(0);
 }
 
 void
 ReferenceMappings::onLoad(uint32_t docIdLimit)
 {
-    _referencedLids.clear();
-    _referencedLids.unsafe_reserve(docIdLimit);
-    _referencedLids.ensure_size(docIdLimit);
+    _targetLids.clear();
+    _targetLids.unsafe_reserve(docIdLimit);
+    _targetLids.ensure_size(docIdLimit);
 }
 
 void
 ReferenceMappings::shrink(uint32_t docIdLimit)
 {
-    _referencedLids.shrink(docIdLimit);
+    _targetLids.shrink(docIdLimit);
 }
 
 MemoryUsage
@@ -145,7 +145,7 @@ ReferenceMappings::getMemoryUsage()
 {
     MemoryUsage usage = _reverseMapping.getMemoryUsage();
     usage.merge(_reverseMappingIndices.getMemoryUsage());
-    usage.merge(_referencedLids.getMemoryUsage());
+    usage.merge(_targetLids.getMemoryUsage());
     return usage;
 }
 
diff --git a/searchlib/src/vespa/searchlib/attribute/reference_mappings.h b/searchlib/src/vespa/searchlib/attribute/reference_mappings.h
index 9ba6dd5853e..6d06d091129 100644
--- a/searchlib/src/vespa/searchlib/attribute/reference_mappings.h
+++ b/searchlib/src/vespa/searchlib/attribute/reference_mappings.h
@@ -26,22 +26,22 @@ class ReferenceMappings
     using generation_t = vespalib::GenerationHandler::generation_t;
 
     // Vector containing references to trees of lids referencing given
-    // referenced lid.
+    // target lid.
     ReverseMappingIndices _reverseMappingIndices;
-    // limit for referenced lid when accessing _reverseMappingIndices
-    uint32_t              _referencedLidLimit;
-    // Store of B-Trees, used to map from gid or referenced lid to
+    // limit for target lid when accessing _reverseMappingIndices
+    uint32_t              _targetLidLimit;
+    // Store of B-Trees, used to map from gid or target lid to
     // referencing lids.
     ReverseMapping _reverseMapping;
-    // vector containing referenced lid given referencing lid
-    RcuVectorBase<uint32_t> _referencedLids;
+    // vector containing target lid given referencing lid
+    RcuVectorBase<uint32_t> _targetLids;
     const uint32_t &_committedDocIdLimit;
 
     void syncForwardMapping(const Reference &entry);
     void syncReverseMappingIndices(const Reference &entry);
 
 public:
-    using ReferencedLids = vespalib::ConstArrayRef<uint32_t>;
+    using TargetLids = vespalib::ConstArrayRef<uint32_t>;
     using ReverseMappingRefs = vespalib::ConstArrayRef<EntryRef>;
 
     ReferenceMappings(GenerationHolder &genHolder, const uint32_t &committedDocIdLimit);
@@ -58,12 +58,12 @@ public:
     void transferHoldLists(generation_t generation) { _reverseMapping.transferHoldLists(generation); }
 
     // Handle mapping changes
-    void notifyReferencedPut(const Reference &entry, uint32_t referencedLid);
+    void notifyReferencedPut(const Reference &entry, uint32_t targetLid);
     void notifyReferencedRemove(const Reference &entry);
     void removeReverseMapping(const Reference &entry, uint32_t lid);
     void addReverseMapping(const Reference &entry, uint32_t lid);
 
-    // Maintain size of mapping from lid to referenced lid
+    // Maintain size of mapping from lid to target lid
     void onAddDocs(uint32_t docIdLimit);
     void addDoc();
     void onLoad(uint32_t docIdLimit);
@@ -77,28 +77,28 @@ public:
     // Reader API, reader must hold generation guard
     template <typename FunctionType>
     void
-    foreach_lid(uint32_t referencedLid, FunctionType &&func) const;
+    foreach_lid(uint32_t targetLid, FunctionType &&func) const;
 
-    ReferencedLids getReferencedLids() const {
+    TargetLids getTargetLids() const {
         uint32_t committedDocIdLimit = _committedDocIdLimit;
         std::atomic_thread_fence(std::memory_order_acquire);
-        return ReferencedLids(&_referencedLids[0], committedDocIdLimit);
+        return TargetLids(&_targetLids[0], committedDocIdLimit);
     }
-    uint32_t getReferencedLid(uint32_t doc) const { return _referencedLids[doc]; }
+    uint32_t getTargetLid(uint32_t doc) const { return _targetLids[doc]; }
     ReverseMappingRefs getReverseMappingRefs() const {
-        uint32_t referencedLidLimit = _referencedLidLimit;
+        uint32_t targetLidLimit = _targetLidLimit;
         std::atomic_thread_fence(std::memory_order_acquire);
-        return ReverseMappingRefs(&_reverseMappingIndices[0], referencedLidLimit);
+        return ReverseMappingRefs(&_reverseMappingIndices[0], targetLidLimit);
     }
     const ReverseMapping &getReverseMapping() const { return _reverseMapping; }
 };
 
 template <typename FunctionType>
 void
-ReferenceMappings::foreach_lid(uint32_t referencedLid, FunctionType &&func) const
+ReferenceMappings::foreach_lid(uint32_t targetLid, FunctionType &&func) const
 {
-    if (referencedLid < _reverseMappingIndices.size()) {
-        EntryRef revMapIdx = _reverseMappingIndices[referencedLid];
+    if (targetLid < _reverseMappingIndices.size()) {
+        EntryRef revMapIdx = _reverseMappingIndices[targetLid];
         _reverseMapping.foreach_frozen_key(revMapIdx, std::forward<FunctionType>(func));
     }
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.cpp b/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.cpp
index c6db5a76ed1..8b60f0c3e8e 100644
--- a/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.cpp
@@ -41,7 +41,7 @@ ImportedTensorAttributeVectorReadGuard::asTensorAttribute() const
 std::unique_ptr<Tensor>
 ImportedTensorAttributeVectorReadGuard::getTensor(uint32_t docId) const
 {
-    return _target_tensor_attribute.getTensor(getReferencedLid(docId));
+    return _target_tensor_attribute.getTensor(getTargetLid(docId));
 }
 
 std::unique_ptr<Tensor>
@@ -53,7 +53,7 @@ ImportedTensorAttributeVectorReadGuard::getEmptyTensor() const
 void
 ImportedTensorAttributeVectorReadGuard::getTensor(uint32_t docId, vespalib::tensor::MutableDenseTensorView &tensor) const
 {
-    _target_tensor_attribute.getTensor(getReferencedLid(docId), tensor);
+    _target_tensor_attribute.getTensor(getTargetLid(docId), tensor);
 }
 
 vespalib::eval::ValueType
diff --git a/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.h b/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.h
index d538135bb99..fce744503cd 100644
--- a/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.h
+++ b/searchlib/src/vespa/searchlib/tensor/imported_tensor_attribute_vector_read_guard.h
@@ -14,7 +14,7 @@ namespace search::tensor {
 /**
  * Short lived attribute vector for imported tensor attributes.
  *
- * Extra information for direct lid to referenced lid mapping with
+ * Extra information for direct lid to target lid mapping with
  * boundary check is setup during construction.
  */
 class ImportedTensorAttributeVectorReadGuard : public attribute::ImportedAttributeVectorReadGuard,