Merge pull request #25840 from vespa-engine/balder/deinline-searchlib

Deinline large destructors and clean up some code based on clion hints.

34 files changed, 329 insertions, 262 deletions

diff --git a/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp b/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp
index 9bc0382f3ab..839ead48908 100644
--- a/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp
+++ b/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp
@@ -69,13 +69,11 @@ private:
     Schema _schema;
     uint32_t _indexId;
 public:
-    void
-    requireThatDictionaryHandlesNoEntries(bool directio, bool readmmap);
-
-    void
-    requireThatDictionaryHandlesMultipleEntries(bool directio, bool readmmap);
+    void requireThatDictionaryHandlesNoEntries(bool directio, bool readmmap);
+    void requireThatDictionaryHandlesMultipleEntries(bool directio, bool readmmap);
 
     Test();
+    ~Test() override;
     int Main() override;
 };
 
@@ -104,8 +102,8 @@ Test::requireThatDictionaryHandlesNoEntries(bool directio, bool readmmap)
     EXPECT_TRUE(dict.open("dump/1/", tuneFileRead, bvScope));
     EXPECT_EQUAL(5u, dict.getDocIdLimit());
     EXPECT_EQUAL(0u, dict.getEntries().size());
-    EXPECT_TRUE(dict.lookup(1).get() == NULL);
-    EXPECT_TRUE(dict.lookup(2).get() == NULL);
+    EXPECT_FALSE(dict.lookup(1));
+    EXPECT_FALSE(dict.lookup(2));
 }
 
 void
@@ -162,17 +160,17 @@ Test::requireThatDictionaryHandlesMultipleEntries(bool directio, bool readmmap)
     EXPECT_EQUAL(5u, e._wordNum);
     EXPECT_EQUAL(23u, e._numDocs);
 
-    EXPECT_TRUE(dict.lookup(2).get() == NULL);
-    EXPECT_TRUE(dict.lookup(3).get() == NULL);
-    EXPECT_TRUE(dict.lookup(4).get() == NULL);
-    EXPECT_TRUE(dict.lookup(6).get() == NULL);
+    EXPECT_FALSE(dict.lookup(2));
+    EXPECT_FALSE(dict.lookup(3));
+    EXPECT_FALSE(dict.lookup(4));
+    EXPECT_FALSE(dict.lookup(6));
 
     BitVector::UP bv1act = dict.lookup(1);
-    EXPECT_TRUE(bv1act.get() != NULL);
+    EXPECT_TRUE(bv1act);
     EXPECT_TRUE(*bv1exp == *bv1act);
 
     BitVector::UP bv5act = dict.lookup(5);
-    EXPECT_TRUE(bv5act.get() != NULL);
+    EXPECT_TRUE(bv5act);
     EXPECT_TRUE(*bv5exp == *bv5act);
 }
 
@@ -183,6 +181,8 @@ Test::Test()
     _schema.addIndexField(Schema::IndexField("f1", DataType::STRING));
 }
 
+Test::~Test() = default;
+
 int
 Test::Main()
 {
diff --git a/searchlib/src/tests/docstore/store_by_bucket/store_by_bucket_test.cpp b/searchlib/src/tests/docstore/store_by_bucket/store_by_bucket_test.cpp
index b849143427c..13aa1880e8c 100644
--- a/searchlib/src/tests/docstore/store_by_bucket/store_by_bucket_test.cpp
+++ b/searchlib/src/tests/docstore/store_by_bucket/store_by_bucket_test.cpp
@@ -57,6 +57,7 @@ public:
         _lastBucketId = bucketId;
         EXPECT_EQUAL(0, memcmp(buffer, createPayload(bucketId).c_str(), sz));
     }
+    ~VerifyBucketOrder() override;
 private:
     uint32_t _lastLid;
     BucketId _lastBucketId;
@@ -64,6 +65,8 @@ private:
     vespalib::hash_set<uint64_t> _uniqueBucket;
 };
 
+VerifyBucketOrder::~VerifyBucketOrder() = default;
+
 TEST("require that StoreByBucket gives bucket by bucket and ordered within")
 {
     std::mutex backing_lock;
diff --git a/searchlib/src/tests/features/onnx_feature/onnx_feature_test.cpp b/searchlib/src/tests/features/onnx_feature/onnx_feature_test.cpp
index bf7cbeeb5a2..f6f6c62321e 100644
--- a/searchlib/src/tests/features/onnx_feature/onnx_feature_test.cpp
+++ b/searchlib/src/tests/features/onnx_feature/onnx_feature_test.cpp
@@ -179,9 +179,12 @@ struct MyIssues : Issue::Handler {
     std::vector<vespalib::string> list;
     Issue::Binding capture;
     MyIssues() : list(), capture(Issue::listen(*this)) {}
+    ~MyIssues() override;
     void handle(const Issue &issue) override { list.push_back(issue.message()); }
 };
 
+MyIssues::~MyIssues() = default;
+
 TEST_F(OnnxFeatureTest, broken_model_evaluates_to_all_zeros) {
     add_expr("in1", "tensor<float>(x[2]):[docid,5]");
     add_expr("in2", "tensor<float>(x[3]):[docid,10,31515]");
diff --git a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
index 90ee5519cc4..f5082871a3f 100644
--- a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
+++ b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
@@ -245,9 +245,12 @@ struct MyIssues : Issue::Handler {
     std::vector<vespalib::string> list;
     Issue::Binding capture;
     MyIssues() : list(), capture(Issue::listen(*this)) {}
+    ~MyIssues() override;
     void handle(const Issue &issue) override { list.push_back(issue.message()); }
 };
 
+MyIssues::~MyIssues() = default;
+
 //-----------------------------------------------------------------------------
 
 TEST_F("require expression without override works", SimpleRankFixture) {
diff --git a/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp b/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp
index b2a5cf0f4c0..89fdff7819c 100644
--- a/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp
+++ b/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp
@@ -24,9 +24,12 @@ private:
 
 public:
     Benchmark() : _timer(), _sample(0) {}
+    ~Benchmark() override;
     int Main() override;
 };
 
+Benchmark::~Benchmark() = default;
+
 void
 Benchmark::run(size_t numRuns, size_t numPositions)
 {
diff --git a/searchlib/src/tests/memoryindex/field_index/field_index_test.cpp b/searchlib/src/tests/memoryindex/field_index/field_index_test.cpp
index 76056029f78..b57a2f42ea7 100644
--- a/searchlib/src/tests/memoryindex/field_index/field_index_test.cpp
+++ b/searchlib/src/tests/memoryindex/field_index/field_index_test.cpp
@@ -76,15 +76,8 @@ private:
     bool              _firstDoc;
 
 public:
-    explicit MyBuilder(const Schema &schema)
-        : IndexBuilder(schema),
-          _ss(),
-          _insideWord(false),
-          _insideField(false),
-          _firstWord(true),
-          _firstField(true),
-          _firstDoc(true)
-    {}
+    explicit MyBuilder(const Schema &schema);
+    ~MyBuilder() override;
 
     void startWord(vespalib::stringref word) override {
         assert(_insideField);
@@ -153,6 +146,17 @@ public:
     }
 };
 
+MyBuilder::MyBuilder(const Schema &schema)
+    : IndexBuilder(schema),
+      _ss(),
+      _insideWord(false),
+      _insideField(false),
+      _firstWord(true),
+      _firstField(true),
+      _firstDoc(true)
+{}
+MyBuilder::~MyBuilder() = default;
+
 struct SimpleMatchData {
     TermFieldMatchData term;
     TermFieldMatchDataArray array;
@@ -395,7 +399,7 @@ public:
         if (_inserter != nullptr) {
             _inserter->flush();
         }
-        for (auto wfp : _mock) {
+        for (const auto& wfp : _mock) {
             auto &wf = wfp.first;
             auto &word = wf.first;
             auto fieldId = wf.second;
@@ -522,7 +526,7 @@ myCompactFeatures(FieldIndexCollection &fieldIndexes, ISequencedTaskExecutor &pu
 Schema
 make_all_index_schema(DocBuilder::AddFieldsType add_fields)
 {
-    DocBuilder db(add_fields);
+    DocBuilder db(std::move(add_fields));
     return SchemaBuilder(db).add_all_indexes().build();
 }
 
@@ -732,12 +736,8 @@ make_multi_field_add_fields()
 struct FieldIndexCollectionTest : public ::testing::Test {
     Schema schema;
     FieldIndexCollection fic;
-    FieldIndexCollectionTest()
-        : schema(make_all_index_schema(make_multi_field_add_fields())),
-          fic(schema, MockFieldLengthInspector())
-    {
-    }
-    ~FieldIndexCollectionTest();
+    FieldIndexCollectionTest();
+    ~FieldIndexCollectionTest() override;
 
     [[nodiscard]]NormalFieldIndex::PostingList::Iterator
     find(const vespalib::stringref word, uint32_t field_id) const {
@@ -745,6 +745,11 @@ struct FieldIndexCollectionTest : public ::testing::Test {
     }
 };
 
+FieldIndexCollectionTest::FieldIndexCollectionTest()
+    : schema(make_all_index_schema(make_multi_field_add_fields())),
+      fic(schema, MockFieldLengthInspector())
+{
+}
 FieldIndexCollectionTest::~FieldIndexCollectionTest() = default;
 
 TEST_F(FieldIndexCollectionTest, require_that_multiple_posting_lists_across_multiple_fields_can_exist)
@@ -938,8 +943,8 @@ public:
     DocumentInverterContext _inv_context;
     DocumentInverter _inv;
 
-    InverterTest(DocBuilder::AddFieldsType add_fields)
-        : _b(add_fields),
+    explicit InverterTest(DocBuilder::AddFieldsType add_fields)
+        : _b(std::move(add_fields)),
           _schema(SchemaBuilder(_b).add_all_indexes().build()),
           _fic(_schema, MockFieldLengthInspector()),
           _invertThreads(SequencedTaskExecutor::create(invert_executor, 2)),
@@ -948,14 +953,14 @@ public:
           _inv(_inv_context)
     {
     }
-    NormalFieldIndex::PostingList::Iterator find(const vespalib::stringref word, uint32_t field_id) const {
+    [[nodiscard]] NormalFieldIndex::PostingList::Iterator find(const vespalib::stringref word, uint32_t field_id) const {
         return find_in_field_index<false>(word, field_id, _fic);
     }
-    NormalFieldIndex::PostingList::ConstIterator findFrozen(const vespalib::stringref word, uint32_t field_id) const {
+    [[nodiscard]] NormalFieldIndex::PostingList::ConstIterator findFrozen(const vespalib::stringref word, uint32_t field_id) const {
         return find_frozen_in_field_index<false>(word, field_id, _fic);
     }
-    SearchIterator::UP search(const vespalib::stringref word, uint32_t field_id,
-                              const SimpleMatchData& match_data) {
+    [[nodiscard]] SearchIterator::UP
+    search(const vespalib::stringref word, uint32_t field_id,const SimpleMatchData& match_data) const {
         return make_search_iterator<false>(findFrozen(word, field_id), featureStoreRef(_fic, field_id),
                                            field_id, match_data.array);
     }
diff --git a/searchlib/src/tests/memoryindex/field_index_remover/field_index_remover_test.cpp b/searchlib/src/tests/memoryindex/field_index_remover/field_index_remover_test.cpp
index 0a9964d5c31..dee8b7f9ace 100644
--- a/searchlib/src/tests/memoryindex/field_index_remover/field_index_remover_test.cpp
+++ b/searchlib/src/tests/memoryindex/field_index_remover/field_index_remover_test.cpp
@@ -63,20 +63,8 @@ struct FieldIndexRemoverTest : public ::testing::Test {
     std::vector<std::map<vespalib::string, vespalib::datastore::EntryRef>> _wordToRefMaps;
     std::vector<std::unique_ptr<FieldIndexRemover>> _removers;
 
-    FieldIndexRemoverTest()
-        : _listener(),
-          _wordStores(),
-          _wordToRefMaps(),
-          _removers()
-    {
-        uint32_t numFields = 4;
-        for (uint32_t fieldId = 0; fieldId < numFields; ++fieldId) {
-            _wordStores.push_back(std::make_unique<WordStore>());
-            _removers.push_back(std::make_unique<FieldIndexRemover>
-                                (*_wordStores.back()));
-        }
-        _wordToRefMaps.resize(numFields);
-    }
+    FieldIndexRemoverTest();
+    ~FieldIndexRemoverTest() override;
     vespalib::datastore::EntryRef getWordRef(const vespalib::string &word, uint32_t fieldId) {
         auto &wordToRefMap = _wordToRefMaps[fieldId];
         WordStore &wordStore = *_wordStores[fieldId];
@@ -110,6 +98,21 @@ struct FieldIndexRemoverTest : public ::testing::Test {
     }
 };
 
+FieldIndexRemoverTest::FieldIndexRemoverTest()
+    : _listener(),
+      _wordStores(),
+      _wordToRefMaps(),
+      _removers()
+{
+    uint32_t numFields = 4;
+    for (uint32_t fieldId = 0; fieldId < numFields; ++fieldId) {
+        _wordStores.push_back(std::make_unique<WordStore>());
+        _removers.push_back(std::make_unique<FieldIndexRemover>(*_wordStores.back()));
+    }
+    _wordToRefMaps.resize(numFields);
+}
+FieldIndexRemoverTest::~FieldIndexRemoverTest() = default;
+
 TEST_F(FieldIndexRemoverTest, word_field_id_pairs_for_multiple_doc_ids_can_be_inserted)
 {
     insert("a", 1, 10).insert("a", 1, 20).insert("a", 1, 30);
diff --git a/searchlib/src/tests/memoryindex/field_inverter/field_inverter_test.cpp b/searchlib/src/tests/memoryindex/field_inverter/field_inverter_test.cpp
index 6470d6593cd..2e3e56a123b 100644
--- a/searchlib/src/tests/memoryindex/field_inverter/field_inverter_test.cpp
+++ b/searchlib/src/tests/memoryindex/field_inverter/field_inverter_test.cpp
@@ -161,27 +161,8 @@ struct FieldInverterTest : public ::testing::Test {
                };
     }
 
-    FieldInverterTest()
-        : _b(make_add_fields()),
-          _schema(SchemaBuilder(_b).add_all_indexes().build()),
-          _word_store(),
-          _remover(_word_store),
-          _inserter_backend(),
-          _calculators(),
-          _inserters(),
-          _inverters()
-    {
-        for (uint32_t fieldId = 0; fieldId < _schema.getNumIndexFields();
-             ++fieldId) {
-            _calculators.emplace_back(std::make_unique<FieldLengthCalculator>());
-            _inserters.emplace_back(std::make_unique<test::OrderedFieldIndexInserter>(_inserter_backend, fieldId));
-            _inverters.push_back(std::make_unique<FieldInverter>(_schema,
-                                                                 fieldId,
-                                                                 _remover,
-                                                                 *_inserters.back(),
-                                                                 *_calculators.back()));
-        }
-    }
+    FieldInverterTest();
+    ~FieldInverterTest() override;
 
     void invertDocument(uint32_t docId, const Document &doc) {
         uint32_t fieldId = 0;
@@ -213,6 +194,24 @@ struct FieldInverterTest : public ::testing::Test {
 
 };
 
+FieldInverterTest::FieldInverterTest()
+    : _b(make_add_fields()),
+      _schema(SchemaBuilder(_b).add_all_indexes().build()),
+      _word_store(),
+      _remover(_word_store),
+      _inserter_backend(),
+      _calculators(),
+      _inserters(),
+      _inverters()
+{
+    for (uint32_t fieldId = 0; fieldId < _schema.getNumIndexFields(); ++fieldId) {
+        _calculators.emplace_back(std::make_unique<FieldLengthCalculator>());
+        _inserters.emplace_back(std::make_unique<test::OrderedFieldIndexInserter>(_inserter_backend, fieldId));
+        _inverters.push_back(std::make_unique<FieldInverter>(_schema, fieldId, _remover, *_inserters.back(), *_calculators.back()));
+    }
+}
+FieldInverterTest::~FieldInverterTest() = default;
+
 TEST_F(FieldInverterTest, require_that_fresh_insert_works)
 {
     invertDocument(10, *makeDoc10(_b));
diff --git a/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp b/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp
index 69063f38aeb..4f7a7934d4c 100644
--- a/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp
+++ b/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp
@@ -55,6 +55,8 @@ using namespace search::queryeval;
 struct MySetup : public IFieldLengthInspector {
     std::vector<vespalib::string> fields;
     std::map<vespalib::string, FieldLengthInfo> field_lengths;
+    MySetup();
+    ~MySetup() override;
     MySetup &field(const std::string &name) {
         fields.emplace_back(name);
         return *this;
@@ -84,6 +86,9 @@ struct MySetup : public IFieldLengthInspector {
 
 };
 
+MySetup::MySetup() = default;
+MySetup::~MySetup() = default;
+
 //-----------------------------------------------------------------------------
 
 struct Index {
diff --git a/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp b/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
index fd73243b4fa..0cd31cd491a 100644
--- a/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
+++ b/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
@@ -54,13 +54,13 @@ struct ModSearch : SearchIterator {
     uint32_t limit;
     MinMaxPostingInfo info;
     TermFieldMatchData *tfmd;
-    ModSearch(Stats &stats_in, uint32_t step_in, uint32_t limit_in, int32_t maxWeight, TermFieldMatchData *tfmd_in)
-        : stats(stats_in), step(step_in), limit(limit_in), info(0, maxWeight), tfmd(tfmd_in) { }
+    ModSearch(Stats &stats_in, uint32_t step_in, uint32_t limit_in, int32_t maxWeight, TermFieldMatchData *tfmd_in);
+    ~ModSearch() override;
     void initRange(uint32_t begin, uint32_t end) override {
         SearchIterator::initRange(begin, end);
         setDocId(step);
     }
-    virtual void doSeek(uint32_t docid) override {
+    void doSeek(uint32_t docid) override {
         assert(docid > getDocId());
         uint32_t skippedDocs = (docid - getDocId() - 1);
         uint32_t skippedHits = (skippedDocs / step);
@@ -76,7 +76,7 @@ struct ModSearch : SearchIterator {
             setAtEnd();
         }
     }
-    virtual void doUnpack(uint32_t docid) override {
+    void doUnpack(uint32_t docid) override {
         if (tfmd != NULL) {
             tfmd->reset(docid);
             search::fef::TermFieldMatchDataPosition pos;
@@ -85,9 +85,14 @@ struct ModSearch : SearchIterator {
         }
         stats.unpack();
     }
-    virtual const PostingInfo *getPostingInfo() const override { return &info; }
+    const PostingInfo *getPostingInfo() const override { return &info; }
 };
 
+ModSearch::ModSearch(Stats &stats_in, uint32_t step_in, uint32_t limit_in, int32_t maxWeight, TermFieldMatchData *tfmd_in)
+    : stats(stats_in), step(step_in), limit(limit_in), info(0, maxWeight), tfmd(tfmd_in)
+{ }
+ModSearch::~ModSearch() = default;
+
 struct WandFactory {
     virtual std::string name() const = 0;
     virtual SearchIterator::UP create(const wand::Terms &terms) = 0;
diff --git a/searchlib/src/tests/queryeval/weighted_set_term/weighted_set_term_test.cpp b/searchlib/src/tests/queryeval/weighted_set_term/weighted_set_term_test.cpp
index 8f4381c48f9..51594c478e5 100644
--- a/searchlib/src/tests/queryeval/weighted_set_term/weighted_set_term_test.cpp
+++ b/searchlib/src/tests/queryeval/weighted_set_term/weighted_set_term_test.cpp
@@ -44,28 +44,20 @@ struct WS {
     bool field_is_filter;
     bool term_is_not_needed;
 
-    WS()
-        : layout(),
-          handle(layout.allocTermField(fieldId)),
-          tokens(),
-          field_is_filter(false),
-          term_is_not_needed(false)
-    {
-        MatchData::UP tmp = layout.createMatchData();
-        ASSERT_TRUE(tmp->resolveTermField(handle)->getFieldId() == fieldId);
-    }
+    WS();
+    ~WS();
 
     WS &add(const std::string &token, uint32_t weight) {
-        tokens.push_back(std::make_pair(token, weight));
+        tokens.emplace_back(token, weight);
         return *this;
     }
     WS& set_field_is_filter(bool value) { field_is_filter = value; return *this; }
     WS& set_term_is_not_needed(bool value) { term_is_not_needed = value; return *this; }
 
-    Node::UP createNode() const {
-        SimpleWeightedSetTerm *node = new SimpleWeightedSetTerm(tokens.size(), "view", 0, Weight(0));
-        for (size_t i = 0; i < tokens.size(); ++i) {
-            node->addTerm(tokens[i].first,Weight(tokens[i].second));
+    [[nodiscard]] Node::UP createNode() const {
+        auto *node = new SimpleWeightedSetTerm(tokens.size(), "view", 0, Weight(0));
+        for (const auto & token : tokens) {
+            node->addTerm(token.first,Weight(token.second));
         }
         return Node::UP(node);
     }
@@ -78,7 +70,7 @@ struct WS {
         queryeval::Blueprint::UP bp = searchable.createBlueprint(requestContext, fields, *node);
         bp->fetchPostings(ExecuteInfo::create(strict));
         SearchIterator::UP sb = bp->createSearch(*md, strict);
-        return (dynamic_cast<WeightedSetTermSearch*>(sb.get()) != 0);
+        return (dynamic_cast<WeightedSetTermSearch*>(sb.get()) != nullptr);
     }
 
     FakeResult search(Searchable &searchable, const std::string &field, bool strict) const {
@@ -111,26 +103,38 @@ struct WS {
     }
 };
 
+WS::WS()
+    : layout(),
+      handle(layout.allocTermField(fieldId)),
+      tokens(),
+      field_is_filter(false),
+      term_is_not_needed(false)
+{
+    MatchData::UP tmp = layout.createMatchData();
+    ASSERT_TRUE(tmp->resolveTermField(handle)->getFieldId() == fieldId);
+}
+WS::~WS() = default;
+
 struct MockSearch : public SearchIterator {
     int seekCnt;
     int _initial;
-    MockSearch(uint32_t initial) : SearchIterator(), seekCnt(0), _initial(initial) { }
+    explicit MockSearch(uint32_t initial) : SearchIterator(), seekCnt(0), _initial(initial) { }
     void initRange(uint32_t begin, uint32_t end) override {
         SearchIterator::initRange(begin, end);
         setDocId(_initial);
     }
-    virtual void doSeek(uint32_t) override {
+    void doSeek(uint32_t) override {
         ++seekCnt;
         setAtEnd();
     }
-    virtual void doUnpack(uint32_t) override {}
+    void doUnpack(uint32_t) override {}
 };
 
 struct MockFixture {
     MockSearch *mock;
     TermFieldMatchData tfmd;
     std::unique_ptr<SearchIterator> search;
-    MockFixture(uint32_t initial) : mock(0), tfmd(), search() {
+    explicit MockFixture(uint32_t initial) : mock(nullptr), tfmd(), search() {
         std::vector<SearchIterator*> children;
         std::vector<int32_t> weights;
         mock = new MockSearch(initial);
@@ -156,10 +160,11 @@ void run_simple(bool field_is_filter, bool term_is_not_needed)
             .doc(5).elem(0).weight(50).pos(0)
             .doc(7).elem(0).weight(70).pos(0);
     }
-    WS ws = WS().add("7", 70).add("5", 50).add("3", 30).add("100", 1000)
-            .set_field_is_filter(field_is_filter)
-            .set_term_is_not_needed(term_is_not_needed);
-;
+    WS ws;
+    ws.add("7", 70).add("5", 50).add("3", 30).add("100", 1000)
+      .set_field_is_filter(field_is_filter)
+      .set_term_is_not_needed(term_is_not_needed);
+
     EXPECT_TRUE(ws.isGenericSearch(index, "field", true));
     EXPECT_TRUE(ws.isGenericSearch(index, "field", false));
     EXPECT_TRUE(ws.isGenericSearch(index, "multi-field", true));
@@ -197,11 +202,12 @@ void run_multi(bool field_is_filter, bool term_is_not_needed)
             .doc(5).elem(0).weight(150).pos(0).elem(0).weight(50).pos(0)
             .doc(7).elem(0).weight(70).pos(0);
     }
-    WS ws = WS().add("7", 70).add("5", 50).add("3", 30)
-            .add("15", 150).add("13", 130)
-            .add("23", 230).add("100", 1000)
-            .set_field_is_filter(field_is_filter)
-            .set_term_is_not_needed(term_is_not_needed);
+    WS ws;
+    ws.add("7", 70).add("5", 50).add("3", 30)
+      .add("15", 150).add("13", 130)
+      .add("23", 230).add("100", 1000)
+      .set_field_is_filter(field_is_filter)
+      .set_term_is_not_needed(term_is_not_needed);
     EXPECT_TRUE(ws.isGenericSearch(index, "multi-field", true));
     EXPECT_TRUE(ws.isGenericSearch(index, "multi-field", false));
 
@@ -274,9 +280,9 @@ TEST("verify search iterator conformance with document weight iterator children"
 struct VerifyMatchData {
     struct MyBlueprint : search::queryeval::SimpleLeafBlueprint {
         VerifyMatchData &vmd;
-        MyBlueprint(VerifyMatchData &vmd_in, FieldSpec spec_in)
+        MyBlueprint(VerifyMatchData &vmd_in, const FieldSpec & spec_in)
             : SimpleLeafBlueprint(spec_in), vmd(vmd_in) {}
-        SearchIterator::UP createLeafSearch(const fef::TermFieldMatchDataArray &tfmda, bool) const override {
+        [[nodiscard]] SearchIterator::UP createLeafSearch(const fef::TermFieldMatchDataArray &tfmda, bool) const override {
             EXPECT_EQUAL(tfmda.size(), 1u);
             EXPECT_TRUE(tfmda[0] != nullptr);
             if (vmd.child_tfmd == nullptr) {
@@ -287,7 +293,7 @@ struct VerifyMatchData {
             ++vmd.child_cnt;
             return std::make_unique<EmptySearch>();
         }
-        SearchIteratorUP createFilterSearch(bool strict, FilterConstraint constraint) const override {
+        [[nodiscard]] SearchIteratorUP createFilterSearch(bool strict, FilterConstraint constraint) const override {
             return create_default_filter(strict, constraint);
         }
     };
diff --git a/searchlib/src/tests/sort/sortbenchmark.cpp b/searchlib/src/tests/sort/sortbenchmark.cpp
index 04832593b28..94f9424575c 100644
--- a/searchlib/src/tests/sort/sortbenchmark.cpp
+++ b/searchlib/src/tests/sort/sortbenchmark.cpp
@@ -18,9 +18,15 @@ public:
     V merge();
     void twoWayMerge();
     V cat() const;
+    Test();
+    ~Test() override;
 };
 
-void Test::generateVectors(size_t numVectors, size_t values)
+Test::Test() = default;
+Test::~Test() = default;
+
+void
+Test::generateVectors(size_t numVectors, size_t values)
 {
     _data.resize(numVectors);
     for (size_t j(0); j < numVectors; j++) {
@@ -32,13 +38,15 @@ void Test::generateVectors(size_t numVectors, size_t values)
     }
 }
 
-Test::V Test::merge()
+Test::V
+Test::merge()
 {
     twoWayMerge();
     return _data[0];
 }
 
-void Test::twoWayMerge()
+void
+Test::twoWayMerge()
 {
     std::vector<V> n((_data.size()+1)/2);
 
@@ -57,7 +65,8 @@ void Test::twoWayMerge()
     }
 }
 
-Test::V Test::cat() const
+Test::V
+Test::cat() const
 {
     size_t sum(0);
     for (size_t i(0), m(_data.size()); i < m; i++) {
diff --git a/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.cpp b/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.cpp
index b3dff78abfb..01559952f28 100644
--- a/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.cpp
+++ b/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.cpp
@@ -2,7 +2,6 @@
 
 #include "hitsaggregationresult.h"
 #include <vespa/document/fieldvalue/document.h>
-#include <cassert>
 
 #include <vespa/log/log.h>
 LOG_SETUP(".searchlib.aggregation.hitsaggregationresult");
@@ -21,9 +20,13 @@ HitsAggregationResult::HitsAggregationResult() :
     _hits(),
     _isOrdered(false),
     _bestHitRank(),
-    _summaryGenerator(0)
+    _summaryGenerator(nullptr)
 {}
-HitsAggregationResult::~HitsAggregationResult() {}
+HitsAggregationResult::HitsAggregationResult(HitsAggregationResult &&) noexcept = default;
+HitsAggregationResult & HitsAggregationResult::operator=(HitsAggregationResult &&) noexcept = default;
+HitsAggregationResult::HitsAggregationResult(const HitsAggregationResult &) = default;
+HitsAggregationResult & HitsAggregationResult::operator=(const HitsAggregationResult &) = default;
+HitsAggregationResult::~HitsAggregationResult() = default;
 
 void HitsAggregationResult::onPrepare(const ResultNode & result, bool useForInit)
 {
@@ -34,7 +37,7 @@ void HitsAggregationResult::onPrepare(const ResultNode & result, bool useForInit
 void
 HitsAggregationResult::onMerge(const AggregationResult &b)
 {
-    const HitsAggregationResult &rhs = (const HitsAggregationResult &)b;
+    const auto &rhs = (const HitsAggregationResult &)b;
     _hits.onMerge(rhs._hits);
 }
 
diff --git a/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.h b/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.h
index 97595a4119c..30059078920 100644
--- a/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.h
+++ b/searchlib/src/vespa/searchlib/aggregation/hitsaggregationresult.h
@@ -43,7 +43,11 @@ public:
 
     DECLARE_AGGREGATIONRESULT(HitsAggregationResult);
     HitsAggregationResult();
-    ~HitsAggregationResult();
+    HitsAggregationResult(HitsAggregationResult &&) noexcept;
+    HitsAggregationResult & operator=(HitsAggregationResult &&) noexcept;
+    HitsAggregationResult(const HitsAggregationResult &);
+    HitsAggregationResult & operator=(const HitsAggregationResult &);
+    ~HitsAggregationResult() override;
     void postMerge() override { _hits.postMerge(_maxHits); }
     void setSummaryGenerator(SummaryGenerator & summaryGenerator) { _summaryGenerator = &summaryGenerator; }
     const SummaryClassType & getSummaryClass() const { return _summaryClass; }
diff --git a/searchlib/src/vespa/searchlib/attribute/search_context.cpp b/searchlib/src/vespa/searchlib/attribute/search_context.cpp
index 3deacca5764..a0345ddce70 100644
--- a/searchlib/src/vespa/searchlib/attribute/search_context.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/search_context.cpp
@@ -10,7 +10,7 @@ using search::queryeval::SearchIterator;
 
 namespace search::attribute {
 
-SearchContext::SearchContext(const AttributeVector &attr)
+SearchContext::SearchContext(const AttributeVector &attr) noexcept
     : _attr(attr),
       _plsc(nullptr)
 {
diff --git a/searchlib/src/vespa/searchlib/attribute/search_context.h b/searchlib/src/vespa/searchlib/attribute/search_context.h
index 8e1297ad2df..025b0fdf113 100644
--- a/searchlib/src/vespa/searchlib/attribute/search_context.h
+++ b/searchlib/src/vespa/searchlib/attribute/search_context.h
@@ -47,7 +47,7 @@ public:
     const AttributeVector& attribute() const { return _attr; }
 
 protected:
-    SearchContext(const AttributeVector& attr);
+    SearchContext(const AttributeVector& attr) noexcept;
 
     const AttributeVector&                _attr;
     attribute::IPostingListSearchContext* _plsc;
diff --git a/searchlib/src/vespa/searchlib/attribute/string_search_context.cpp b/searchlib/src/vespa/searchlib/attribute/string_search_context.cpp
index e548ab8078c..fadf7a3151d 100644
--- a/searchlib/src/vespa/searchlib/attribute/string_search_context.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/string_search_context.cpp
@@ -21,6 +21,9 @@ StringSearchContext::StringSearchContext(const AttributeVector& to_be_searched,
 {
 }
 
+StringSearchContext::StringSearchContext(StringSearchContext &&) noexcept = default;
+StringSearchContext::~StringSearchContext() = default;
+
 const QueryTermUCS4*
 StringSearchContext::queryTerm() const
 {
diff --git a/searchlib/src/vespa/searchlib/attribute/string_search_context.h b/searchlib/src/vespa/searchlib/attribute/string_search_context.h
index fc9f3688a7a..a0014379436 100644
--- a/searchlib/src/vespa/searchlib/attribute/string_search_context.h
+++ b/searchlib/src/vespa/searchlib/attribute/string_search_context.h
@@ -26,6 +26,8 @@ protected:
 public:
     StringSearchContext(const AttributeVector& to_be_searched, std::unique_ptr<QueryTermSimple> query_term, bool cased);
     StringSearchContext(const AttributeVector& to_be_searched, StringMatcher&& matcher);
+    StringSearchContext(StringSearchContext &&) noexcept;
+    ~StringSearchContext() override;
     const QueryTermUCS4* queryTerm() const override;
     bool valid() const override;
 
diff --git a/searchlib/src/vespa/searchlib/expression/functionnodes.cpp b/searchlib/src/vespa/searchlib/expression/functionnodes.cpp
index 9046a5427ce..cc6a8c137a7 100644
--- a/searchlib/src/vespa/searchlib/expression/functionnodes.cpp
+++ b/searchlib/src/vespa/searchlib/expression/functionnodes.cpp
@@ -3,9 +3,7 @@
 #include "floatresultnode.h"
 #include "stringresultnode.h"
 #include "rawresultnode.h"
-#include "enumresultnode.h"
 #include "constantnode.h"
-#include "relevancenode.h"
 #include "addfunctionnode.h"
 #include "dividefunctionnode.h"
 #include "multiplyfunctionnode.h"
@@ -29,8 +27,6 @@
 #include "xorbitfunctionnode.h"
 #include "md5bitfunctionnode.h"
 #include "binaryfunctionnode.h"
-#include "nullresultnode.h"
-#include "positiveinfinityresultnode.h"
 #include "resultvector.h"
 #include "catserializer.h"
 #include "strcatserializer.h"
@@ -320,6 +316,8 @@ ResultNode::CP DivideFunctionNode::getInitialValue() const
    throw std::runtime_error("DivideFunctionNode::getInitialValue() const not implemented since it shall never be used.");
 }
 
+UnaryBitFunctionNode::~UnaryBitFunctionNode() = default;
+
 void UnaryBitFunctionNode::onPrepareResult()
 {
     setResultType(std::unique_ptr<ResultNode>(new RawResultNode()));
diff --git a/searchlib/src/vespa/searchlib/expression/unarybitfunctionnode.h b/searchlib/src/vespa/searchlib/expression/unarybitfunctionnode.h
index 63114188b1f..536d881cb90 100644
--- a/searchlib/src/vespa/searchlib/expression/unarybitfunctionnode.h
+++ b/searchlib/src/vespa/searchlib/expression/unarybitfunctionnode.h
@@ -4,8 +4,7 @@
 #include "unaryfunctionnode.h"
 #include <vespa/vespalib/objects/nbostream.h>
 
-namespace search {
-namespace expression {
+namespace search::expression {
 
 class UnaryBitFunctionNode : public UnaryFunctionNode
 {
@@ -15,6 +14,7 @@ public:
     DECLARE_ABSTRACT_EXPRESSIONNODE(UnaryBitFunctionNode);
     UnaryBitFunctionNode() : _numBits(0) { }
     UnaryBitFunctionNode(ExpressionNode::UP arg, unsigned numBits) : UnaryFunctionNode(std::move(arg)), _numBits(numBits) { }
+    ~UnaryBitFunctionNode() override;
 protected:
     size_t getNumBits()  const { return _numBits; }
     size_t getNumBytes() const { return (_numBits+7)/8; }
@@ -28,5 +28,3 @@ private:
 };
 
 }
-}
-
diff --git a/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp b/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp
index a58f97a2755..d039b80930b 100644
--- a/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp
@@ -236,15 +236,8 @@ private:
     const fef::MatchData   *_md;
 
 public:
-    ElementSimilarityExecutor(VectorizedQueryTerms &&terms, std::vector<OutputSpec> &&outputs_in)
-        : _terms(std::move(terms)),
-          _pos(_terms.handles.size(), nullptr),
-          _end(_terms.handles.size(), nullptr),
-          _position_queue(CmpPosition(_pos.data())),
-          _element_queue(CmpElement(_pos.data())),
-          _outputs(std::move(outputs_in)),
-          _md(nullptr)
-    { }
+    ElementSimilarityExecutor(VectorizedQueryTerms &&terms, std::vector<OutputSpec> &&outputs_in);
+    ~ElementSimilarityExecutor() override;
 
     bool isPure() override { return _terms.handles.empty(); }
 
@@ -317,6 +310,17 @@ public:
     }
 };
 
+ElementSimilarityExecutor::ElementSimilarityExecutor(VectorizedQueryTerms &&terms, std::vector<OutputSpec> &&outputs_in)
+    : _terms(std::move(terms)),
+      _pos(_terms.handles.size(), nullptr),
+      _end(_terms.handles.size(), nullptr),
+      _position_queue(CmpPosition(_pos.data())),
+      _element_queue(CmpElement(_pos.data())),
+      _outputs(std::move(outputs_in)),
+      _md(nullptr)
+{ }
+ElementSimilarityExecutor::~ElementSimilarityExecutor() = default;
+
 //-----------------------------------------------------------------------------
 
 std::vector<std::pair<vespalib::string, vespalib::string> >
diff --git a/searchlib/src/vespa/searchlib/fef/blueprintresolver.cpp b/searchlib/src/vespa/searchlib/fef/blueprintresolver.cpp
index dd94e26b056..cc2cae1c8cb 100644
--- a/searchlib/src/vespa/searchlib/fef/blueprintresolver.cpp
+++ b/searchlib/src/vespa/searchlib/fef/blueprintresolver.cpp
@@ -51,7 +51,7 @@ struct Compiler : public Blueprint::DependencyHandler {
     struct Frame {
         ExecutorSpec spec;
         const FeatureNameParser &parser;
-        Frame(Blueprint::SP blueprint, const FeatureNameParser &parser_in)
+        Frame(Blueprint::SP blueprint, const FeatureNameParser &parser_in) noexcept
             : spec(std::move(blueprint)), parser(parser_in) {}
     };
     using Stack = std::vector<Frame>;
@@ -91,7 +91,7 @@ struct Compiler : public Blueprint::DependencyHandler {
           failed_set(),
           min_stack(nullptr),
           max_stack(nullptr) {}
-    ~Compiler();
+    ~Compiler() override;
 
     void probe_stack() {
         const char c = 'X';
@@ -99,12 +99,12 @@ struct Compiler : public Blueprint::DependencyHandler {
         max_stack = (max_stack == nullptr) ? &c : std::max(max_stack, &c);
     }
 
-    int stack_usage() const {
+    [[nodiscard]] int stack_usage() const {
         return (max_stack - min_stack);
     }
 
     Frame &self() { return resolve_stack.back(); }
-    bool failed() const { return !failed_set.empty(); }
+    [[nodiscard]] bool failed() const { return !failed_set.empty(); }
 
     vespalib::string make_trace(bool skip_self) {
         vespalib::string trace;
@@ -142,7 +142,7 @@ struct Compiler : public Blueprint::DependencyHandler {
             errors.emplace_back(msg);
         }
         probe_stack();
-        return FeatureRef();
+        return {};
     }
 
     void fail_self(const vespalib::string &reason) {
@@ -245,12 +245,14 @@ Compiler::~Compiler() = default;
 
 } // namespace search::fef::<unnamed>
 
-BlueprintResolver::ExecutorSpec::ExecutorSpec(Blueprint::SP blueprint_in)
+BlueprintResolver::ExecutorSpec::ExecutorSpec(Blueprint::SP blueprint_in) noexcept
     : blueprint(std::move(blueprint_in)),
       inputs(),
       output_types()
 { }
-
+BlueprintResolver::ExecutorSpec::ExecutorSpec(ExecutorSpec &&) noexcept = default;
+BlueprintResolver::ExecutorSpec & BlueprintResolver::ExecutorSpec::operator =(ExecutorSpec &&) noexcept = default;
+BlueprintResolver::ExecutorSpec::ExecutorSpec(const ExecutorSpec &) = default;
 BlueprintResolver::ExecutorSpec::~ExecutorSpec() = default;
 BlueprintResolver::~BlueprintResolver() = default;
 
diff --git a/searchlib/src/vespa/searchlib/fef/blueprintresolver.h b/searchlib/src/vespa/searchlib/fef/blueprintresolver.h
index cbc8614dbde..3cf52a90684 100644
--- a/searchlib/src/vespa/searchlib/fef/blueprintresolver.h
+++ b/searchlib/src/vespa/searchlib/fef/blueprintresolver.h
@@ -43,7 +43,7 @@ public:
         FeatureRef() : executor(undef), output(0) {}
         FeatureRef(uint32_t executor_in, uint32_t output_in)
             : executor(executor_in), output(output_in) {}
-        bool valid() { return (executor != undef); }
+        [[nodiscard]] bool valid() const { return (executor != undef); }
     };
     using FeatureMap = std::map<vespalib::string, FeatureRef>;
 
@@ -57,7 +57,10 @@ public:
         std::vector<FeatureRef>  inputs;
         std::vector<FeatureType> output_types;
 
-        ExecutorSpec(BlueprintSP blueprint_in);
+        explicit ExecutorSpec(BlueprintSP blueprint_in) noexcept;
+        ExecutorSpec(ExecutorSpec &&) noexcept;
+        ExecutorSpec & operator =(ExecutorSpec &&) noexcept;
+        ExecutorSpec(const ExecutorSpec &);
         ~ExecutorSpec();
     };
     using ExecutorSpecList = std::vector<ExecutorSpec>;
@@ -136,7 +139,7 @@ public:
      *
      * @return feature executor assembly directions
      **/
-    const ExecutorSpecList &getExecutorSpecs() const { return _executorSpecs; }
+    [[nodiscard]] const ExecutorSpecList &getExecutorSpecs() const { return _executorSpecs; }
 
     /**
      * Obtain the location of all named features known to this
@@ -147,7 +150,7 @@ public:
      *
      * @return feature locations
      **/
-    const FeatureMap &getFeatureMap() const { return _featureMap; }
+    [[nodiscard]] const FeatureMap &getFeatureMap() const { return _featureMap; }
 
     /**
      * Obtain the location of all seeds used by this resolver. This
@@ -158,13 +161,13 @@ public:
      *
      * @return seed locations
      **/
-    const FeatureMap &getSeedMap() const { return _seedMap; }
+    [[nodiscard]] const FeatureMap &getSeedMap() const { return _seedMap; }
 
     /**
      * Will return any accumulated warnings during compile
      * @return list of warnings
      **/
-    const Warnings & getWarnings() const { return _warnings; }
+    [[nodiscard]] const Warnings & getWarnings() const { return _warnings; }
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/fef/feature_type.h b/searchlib/src/vespa/searchlib/fef/feature_type.h
index 643d0b9ae0f..dea1920e840 100644
--- a/searchlib/src/vespa/searchlib/fef/feature_type.h
+++ b/searchlib/src/vespa/searchlib/fef/feature_type.h
@@ -23,12 +23,12 @@ private:
     using TYPE_UP = std::unique_ptr<TYPE>;
     TYPE_UP _type;
     static const FeatureType _number;
-    FeatureType(TYPE_UP type_in) : _type(std::move(type_in)) {}
+    explicit FeatureType(TYPE_UP type_in) : _type(std::move(type_in)) {}
 public:
     FeatureType(const FeatureType &rhs);
-    FeatureType(FeatureType &&rhs) = default;
-    bool is_object() const { return (_type.get() != nullptr); }
-    const TYPE &type() const;
+    FeatureType(FeatureType &&rhs) noexcept = default;
+    [[nodiscard]] bool is_object() const { return (_type.get() != nullptr); }
+    [[nodiscard]] const TYPE &type() const;
     static const FeatureType &number() { return _number; }
     static FeatureType object(const TYPE &type_in);
 };
diff --git a/searchlib/src/vespa/searchlib/fef/phrase_splitter_query_env.cpp b/searchlib/src/vespa/searchlib/fef/phrase_splitter_query_env.cpp
index 02b1e3616a0..dfa1d9886f7 100644
--- a/searchlib/src/vespa/searchlib/fef/phrase_splitter_query_env.cpp
+++ b/searchlib/src/vespa/searchlib/fef/phrase_splitter_query_env.cpp
@@ -21,7 +21,7 @@ PhraseSplitterQueryEnv::considerTerm(uint32_t termIdx, const ITermData &term, ui
                 prototype.addField(fieldId);
                 _phrase_terms.push_back(PhraseTerm(term, _terms.size(), h));
                 for (uint32_t i = 0; i < term.getPhraseLength(); ++i) {
-                    _terms.push_back(prototype);
+                    _terms.emplace_back(prototype);
                     _termIdxMap.push_back(TermIdx(_terms.size() - 1, true));
                 }
                 return;
diff --git a/searchlib/src/vespa/searchlib/fef/simpletermdata.cpp b/searchlib/src/vespa/searchlib/fef/simpletermdata.cpp
index fdea499f9b4..92245ef21b3 100644
--- a/searchlib/src/vespa/searchlib/fef/simpletermdata.cpp
+++ b/searchlib/src/vespa/searchlib/fef/simpletermdata.cpp
@@ -4,10 +4,9 @@
 
 namespace search::fef {
 
-SimpleTermData::SimpleTermData()
+SimpleTermData::SimpleTermData() noexcept
     : _weight(0),
       _numTerms(0),
-      _termIndex(0),
       _uniqueId(0),
       _query_tensor_name(),
       _fields()
@@ -21,11 +20,16 @@ SimpleTermData::SimpleTermData(const ITermData &rhs)
       _query_tensor_name(rhs.query_tensor_name()),
       _fields()
 {
+    _fields.reserve(rhs.numFields());
     for (size_t i(0), m(rhs.numFields()); i < m; ++i) {
-        _fields.push_back(SimpleTermFieldData(rhs.field(i)));
+        _fields.emplace_back(rhs.field(i));
     }
 }
 
+SimpleTermData::SimpleTermData(const SimpleTermData &) = default;
+SimpleTermData::SimpleTermData(SimpleTermData &&) noexcept = default;
+SimpleTermData & SimpleTermData::operator=(SimpleTermData &&) noexcept = default;
+
 SimpleTermData::~SimpleTermData() = default;
 
 }
diff --git a/searchlib/src/vespa/searchlib/fef/simpletermdata.h b/searchlib/src/vespa/searchlib/fef/simpletermdata.h
index c59816dc687..d501d0848e8 100644
--- a/searchlib/src/vespa/searchlib/fef/simpletermdata.h
+++ b/searchlib/src/vespa/searchlib/fef/simpletermdata.h
@@ -9,8 +9,7 @@
 #include <vector>
 #include <cassert>
 
-namespace search {
-namespace fef {
+namespace search::fef {
 
 /**
  * Static match data for a single unit (term/phrase/etc).
@@ -20,49 +19,42 @@ class SimpleTermData final : public ITermData
 private:
     query::Weight   _weight;
     uint32_t        _numTerms;
-    uint32_t        _termIndex;
     uint32_t        _uniqueId;
-    std::optional<vespalib::string> _query_tensor_name;
-
+    std::optional<vespalib::string>  _query_tensor_name;
     std::vector<SimpleTermFieldData> _fields;
 
 public:
-    /**
-     * Creates a new object.
-     **/
-    SimpleTermData();
-
-    /**
-     * Side-cast copy constructor.
-     **/
+    SimpleTermData() noexcept;
     SimpleTermData(const ITermData &rhs);
-
-    ~SimpleTermData();
+    SimpleTermData(const SimpleTermData &);
+    SimpleTermData(SimpleTermData &&) noexcept;
+    SimpleTermData & operator=(SimpleTermData &&) noexcept;
+    ~SimpleTermData() override;
 
     //----------- ITermData implementation ------------------------------------
 
-    query::Weight getWeight() const override { return _weight; }
+    [[nodiscard]] query::Weight getWeight() const override { return _weight; }
 
-    uint32_t getPhraseLength() const override { return _numTerms; }
+    [[nodiscard]] uint32_t getPhraseLength() const override { return _numTerms; }
 
-    uint32_t getUniqueId() const override { return _uniqueId; }
+    [[nodiscard]] uint32_t getUniqueId() const override { return _uniqueId; }
 
-    std::optional<vespalib::string> query_tensor_name() const override { return _query_tensor_name; }
+    [[nodiscard]] std::optional<vespalib::string> query_tensor_name() const override { return _query_tensor_name; }
 
-    size_t numFields() const override { return _fields.size(); }
+    [[nodiscard]] size_t numFields() const override { return _fields.size(); }
 
-    const ITermFieldData &field(size_t i) const override {
+    [[nodiscard]] const ITermFieldData &field(size_t i) const override {
         return _fields[i];
     }
 
-    const ITermFieldData *lookupField(uint32_t fieldId) const override {
+    [[nodiscard]] const ITermFieldData *lookupField(uint32_t fieldId) const override {
         for (size_t fieldIdx(0), m(numFields()); fieldIdx < m; ++fieldIdx) {
             const ITermFieldData &tfd = field(fieldIdx);
             if (tfd.getFieldId() == fieldId) {
                 return &tfd;
             }
         }
-        return 0;
+        return nullptr;
     }
 
     //----------- Utility functions -------------------------------------------
@@ -84,17 +76,6 @@ public:
     }
 
     /**
-     * Set the location of this term in the original user query.
-     *
-     * @return this to allow chaining.
-     * @param idx term index
-     **/
-    SimpleTermData &setTermIndex(uint32_t idx) {
-        _termIndex = idx;
-        return *this;
-    }
-
-    /**
      * Set the unique id of this term. 0 means not set.
      *
      * @param id unique id or 0
@@ -117,7 +98,7 @@ public:
      * @param fieldId field id of the added field
      **/
     SimpleTermFieldData &addField(uint32_t fieldId) {
-        _fields.push_back(SimpleTermFieldData(fieldId));
+        _fields.emplace_back(fieldId);
         return _fields.back();
     }
 
@@ -143,11 +124,10 @@ public:
                 return &tfd;
             }
         }
-        return 0;
+        return nullptr;
     }
 };
 
-
 /**
  * convenience adapter for easy iteration
  **/
@@ -161,14 +141,11 @@ public:
         : _ref(ref), _idx(0), _lim(ref.numFields())
     {}
 
-    bool valid() const { return (_idx < _lim); }
+    [[nodiscard]] bool valid() const { return (_idx < _lim); }
 
-    SimpleTermFieldData& get() const  { return _ref.field(_idx); }
+    [[nodiscard]] SimpleTermFieldData& get() const  { return _ref.field(_idx); }
 
     void next() { assert(valid()); ++_idx; }
 };
 
-
-} // namespace fef
-} // namespace search
-
+}
diff --git a/searchlib/src/vespa/searchlib/grouping/sketch.h b/searchlib/src/vespa/searchlib/grouping/sketch.h
index b973a99da92..6a2082b793d 100644
--- a/searchlib/src/vespa/searchlib/grouping/sketch.h
+++ b/searchlib/src/vespa/searchlib/grouping/sketch.h
@@ -74,6 +74,7 @@ struct SparseSketch : Sketch<BucketBits, HashT> {
     };
     std::unordered_set<HashT, IdentityHash> hash_set;
 
+    ~SparseSketch() override;
     [[nodiscard]] size_t getSize() const { return hash_set.size(); }
 
     int aggregate(HashT hash) override {
@@ -184,6 +185,8 @@ struct NormalSketch : Sketch<BucketBits, HashT> {
     }
 };
 
+template <int BucketBits, typename HashT>
+SparseSketch<BucketBits, HashT>::~SparseSketch() = default;
 
 template <int BucketBits, typename HashT>
 void SparseSketch<BucketBits, HashT>::
diff --git a/searchlib/src/vespa/searchlib/query/tree/termnodes.cpp b/searchlib/src/vespa/searchlib/query/tree/termnodes.cpp
index 6e889e76f21..00f17f7963c 100644
--- a/searchlib/src/vespa/searchlib/query/tree/termnodes.cpp
+++ b/searchlib/src/vespa/searchlib/query/tree/termnodes.cpp
@@ -30,7 +30,8 @@ namespace {
 
 class StringTermVector final : public MultiTerm::TermVector {
 public:
-    StringTermVector(uint32_t sz) : _terms() { _terms.reserve(sz); }
+    explicit StringTermVector(uint32_t sz) : _terms() { _terms.reserve(sz); }
+    ~StringTermVector() override;
     void addTerm(stringref term, Weight weight) override {
         _terms.emplace_back(term, weight);
     }
@@ -39,27 +40,27 @@ public:
         auto res = std::to_chars(buf, buf + sizeof(buf), value, 10);
         addTerm(stringref(buf, res.ptr - buf), weight);
     }
-    StringAndWeight getAsString(uint32_t index) const override {
+    [[nodiscard]] StringAndWeight getAsString(uint32_t index) const override {
         const auto & v = _terms[index];
-        return StringAndWeight(v.first, v.second);
+        return {v.first, v.second};
     }
-    IntegerAndWeight getAsInteger(uint32_t index) const override {
+    [[nodiscard]] IntegerAndWeight getAsInteger(uint32_t index) const override {
         const auto & v = _terms[index];
         int64_t value(0);
         std::from_chars(v.first.c_str(), v.first.c_str() + v.first.size(), value);
-        return IntegerAndWeight(value, v.second);
+        return {value, v.second};
     }
-    Weight getWeight(uint32_t index) const override {
+    [[nodiscard]] Weight getWeight(uint32_t index) const override {
         return _terms[index].second;
     }
-    uint32_t size() const override { return _terms.size(); }
+    [[nodiscard]] uint32_t size() const override { return _terms.size(); }
 private:
     std::vector<std::pair<vespalib::string, Weight>> _terms;
 };
 
 class IntegerTermVector final : public MultiTerm::TermVector {
 public:
-    IntegerTermVector(uint32_t sz) : _terms() { _terms.reserve(sz); }
+    explicit IntegerTermVector(uint32_t sz) : _terms() { _terms.reserve(sz); }
     void addTerm(stringref, Weight) override {
         // Will/should never happen
         assert(false);
@@ -71,7 +72,7 @@ public:
         const auto & v = _terms[index];
         auto res = std::to_chars(_scratchPad, _scratchPad + sizeof(_scratchPad)-1, v.first, 10);
         res.ptr[0] = '\0';
-        return StringAndWeight(stringref(_scratchPad, res.ptr - _scratchPad), v.second);
+        return {stringref(_scratchPad, res.ptr - _scratchPad), v.second};
     }
     IntegerAndWeight getAsInteger(uint32_t index) const override {
         return _terms[index];
@@ -85,6 +86,8 @@ private:
     mutable char                  _scratchPad[24];
 };
 
+StringTermVector::~StringTermVector() = default;
+
 }
 
 MultiTerm::MultiTerm(uint32_t num_terms)
diff --git a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
index 9a29c4c0caf..8e7bd185f85 100644
--- a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
@@ -601,6 +601,8 @@ SourceBlenderBlueprint::SourceBlenderBlueprint(const ISourceSelector &selector)
 {
 }
 
+SourceBlenderBlueprint::~SourceBlenderBlueprint() = default;
+
 Blueprint::HitEstimate
 SourceBlenderBlueprint::combine(const std::vector<HitEstimate> &data) const
 {
diff --git a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
index f4ae2e21b41..8cced6097b5 100644
--- a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
+++ b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
@@ -177,6 +177,7 @@ private:
 
 public:
     SourceBlenderBlueprint(const ISourceSelector &selector);
+    ~SourceBlenderBlueprint() override;
     HitEstimate combine(const std::vector<HitEstimate> &data) const override;
     FieldSpecBaseList exposeFields() const override;
     void sort(Children &children) const override;
diff --git a/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp b/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp
index d22f24cc7da..af332189b61 100644
--- a/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp
@@ -67,12 +67,12 @@ template <>
 class GlobalFilterWrapper<HnswIndexType::SINGLE> {
     const GlobalFilter *_filter;
 public:
-    GlobalFilterWrapper(const GlobalFilter *filter)
+    explicit GlobalFilterWrapper(const GlobalFilter *filter)
         : _filter(filter)
     {
     }
 
-    bool check(uint32_t docid) const noexcept { return !_filter || _filter->check(docid); }
+    [[nodiscard]] bool check(uint32_t docid) const noexcept { return !_filter || _filter->check(docid); }
 
     void clamp_nodeid_limit(uint32_t& nodeid_limit) {
         if (_filter) {
@@ -86,18 +86,38 @@ class GlobalFilterWrapper<HnswIndexType::MULTI> {
     const GlobalFilter *_filter;
     uint32_t            _docid_limit;
 public:
-    GlobalFilterWrapper(const GlobalFilter *filter)
+    explicit GlobalFilterWrapper(const GlobalFilter *filter)
         : _filter(filter),
           _docid_limit(filter ? filter->size() : 0u)
     {
     }
 
-    bool check(uint32_t docid) const noexcept { return !_filter || (docid < _docid_limit && _filter->check(docid)); }
+    [[nodiscard]] bool check(uint32_t docid) const noexcept { return !_filter || (docid < _docid_limit && _filter->check(docid)); }
     static void clamp_nodeid_limit(uint32_t&) { }
 };
 
 }
 
+namespace internal {
+
+PreparedAddNode::PreparedAddNode() noexcept
+    : connections()
+{ }
+PreparedAddNode::PreparedAddNode(std::vector<Links>&& connections_in) noexcept
+    : connections(std::move(connections_in))
+{ }
+PreparedAddNode::~PreparedAddNode() = default;
+PreparedAddNode::PreparedAddNode(PreparedAddNode&& other) noexcept = default;
+
+PreparedAddDoc::PreparedAddDoc(uint32_t docid_in, ReadGuard read_guard_in) noexcept
+    : docid(docid_in),
+      read_guard(std::move(read_guard_in)),
+      nodes()
+{}
+PreparedAddDoc::~PreparedAddDoc() = default;
+PreparedAddDoc::PreparedAddDoc(PreparedAddDoc&& other) noexcept = default;
+}
+
 template <HnswIndexType type>
 vespalib::datastore::ArrayStoreConfig
 HnswIndex<type>::make_default_level_array_store_config()
@@ -415,6 +435,10 @@ HnswIndex<type>::HnswIndex(const DocVectorAccess& vectors, DistanceFunction::UP
 template <HnswIndexType type>
 HnswIndex<type>::~HnswIndex() = default;
 
+using internal::PreparedAddNode;
+using internal::PreparedAddDoc;
+using internal::PreparedFirstAddDoc;
+
 template <HnswIndexType type>
 void
 HnswIndex<type>::add_document(uint32_t docid)
@@ -434,7 +458,7 @@ HnswIndex<type>::add_document(uint32_t docid)
 }
 
 template <HnswIndexType type>
-typename HnswIndex<type>::PreparedAddDoc
+PreparedAddDoc
 HnswIndex<type>::internal_prepare_add(uint32_t docid, VectorBundle input_vectors, vespalib::GenerationHandler::Guard read_guard) const
 {
     PreparedAddDoc op(docid, std::move(read_guard));
@@ -449,10 +473,10 @@ HnswIndex<type>::internal_prepare_add(uint32_t docid, VectorBundle input_vectors
 
 template <HnswIndexType type>
 void
-HnswIndex<type>::internal_prepare_add_node(typename HnswIndex::PreparedAddDoc& op, TypedCells input_vector, const typename GraphType::EntryNode& entry) const
+HnswIndex<type>::internal_prepare_add_node(PreparedAddDoc& op, TypedCells input_vector, const typename GraphType::EntryNode& entry) const
 {
     int node_max_level = std::min(_level_generator->max_level(), max_max_level);
-    std::vector<typename PreparedAddNode::Links> connections(node_max_level + 1);
+    std::vector<PreparedAddNode::Links> connections(node_max_level + 1);
     if (entry.nodeid == 0) {
         // graph has no entry point
         op.nodes.emplace_back(std::move(connections));
diff --git a/searchlib/src/vespa/searchlib/tensor/hnsw_index.h b/searchlib/src/vespa/searchlib/tensor/hnsw_index.h
index 8d348d13f15..984acc6c9a1 100644
--- a/searchlib/src/vespa/searchlib/tensor/hnsw_index.h
+++ b/searchlib/src/vespa/searchlib/tensor/hnsw_index.h
@@ -39,6 +39,29 @@ namespace search::tensor {
  * TODO: Add details on how to handle removes.
  */
 
+namespace internal {
+struct PreparedAddNode {
+    using Links = std::vector<std::pair<uint32_t, vespalib::datastore::EntryRef>>;
+    std::vector<Links> connections;
+
+    PreparedAddNode() noexcept;
+    explicit PreparedAddNode(std::vector<Links>&& connections_in) noexcept;
+    ~PreparedAddNode();
+    PreparedAddNode(PreparedAddNode&& other) noexcept;
+};
+
+struct PreparedFirstAddDoc : public PrepareResult {};
+
+struct PreparedAddDoc : public PrepareResult {
+    using ReadGuard = vespalib::GenerationHandler::Guard;
+    uint32_t docid;
+    ReadGuard read_guard;
+    std::vector<PreparedAddNode> nodes;
+    PreparedAddDoc(uint32_t docid_in, ReadGuard read_guard_in) noexcept;
+    ~PreparedAddDoc();
+    PreparedAddDoc(PreparedAddDoc&& other) noexcept;
+};
+}
 template <HnswIndexType type>
 class HnswIndex : public NearestNeighborIndex {
 public:
@@ -155,43 +178,12 @@ protected:
                                          const GlobalFilter *filter, uint32_t explore_k,
                                          double distance_threshold) const;
 
-    struct PreparedAddNode {
-        using Links = std::vector<std::pair<uint32_t, vespalib::datastore::EntryRef>>;
-        std::vector<Links> connections;
-
-        PreparedAddNode() noexcept
-            : connections()
-        {
-        }
-        PreparedAddNode(std::vector<Links>&& connections_in) noexcept
-            : connections(std::move(connections_in))
-        {
-        }
-        ~PreparedAddNode() = default;
-        PreparedAddNode(PreparedAddNode&& other) noexcept = default;
-    };
-
-    struct PreparedFirstAddDoc : public PrepareResult {};
-
-    struct PreparedAddDoc : public PrepareResult {
-        using ReadGuard = vespalib::GenerationHandler::Guard;
-        uint32_t docid;
-        ReadGuard read_guard;
-        std::vector<PreparedAddNode> nodes;
-        PreparedAddDoc(uint32_t docid_in, ReadGuard read_guard_in)
-          : docid(docid_in),
-            read_guard(std::move(read_guard_in)),
-            nodes()
-        {}
-        ~PreparedAddDoc() = default;
-        PreparedAddDoc(PreparedAddDoc&& other) = default;
-    };
-    PreparedAddDoc internal_prepare_add(uint32_t docid, VectorBundle input_vectors,
+    internal::PreparedAddDoc internal_prepare_add(uint32_t docid, VectorBundle input_vectors,
                                         vespalib::GenerationHandler::Guard read_guard) const;
-    void internal_prepare_add_node(HnswIndex::PreparedAddDoc& op, TypedCells input_vector, const typename GraphType::EntryNode& entry) const;
-    LinkArray filter_valid_nodeids(uint32_t level, const typename PreparedAddNode::Links &neighbors, uint32_t self_nodeid);
-    void internal_complete_add(uint32_t docid, PreparedAddDoc &op);
-    void internal_complete_add_node(uint32_t nodeid, uint32_t docid, uint32_t subspace, PreparedAddNode &prepared_node);
+    void internal_prepare_add_node(internal::PreparedAddDoc& op, TypedCells input_vector, const typename GraphType::EntryNode& entry) const;
+    LinkArray filter_valid_nodeids(uint32_t level, const internal::PreparedAddNode::Links &neighbors, uint32_t self_nodeid);
+    void internal_complete_add(uint32_t docid, internal::PreparedAddDoc &op);
+    void internal_complete_add_node(uint32_t nodeid, uint32_t docid, uint32_t subspace, internal::PreparedAddNode &prepared_node);
 public:
     HnswIndex(const DocVectorAccess& vectors, DistanceFunction::UP distance_func,
               RandomLevelGenerator::UP level_generator, const HnswIndexConfig& cfg);
diff --git a/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h b/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h
index 1f3017237a5..208e5cb6de3 100644
--- a/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h
+++ b/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h
@@ -8,10 +8,10 @@ namespace search::test {
 
 class WeightedChildrenVerifier : public SearchIteratorVerifier {
 public:
-    WeightedChildrenVerifier() :
-        _weights(_num_children, 1)
+    WeightedChildrenVerifier()
+        : _weights(_num_children, 1)
     { }
-    ~WeightedChildrenVerifier() {}
+    ~WeightedChildrenVerifier() override {}
 
 protected:
     static constexpr size_t _num_children = 7;
@@ -21,15 +21,16 @@ protected:
 
 class IteratorChildrenVerifier : public WeightedChildrenVerifier {
 public:
-    IteratorChildrenVerifier() :
-        WeightedChildrenVerifier(),
-        _split_lists(_num_children)
+    IteratorChildrenVerifier()
+        : WeightedChildrenVerifier(),
+          _split_lists(_num_children)
     {
         auto full_list = getExpectedDocIds();
         for (size_t i = 0; i < full_list.size(); ++i) {
             _split_lists[i % _num_children].push_back(full_list[i]);
         }
     }
+    ~IteratorChildrenVerifier() override { }
     SearchIterator::UP create(bool strict) const override {
         (void) strict;
         std::vector<SearchIterator*> children;
@@ -58,7 +59,7 @@ public:
             _helper.set_doc(full_list[i], i % _num_children, 1);
         }
     }
-    ~DwaIteratorChildrenVerifier() {}
+    ~DwaIteratorChildrenVerifier() override {}
     SearchIterator::UP create(bool strict) const override {
         (void) strict;
         std::vector<DocumentWeightIterator> children;
@@ -69,9 +70,8 @@ public:
         return create(std::move(children));
     }
 protected:
-    virtual SearchIterator::UP create(std::vector<DocumentWeightIterator> && children) const  {
-        (void) children;
-        return SearchIterator::UP();
+    virtual SearchIterator::UP create(std::vector<DocumentWeightIterator> &&) const  {
+        return {};
     }
     DocumentWeightAttributeHelper _helper;
 };