use custom types for true/false (NodeTypes::True, ProtonTrue, etc)

8 files changed, 44 insertions, 9 deletions

diff --git a/searchlib/src/tests/query/customtypevisitor_test.cpp b/searchlib/src/tests/query/customtypevisitor_test.cpp
index 112e49cd1c1..da3d8ffa115 100644
--- a/searchlib/src/tests/query/customtypevisitor_test.cpp
+++ b/searchlib/src/tests/query/customtypevisitor_test.cpp
@@ -42,7 +42,11 @@ struct MyDotProduct : DotProduct { MyDotProduct() : DotProduct(0, "view", 0, Wei
 struct MyWandTerm : WandTerm { MyWandTerm() : WandTerm(0, "view", 0, Weight(42), 57, 67, 77.7) {} };
 struct MyPredicateQuery : InitTerm<PredicateQuery> {};
 struct MyRegExpTerm : InitTerm<RegExpTerm>  {};
-struct MyNearestNeighborTerm : NearestNeighborTerm {};
+struct MyNearestNeighborTerm : NearestNeighborTerm {
+    MyNearestNeighborTerm() : NearestNeighborTerm("qt", "fn", 0, Weight(42), 10, true, 666, 1234.5) {}
+};
+struct MyTrue : TrueQueryNode {};
+struct MyFalse : FalseQueryNode {};
 
 struct MyQueryNodeTypes {
     typedef MyAnd And;
@@ -68,6 +72,8 @@ struct MyQueryNodeTypes {
     typedef MyPredicateQuery PredicateQuery;
     typedef MyRegExpTerm RegExpTerm;
     typedef MyNearestNeighborTerm NearestNeighborTerm;
+    typedef MyFalse False;
+    typedef MyTrue True;
 };
 
 class MyCustomVisitor : public CustomTypeVisitor<MyQueryNodeTypes>
@@ -104,8 +110,8 @@ public:
     void visit(MyPredicateQuery &) override { setVisited<MyPredicateQuery>(); }
     void visit(MyRegExpTerm &) override { setVisited<MyRegExpTerm>(); }
     void visit(MyNearestNeighborTerm &) override { setVisited<MyNearestNeighborTerm>(); }
-    void visit(TrueQueryNode &) override {}
-    void visit(FalseQueryNode &) override {}
+    void visit(MyTrue &) override { setVisited<MyTrue>(); }
+    void visit(MyFalse &) override { setVisited<MyFalse>(); }
 };
 
 template <class T>
@@ -138,6 +144,10 @@ TEST("customtypevisitor_test") {
     requireThatNodeIsVisited<MyWandTerm>();
     requireThatNodeIsVisited<MyPredicateQuery>();
     requireThatNodeIsVisited<MyRegExpTerm>();
+    requireThatNodeIsVisited<MyLocationTerm>();
+    requireThatNodeIsVisited<MyNearestNeighborTerm>();
+    requireThatNodeIsVisited<MyTrue>();
+    requireThatNodeIsVisited<MyFalse>();
 }
 }  // namespace
 
diff --git a/searchlib/src/tests/query/querybuilder_test.cpp b/searchlib/src/tests/query/querybuilder_test.cpp
index 0c784287e5c..b421084bbef 100644
--- a/searchlib/src/tests/query/querybuilder_test.cpp
+++ b/searchlib/src/tests/query/querybuilder_test.cpp
@@ -409,6 +409,8 @@ struct MyNearestNeighborTerm : NearestNeighborTerm {
       : NearestNeighborTerm(query_tensor_name, field_name, i, w, target_num_hits, allow_approximate, explore_additional_hits, distance_threshold)
     {}
 };
+struct MyTrue : TrueQueryNode {};
+struct MyFalse : FalseQueryNode {};
 
 struct MyQueryNodeTypes {
     typedef MyAnd And;
@@ -434,6 +436,8 @@ struct MyQueryNodeTypes {
     typedef MyPredicateQuery PredicateQuery;
     typedef MyRegExpTerm RegExpTerm;
     typedef MyNearestNeighborTerm NearestNeighborTerm;
+    typedef MyTrue True;
+    typedef MyFalse False;
 };
 
 TEST("require that Custom Query Trees Can Be Built") {
diff --git a/searchlib/src/vespa/searchlib/query/tree/const_bool_nodes.h b/searchlib/src/vespa/searchlib/query/tree/const_bool_nodes.h
index fae7c943319..fd31f3bf8f2 100644
--- a/searchlib/src/vespa/searchlib/query/tree/const_bool_nodes.h
+++ b/searchlib/src/vespa/searchlib/query/tree/const_bool_nodes.h
@@ -7,11 +7,13 @@
 namespace search::query {
 
 class TrueQueryNode : public Node {
+public:
     ~TrueQueryNode();
     void accept(QueryVisitor &visitor) override { visitor.visit(*this); }
 };
 
 class FalseQueryNode : public Node {
+public:
     ~FalseQueryNode();
     void accept(QueryVisitor &visitor) override { visitor.visit(*this); }
 };
diff --git a/searchlib/src/vespa/searchlib/query/tree/customtypetermvisitor.h b/searchlib/src/vespa/searchlib/query/tree/customtypetermvisitor.h
index cc593840d87..80b854acaf9 100644
--- a/searchlib/src/vespa/searchlib/query/tree/customtypetermvisitor.h
+++ b/searchlib/src/vespa/searchlib/query/tree/customtypetermvisitor.h
@@ -29,8 +29,8 @@ private:
     void visit(typename NodeTypes::SameElement &n) override { visitChildren(n); }
 
     // leaf nodes without terms:
-    void visit(TrueQueryNode &) override {}
-    void visit(FalseQueryNode &) override {}
+    void visit(typename NodeTypes::True &) override {}
+    void visit(typename NodeTypes::False &) override {}
 
     // phrases and weighted set terms are conceptual leaf nodes and
     // should be handled that way.
diff --git a/searchlib/src/vespa/searchlib/query/tree/customtypevisitor.h b/searchlib/src/vespa/searchlib/query/tree/customtypevisitor.h
index aa4408d0dbe..0e1f590c348 100644
--- a/searchlib/src/vespa/searchlib/query/tree/customtypevisitor.h
+++ b/searchlib/src/vespa/searchlib/query/tree/customtypevisitor.h
@@ -50,6 +50,8 @@ public:
     virtual void visit(typename NodeTypes::PredicateQuery &) = 0;
     virtual void visit(typename NodeTypes::RegExpTerm &) = 0;
     virtual void visit(typename NodeTypes::NearestNeighborTerm &) = 0;
+    virtual void visit(typename NodeTypes::True &) = 0;
+    virtual void visit(typename NodeTypes::False &) = 0;
 
 private:
     // Route QueryVisit requests to the correct custom type.
@@ -77,6 +79,8 @@ private:
     typedef typename NodeTypes::PredicateQuery TPredicateQuery;
     typedef typename NodeTypes::RegExpTerm TRegExpTerm;
     typedef typename NodeTypes::NearestNeighborTerm TNearestNeighborTerm;
+    typedef typename NodeTypes::True TTrue;
+    typedef typename NodeTypes::False TFalse;
 
     void visit(And &n) override { visit(static_cast<TAnd&>(n)); }
     void visit(AndNot &n) override { visit(static_cast<TAndNot&>(n)); }
@@ -101,6 +105,8 @@ private:
     void visit(PredicateQuery &n) override { visit(static_cast<TPredicateQuery&>(n)); }
     void visit(RegExpTerm &n) override { visit(static_cast<TRegExpTerm&>(n)); }
     void visit(NearestNeighborTerm &n) override { visit(static_cast<TNearestNeighborTerm&>(n)); }
+    void visit(TrueQueryNode &n) override { visit(static_cast<TTrue&>(n)); }
+    void visit(FalseQueryNode &n) override { visit(static_cast<TFalse&>(n)); }
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/query/tree/querybuilder.h b/searchlib/src/vespa/searchlib/query/tree/querybuilder.h
index 3da8b32b9ee..1df73ededac 100644
--- a/searchlib/src/vespa/searchlib/query/tree/querybuilder.h
+++ b/searchlib/src/vespa/searchlib/query/tree/querybuilder.h
@@ -99,6 +99,12 @@ public:
 // You may specialize these functions for your own traits class to have full
 // control of the query node instantiation.
 
+template <class NodeTypes>
+typename NodeTypes::True *create_true() { return new typename NodeTypes::True; }
+
+template <class NodeTypes>
+typename NodeTypes::False *create_false() { return new typename NodeTypes::False; }
+
 // Intermediate nodes
 template <class NodeTypes>
 typename NodeTypes::And *createAnd() { return new typename NodeTypes::And; }
@@ -329,8 +335,12 @@ public:
         adjustWeight(weight);
         return addTerm(create_nearest_neighbor_term<NodeTypes>(query_tensor_name, field_name, id, weight, target_num_hits, allow_approximate, explore_additional_hits, distance_threshold));
     }
-    void add_true_node() { addTerm(new TrueQueryNode()); }
-    void add_false_node() { addTerm(new TrueQueryNode()); }
+    typename NodeTypes::True &add_true_node() {
+        return addTerm(create_true<NodeTypes>());
+    }
+    typename NodeTypes::False &add_false_node() {
+        return addTerm(create_false<NodeTypes>());
+    }
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/query/tree/simplequery.h b/searchlib/src/vespa/searchlib/query/tree/simplequery.h
index 44d869bc8bf..4829a569921 100644
--- a/searchlib/src/vespa/searchlib/query/tree/simplequery.h
+++ b/searchlib/src/vespa/searchlib/query/tree/simplequery.h
@@ -7,11 +7,14 @@
 
 #pragma once
 
+#include "const_bool_nodes.h"
 #include "intermediatenodes.h"
 #include "termnodes.h"
 
 namespace search::query {
 
+struct SimpleTrue : TrueQueryNode {};
+struct SimpleFalse : FalseQueryNode {};
 struct SimpleAnd : And {};
 struct SimpleAndNot : AndNot {};
 struct SimpleNear : Near { SimpleNear(size_t dist) : Near(dist) {} };
@@ -119,6 +122,8 @@ struct SimpleQueryNodeTypes {
     using And = SimpleAnd;
     using AndNot = SimpleAndNot;
     using Equiv = SimpleEquiv;
+    using False = SimpleFalse;
+    using True = SimpleTrue;
     using NumberTerm = SimpleNumberTerm;
     using LocationTerm = SimpleLocationTerm;
     using Near = SimpleNear;
diff --git a/searchlib/src/vespa/searchlib/queryeval/fake_searchable.cpp b/searchlib/src/vespa/searchlib/queryeval/fake_searchable.cpp
index 838a95d483a..519f6e81774 100644
--- a/searchlib/src/vespa/searchlib/queryeval/fake_searchable.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/fake_searchable.cpp
@@ -6,7 +6,6 @@
 #include "create_blueprint_visitor_helper.h"
 #include <vespa/vespalib/objects/visit.h>
 
-using search::query::FalseQueryNode;
 using search::query::LocationTerm;
 using search::query::NearestNeighborTerm;
 using search::query::Node;
@@ -18,7 +17,6 @@ using search::query::RegExpTerm;
 using search::query::StringTerm;
 using search::query::SubstringTerm;
 using search::query::SuffixTerm;
-using search::query::TrueQueryNode;
 
 namespace search::queryeval {