Allow control of wand range

8 files changed, 123 insertions, 78 deletions

diff --git a/searchlib/src/tests/queryeval/blueprint/intermediate_blueprints_test.cpp b/searchlib/src/tests/queryeval/blueprint/intermediate_blueprints_test.cpp
index bddc9f92111..48ddeed47e9 100644
--- a/searchlib/src/tests/queryeval/blueprint/intermediate_blueprints_test.cpp
+++ b/searchlib/src/tests/queryeval/blueprint/intermediate_blueprints_test.cpp
@@ -27,8 +27,9 @@
 LOG_SETUP("blueprint_test");
 
 using namespace search::queryeval;
-using namespace search::fef;
 using namespace search::query;
+using search::fef::MatchData;
+using search::queryeval::Blueprint;
 using search::BitVector;
 using BlueprintVector = std::vector<std::unique_ptr<Blueprint>>;
 using vespalib::Slime;
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 5e056eb6c0e..55dc3868ed4 100644
--- a/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
+++ b/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
@@ -29,17 +29,17 @@ struct Stats {
     size_t unpackCnt;
     size_t skippedDocs;
     size_t skippedHits;
-    Stats() : hitCnt(0), seekCnt(0), unpackCnt(0),
+    Stats() noexcept : hitCnt(0), seekCnt(0), unpackCnt(0),
               skippedDocs(0), skippedHits(0) {}
-    void hit() {
+    void hit() noexcept {
         ++hitCnt;
     }
-    void seek(size_t docs, size_t hits) {
+    void seek(size_t docs, size_t hits) noexcept {
         ++seekCnt;
         skippedDocs += docs;
         skippedHits += hits;
     }
-    void unpack() {
+    void unpack() noexcept {
         ++unpackCnt;
     }
     void print() {
@@ -77,7 +77,7 @@ struct ModSearch : SearchIterator {
         }
     }
     void doUnpack(uint32_t docid) override {
-        if (tfmd != NULL) {
+        if (tfmd != nullptr) {
             tfmd->reset(docid);
             search::fef::TermFieldMatchDataPosition pos;
             pos.setElementWeight(info.getMaxWeight());
@@ -96,16 +96,16 @@ ModSearch::~ModSearch() = default;
 struct WandFactory {
     virtual std::string name() const = 0;
     virtual SearchIterator::UP create(const wand::Terms &terms) = 0;
-    virtual ~WandFactory() {}
+    virtual ~WandFactory() = default;
 };
 
 struct VespaWandFactory : WandFactory {
     uint32_t n;
-    VespaWandFactory(uint32_t n_in) : n(n_in) {}
+    explicit VespaWandFactory(uint32_t n_in) noexcept : n(n_in) {}
     ~VespaWandFactory() override;
-    virtual std::string name() const override { return make_string("VESPA WAND (n=%u)", n); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(WeakAndSearch::create(terms, n, true));
+    std::string name() const override { return make_string("VESPA WAND (n=%u)", n); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return WeakAndSearch::create(terms, n, true);
     }
 };
 
@@ -113,11 +113,11 @@ VespaWandFactory::~VespaWandFactory() = default;
 
 struct VespaArrayWandFactory : WandFactory {
     uint32_t n;
-    VespaArrayWandFactory(uint32_t n_in) : n(n_in) {}
+    explicit VespaArrayWandFactory(uint32_t n_in) noexcept : n(n_in) {}
     ~VespaArrayWandFactory() override;
-    virtual std::string name() const override { return make_string("VESPA ARRAY WAND (n=%u)", n); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(WeakAndSearch::createArrayWand(terms, n, true));
+    std::string name() const override { return make_string("VESPA ARRAY WAND (n=%u)", n); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return WeakAndSearch::createArrayWand(terms, wand::TermFrequencyScorer(), n, true);
     }
 };
 
@@ -125,11 +125,11 @@ VespaArrayWandFactory::~VespaArrayWandFactory() = default;
 
 struct VespaHeapWandFactory : WandFactory {
     uint32_t n;
-    VespaHeapWandFactory(uint32_t n_in) : n(n_in) {}
+    explicit VespaHeapWandFactory(uint32_t n_in) noexcept : n(n_in) {}
     ~VespaHeapWandFactory() override;
-    virtual std::string name() const override { return make_string("VESPA HEAP WAND (n=%u)", n); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(WeakAndSearch::createHeapWand(terms, n, true));
+    std::string name() const override { return make_string("VESPA HEAP WAND (n=%u)", n); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return WeakAndSearch::createHeapWand(terms, wand::TermFrequencyScorer(), n, true);
     }
 };
 
@@ -138,39 +138,39 @@ VespaHeapWandFactory::~VespaHeapWandFactory() = default;
 struct VespaParallelWandFactory : public WandFactory {
     SharedWeakAndPriorityQueue scores;
     TermFieldMatchData rootMatchData;
-    VespaParallelWandFactory(uint32_t n) : scores(n), rootMatchData() {}
+    explicit VespaParallelWandFactory(uint32_t n) noexcept : scores(n), rootMatchData() {}
     ~VespaParallelWandFactory() override;
-    virtual std::string name() const override { return make_string("VESPA PWAND (n=%u)", scores.getScoresToTrack()); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(ParallelWeakAndSearch::create(terms,
+    std::string name() const override { return make_string("VESPA PWAND (n=%u)", scores.getScoresToTrack()); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return ParallelWeakAndSearch::create(terms,
                         PWMatchParams(scores, 0, 1, 1),
-                        PWRankParams(rootMatchData, MatchData::UP()), true));
+                        PWRankParams(rootMatchData, {}), true);
     }
 };
 
 VespaParallelWandFactory::~VespaParallelWandFactory() = default;
 
 struct VespaParallelArrayWandFactory : public VespaParallelWandFactory {
-    VespaParallelArrayWandFactory(uint32_t n) : VespaParallelWandFactory(n) {}
+    VespaParallelArrayWandFactory(uint32_t n) noexcept : VespaParallelWandFactory(n) {}
     ~VespaParallelArrayWandFactory() override;
-    virtual std::string name() const override { return make_string("VESPA ARRAY PWAND (n=%u)", scores.getScoresToTrack()); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(ParallelWeakAndSearch::createArrayWand(terms,
+    std::string name() const override { return make_string("VESPA ARRAY PWAND (n=%u)", scores.getScoresToTrack()); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return ParallelWeakAndSearch::createArrayWand(terms,
                         PWMatchParams(scores, 0, 1, 1),
-                        PWRankParams(rootMatchData, MatchData::UP()), true));
+                        PWRankParams(rootMatchData, {}), true);
     }
 };
 
 VespaParallelArrayWandFactory::~VespaParallelArrayWandFactory() = default;
 
 struct VespaParallelHeapWandFactory : public VespaParallelWandFactory {
-    VespaParallelHeapWandFactory(uint32_t n) : VespaParallelWandFactory(n) {}
+    explicit VespaParallelHeapWandFactory(uint32_t n) noexcept : VespaParallelWandFactory(n) {}
     ~VespaParallelHeapWandFactory() override;
-    virtual std::string name() const override { return make_string("VESPA HEAP PWAND (n=%u)", scores.getScoresToTrack()); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(ParallelWeakAndSearch::createHeapWand(terms,
+    std::string name() const override { return make_string("VESPA HEAP PWAND (n=%u)", scores.getScoresToTrack()); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return ParallelWeakAndSearch::createHeapWand(terms,
                         PWMatchParams(scores, 0, 1, 1),
-                        PWRankParams(rootMatchData, MatchData::UP()), true));
+                        PWRankParams(rootMatchData, {}), true);
     }
 };
 
@@ -178,11 +178,11 @@ VespaParallelHeapWandFactory::~VespaParallelHeapWandFactory() = default;
 
 struct TermFrequencyRiseWandFactory : WandFactory {
     uint32_t n;
-    TermFrequencyRiseWandFactory(uint32_t n_in) : n(n_in) {}
+    explicit TermFrequencyRiseWandFactory(uint32_t n_in) noexcept : n(n_in) {}
     ~TermFrequencyRiseWandFactory() override;
-    virtual std::string name() const override { return make_string("RISE WAND TF (n=%u)", n); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(new rise::TermFrequencyRiseWand(terms, n));
+    std::string name() const override { return make_string("RISE WAND TF (n=%u)", n); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return std::make_unique<rise::TermFrequencyRiseWand>(terms, n);
     }
 };
 
@@ -190,11 +190,11 @@ TermFrequencyRiseWandFactory::~TermFrequencyRiseWandFactory() = default;
 
 struct DotProductRiseWandFactory : WandFactory {
     uint32_t n;
-    DotProductRiseWandFactory(uint32_t n_in) : n(n_in) {}
+    explicit DotProductRiseWandFactory(uint32_t n_in) noexcept : n(n_in) {}
     ~DotProductRiseWandFactory() override;
-    virtual std::string name() const override { return make_string("RISE WAND DP (n=%u)", n); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
-        return SearchIterator::UP(new rise::DotProductRiseWand(terms, n));
+    std::string name() const override { return make_string("RISE WAND DP (n=%u)", n); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
+        return std::make_unique<rise::DotProductRiseWand>(terms, n);
     }
 };
 
@@ -204,13 +204,13 @@ struct FilterFactory : WandFactory {
     WandFactory &factory;
     Stats stats;
     uint32_t n;
-    FilterFactory(WandFactory &f, uint32_t n_in) : factory(f), n(n_in) {}
+    FilterFactory(WandFactory &f, uint32_t n_in) noexcept : factory(f), n(n_in) {}
     ~FilterFactory() override;
-    virtual std::string name() const override { return make_string("Filter (mod=%u) [%s]", n, factory.name().c_str()); }
-    virtual SearchIterator::UP create(const wand::Terms &terms) override {
+    std::string name() const override { return make_string("Filter (mod=%u) [%s]", n, factory.name().c_str()); }
+    SearchIterator::UP create(const wand::Terms &terms) override {
         AndNotSearch::Children children;
         children.push_back(factory.create(terms));
-        children.emplace_back(new ModSearch(stats, n, search::endDocId, n, NULL));
+        children.emplace_back(new ModSearch(stats, n, search::endDocId, n, nullptr));
         return AndNotSearch::create(std::move(children), true);
     }
 };
@@ -220,8 +220,8 @@ FilterFactory::~FilterFactory() = default;
 struct Setup {
     Stats    stats;
     vespalib::duration  minTime;
-    Setup() : stats(), minTime(10000s) {}
-    virtual ~Setup() {}
+    Setup() noexcept : stats(), minTime(10000s) {}
+    virtual ~Setup() = default;
     virtual std::string name() const = 0;
     virtual SearchIterator::UP create() = 0;
     void perform() {
@@ -256,10 +256,10 @@ struct WandSetup : Setup {
     MatchData::UP matchData;
     WandSetup(WandFactory &f, uint32_t c, uint32_t l) : Setup(), factory(f), childCnt(c), limit(l), weight(100), matchData() {}
     ~WandSetup() override;
-    virtual std::string name() const override {
+    std::string name() const override {
         return make_string("Wand Setup (terms=%u,docs=%u) [%s]", childCnt, limit, factory.name().c_str());
     }
-    virtual SearchIterator::UP create() override {
+    SearchIterator::UP create() override {
         MatchDataLayout layout;
         std::vector<TermFieldHandle> handles;
         for (size_t i = 0; i < childCnt; ++i) {
diff --git a/searchlib/src/vespa/searchlib/features/bm25_feature.cpp b/searchlib/src/vespa/searchlib/features/bm25_feature.cpp
index 505b8166ee7..03d2e94b5d0 100644
--- a/searchlib/src/vespa/searchlib/features/bm25_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/bm25_feature.cpp
@@ -68,7 +68,7 @@ Bm25Executor::Bm25Executor(const fef::FieldInfo& field,
 }
 
 double
-Bm25Executor::calculate_inverse_document_frequency(uint32_t matching_doc_count, uint32_t total_doc_count)
+Bm25Executor::calculate_inverse_document_frequency(uint32_t matching_doc_count, uint32_t total_doc_count) noexcept
 {
     return std::log(1 + (static_cast<double>(total_doc_count - matching_doc_count + 0.5) /
                          static_cast<double>(matching_doc_count + 0.5)));
diff --git a/searchlib/src/vespa/searchlib/features/bm25_feature.h b/searchlib/src/vespa/searchlib/features/bm25_feature.h
index a1b45375285..637d656990b 100644
--- a/searchlib/src/vespa/searchlib/features/bm25_feature.h
+++ b/searchlib/src/vespa/searchlib/features/bm25_feature.h
@@ -39,7 +39,7 @@ public:
                  double k1_param,
                  double b_param);
 
-    double static calculate_inverse_document_frequency(uint32_t matching_doc_count, uint32_t total_doc_count);
+    double static calculate_inverse_document_frequency(uint32_t matching_doc_count, uint32_t total_doc_count) noexcept;
 
     void handle_bind_match_data(const fef::MatchData& match_data) override;
     void execute(uint32_t docId) override;
diff --git a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
index 33b249572f0..74c8b3534b8 100644
--- a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
@@ -492,7 +492,9 @@ WeakAndBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                            _weights[i],
                            getChild(i).getState().estimate().estHits);
     }
-    return WeakAndSearch::create(terms, _n, strict());
+    return (true)
+        ? WeakAndSearch::create(terms, wand::TermFrequencyScorer(), _n, strict())
+        : WeakAndSearch::create(terms, wand::Bm25TermFrequencyScorer(get_docid_limit(), 1.0), _n, strict());
 }
 
 SearchIterator::UP
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
index 4e781f8497b..69901993dfe 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
@@ -2,10 +2,9 @@
 
 #pragma once
 
-#include <algorithm>
-#include <cmath>
 #include <vespa/searchlib/fef/matchdata.h>
 #include <vespa/searchlib/fef/termfieldmatchdata.h>
+#include <vespa/searchlib/features/bm25_feature.h>
 #include <vespa/searchlib/queryeval/searchiterator.h>
 #include <vespa/searchlib/queryeval/iterator_pack.h>
 #include <vespa/searchlib/attribute/posting_iterator_pack.h>
@@ -13,20 +12,16 @@
 #include <vespa/vespalib/util/priority_queue.h>
 #include <vespa/searchlib/attribute/i_docid_with_weight_posting_store.h>
 #include <vespa/vespalib/util/stringfmt.h>
+#include <cmath>
 
 namespace search::queryeval::wand {
 
 //-----------------------------------------------------------------------------
 
-struct Term;
-using Terms = std::vector<Term>;
 using score_t = int64_t;
 using docid_t = uint32_t;
 using ref_t = uint16_t;
 
-using Attr = IDirectPostingStore;
-using AttrDictEntry = Attr::LookupResult;
-
 //-----------------------------------------------------------------------------
 
 /**
@@ -46,7 +41,7 @@ struct Term {
     Term(SearchIterator *s, int32_t w, uint32_t e) noexcept : Term(s, w, e, nullptr) {}
     Term(SearchIterator::UP s, int32_t w, uint32_t e) noexcept : Term(s.release(), w, e, nullptr) {}
 };
-
+using Terms = std::vector<Term>;
 //-----------------------------------------------------------------------------
 
 // input manipulation utilities
@@ -75,7 +70,7 @@ auto assemble(const F &f, const Order &order)->std::vector<decltype(f(0))> {
 }
 
 int32_t get_max_weight(const SearchIterator &search) {
-    const MinMaxPostingInfo *minMax = dynamic_cast<const MinMaxPostingInfo *>(search.getPostingInfo());
+    const auto *minMax = dynamic_cast<const MinMaxPostingInfo *>(search.getPostingInfo());
     return (minMax != nullptr) ? minMax->getMaxWeight() : std::numeric_limits<int32_t>::max();
 }
 
@@ -291,7 +286,7 @@ struct VectorizedAttributeTerms : VectorizedState<DocidWithWeightIteratorPack> {
  **/
 struct DocIdOrder {
     const docid_t *termPos;
-    explicit DocIdOrder(docid_t *pos) noexcept : termPos(pos) {}
+    explicit DocIdOrder(const docid_t *pos) noexcept : termPos(pos) {}
     bool at_end(ref_t ref) const noexcept { return termPos[ref] == search::endDocId; }
     docid_t get_pos(ref_t ref) const noexcept { return termPos[ref]; }
     bool operator()(ref_t a, ref_t b) const noexcept {
@@ -412,6 +407,34 @@ struct TermFrequencyScorer
     }
 };
 
+class Bm25TermFrequencyScorer
+{
+public:
+    using Bm25Executor = features::Bm25Executor;
+    Bm25TermFrequencyScorer(uint32_t num_docs, float range) noexcept
+        : _num_docs(num_docs),
+          _range(range),
+          _max_idf(Bm25Executor::calculate_inverse_document_frequency(1, _num_docs))
+    { }
+    // weight * idf, scaled to fixedpoint
+    score_t calculateMaxScore(double estHits, double weight) const noexcept {
+        return weight * Bm25Executor::calculate_inverse_document_frequency(estHits, _num_docs);
+    }
+
+    score_t calculateMaxScore(const Term &term) const noexcept {
+        return calculateMaxScore(term.estHits, term.weight) + 1;
+    }
+
+    template <typename Input>
+    score_t calculate_max_score(const Input &input, ref_t ref) const noexcept {
+        return calculateMaxScore(input.get_est_hits(ref), input.get_weight(ref)) + 1;
+    }
+private:
+    uint32_t _num_docs;
+    float    _range;
+    double   _max_idf;
+};
+
 //-----------------------------------------------------------------------------
 
 /**
@@ -453,14 +476,14 @@ struct DotProductScorer
 // used with parallel wand where we can safely discard hits based on score
 struct GreaterThan {
     score_t threshold;
-    GreaterThan(score_t t) : threshold(t) {}
+    explicit GreaterThan(score_t t) noexcept : threshold(t) {}
     bool operator()(score_t score) const { return (score > threshold); }
 };
 
 // used with old-style vespa wand to ensure at least AND'ish results
 struct GreaterThanEqual {
     score_t threshold;
-    GreaterThanEqual(score_t t) : threshold(t) {}
+    explicit GreaterThanEqual(score_t t) noexcept : threshold(t) {}
     bool operator()(score_t score) const { return (score >= threshold); }
 };
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
index 04b1cb75da4..58ffcfe17bc 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
@@ -42,8 +42,9 @@ private:
     }
 
 public:
-    WeakAndSearchLR(const Terms &terms, uint32_t n)
-        : _terms(terms, TermFrequencyScorer(), 0, {}),
+    template<typename Scorer>
+    WeakAndSearchLR(const Terms &terms, const Scorer & scorer, uint32_t n)
+        : _terms(terms, scorer, 0, {}),
           _heaps(DocIdOrder(_terms.docId()), _terms.size()),
           _algo(),
           _threshold(1),
@@ -102,36 +103,50 @@ WeakAndSearch::visitMembers(vespalib::ObjectVisitor &visitor) const
 
 //-----------------------------------------------------------------------------
 
+template<typename Scorer>
 SearchIterator::UP
-WeakAndSearch::createArrayWand(const Terms &terms, uint32_t n, bool strict)
+WeakAndSearch::createArrayWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict)
 {
     if (strict) {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>>(terms, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>>(terms, scorer, n);
     } else {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>>(terms, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>>(terms, scorer, n);
     }
 }
 
+template<typename Scorer>
 SearchIterator::UP
-WeakAndSearch::createHeapWand(const Terms &terms, uint32_t n, bool strict)
+WeakAndSearch::createHeapWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict)
 {
     if (strict) {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>>(terms, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>>(terms, scorer, n);
     } else {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>>(terms, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>>(terms, scorer, n);
     }
 }
 
+template<typename Scorer>
 SearchIterator::UP
-WeakAndSearch::create(const Terms &terms, uint32_t n, bool strict)
+WeakAndSearch::create(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict)
 {
     if (terms.size() < 128) {
-        return createArrayWand(terms, n, strict);
+        return createArrayWand(terms, scorer, n, strict);
     } else {
-        return createHeapWand(terms, n, strict);
+        return createHeapWand(terms, scorer, n, strict);
     }
 }
 
+SearchIterator::UP
+WeakAndSearch::create(const Terms &terms, uint32_t n, bool strict)
+{
+    return create(terms, wand::TermFrequencyScorer(), n, strict);
+}
+
 //-----------------------------------------------------------------------------
 
+template SearchIterator::UP WeakAndSearch::create<wand::TermFrequencyScorer>(const Terms &terms, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
+template SearchIterator::UP WeakAndSearch::createArrayWand<wand::TermFrequencyScorer>(const Terms &terms, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
+template SearchIterator::UP WeakAndSearch::createHeapWand<wand::TermFrequencyScorer>(const Terms &terms, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
+
 }
+
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
index 6a56a04887c..a91b2860a63 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
@@ -15,8 +15,12 @@ struct WeakAndSearch : SearchIterator {
     virtual const Terms &getTerms() const = 0;
     virtual uint32_t getN() const = 0;
     void visitMembers(vespalib::ObjectVisitor &visitor) const override;
-    static SearchIterator::UP createArrayWand(const Terms &terms, uint32_t n, bool strict);
-    static SearchIterator::UP createHeapWand(const Terms &terms, uint32_t n, bool strict);
+    template<typename Scorer>
+    static SearchIterator::UP createArrayWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict);
+    template<typename Scorer>
+    static SearchIterator::UP createHeapWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict);
+    template<typename Scorer>
+    static SearchIterator::UP create(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict);
     static SearchIterator::UP create(const Terms &terms, uint32_t n, bool strict);
 };