Override

11 files changed, 350 insertions, 355 deletions

diff --git a/eval/src/vespa/eval/eval/basic_nodes.h b/eval/src/vespa/eval/eval/basic_nodes.h
index 2887856a66d..f7bd5af3307 100644
--- a/eval/src/vespa/eval/eval/basic_nodes.h
+++ b/eval/src/vespa/eval/eval/basic_nodes.h
@@ -109,10 +109,10 @@ public:
     virtual bool is_const() const override { return true; }
     virtual double get_const_value() const override { return value(); }
     double value() const { return _value; }
-    virtual vespalib::string dump(DumpContext &) const {
+    vespalib::string dump(DumpContext &) const override {
         return make_string("%g", _value);
     }
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class Symbol : public Leaf {
@@ -122,10 +122,10 @@ public:
     static const int UNDEF = std::numeric_limits<int>::max();
     explicit Symbol(int id_in) : _id(id_in) {}
     int id() const { return _id; }
-    virtual bool is_param() const override {
+    bool is_param() const override {
         return (_id >= 0);
     }
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         if (_id >= 0) { // param value
             assert(size_t(_id) < ctx.param_names.size());
             return ctx.param_names[_id];
@@ -135,7 +135,7 @@ public:
             return ctx.let_names[let_offset];
         }
     }
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class String : public Leaf {
@@ -143,12 +143,12 @@ private:
     vespalib::string _value;
 public:
     String(const vespalib::string &value_in) : _value(value_in) {}
-    virtual bool is_const() const override { return true; }
-    virtual double get_const_value() const override { return hash(); }
+    bool is_const() const override { return true; }
+    double get_const_value() const override { return hash(); }
     const vespalib::string value() const { return _value; }
     uint32_t hash() const { return hash_code(_value.data(), _value.size()); }
-    virtual vespalib::string dump(DumpContext &ctx) const;
-    virtual void accept(NodeVisitor &visitor) const override;
+    vespalib::string dump(DumpContext &ctx) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class Array : public Node {
@@ -157,12 +157,12 @@ private:
     bool _is_const;
 public:
     Array() : _nodes(), _is_const(false) {}
-    virtual bool is_const() const override { return _is_const; }
+    bool is_const() const override { return _is_const; }
     size_t size() const { return _nodes.size(); }
     const Node &get(size_t i) const { return *_nodes[i]; }
-    virtual size_t num_children() const override { return size(); }
-    virtual const Node &get_child(size_t idx) const override { return get(idx); }
-    virtual void detach_children(NodeHandler &handler) override {
+    size_t num_children() const override { return size(); }
+    const Node &get_child(size_t idx) const override { return get(idx); }
+    void detach_children(NodeHandler &handler) override {
         for (size_t i = 0; i < _nodes.size(); ++i) {
             handler.handle(std::move(_nodes[i]));
         }
@@ -176,7 +176,7 @@ public:
         }
         _nodes.push_back(std::move(node));
     }
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         vespalib::string str;
         str += "[";
         CommaTracker node_list;
@@ -187,7 +187,7 @@ public:
         str += "]";
         return str;
     }
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class Neg : public Node {
@@ -196,25 +196,25 @@ private:
     bool _is_const;
 public:
     Neg(Node_UP child_in) : _child(std::move(child_in)), _is_const(_child->is_const()) {}
-    virtual bool is_const() const override { return _is_const; }
+    bool is_const() const override { return _is_const; }
     const Node &child() const { return *_child; }
-    virtual size_t num_children() const override { return _child ? 1 : 0; }
-    virtual const Node &get_child(size_t idx) const override {
+    size_t num_children() const override { return _child ? 1 : 0; }
+    const Node &get_child(size_t idx) const override {
         (void) idx;
         assert(idx == 0);
         return child();
     }
-    virtual void detach_children(NodeHandler &handler) override {
+    void detach_children(NodeHandler &handler) override {
         handler.handle(std::move(_child));
     }
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         vespalib::string str;
         str += "(-";
         str += _child->dump(ctx);
         str += ")";
         return str;
     }
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class Not : public Node {
@@ -223,25 +223,25 @@ private:
     bool _is_const;
 public:
     Not(Node_UP child_in) : _child(std::move(child_in)), _is_const(_child->is_const()) {}
-    virtual bool is_const() const override { return _is_const; }
+    bool is_const() const override { return _is_const; }
     const Node &child() const { return *_child; }
-    virtual size_t num_children() const override { return _child ? 1 : 0; }
-    virtual const Node &get_child(size_t idx) const override {
+    size_t num_children() const override { return _child ? 1 : 0; }
+    const Node &get_child(size_t idx) const override {
         (void) idx;
         assert(idx == 0);
         return child();
     }
-    virtual void detach_children(NodeHandler &handler) override {
+    void detach_children(NodeHandler &handler) override {
         handler.handle(std::move(_child));
     }
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         vespalib::string str;
         str += "(!";
         str += _child->dump(ctx);
         str += ")";
         return str;
     }
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class If : public Node {
@@ -257,11 +257,11 @@ public:
     const Node &true_expr() const { return *_true_expr; }
     const Node &false_expr() const { return *_false_expr; }
     double p_true() const { return _p_true; }
-    virtual bool is_tree() const override { return _is_tree; }
-    virtual size_t num_children() const override {
+    bool is_tree() const override { return _is_tree; }
+    size_t num_children() const override {
         return (_cond && _true_expr && _false_expr) ? 3 : 0;
     }
-    virtual const Node &get_child(size_t idx) const override {
+    const Node &get_child(size_t idx) const override {
         assert(idx < 3);
         if (idx == 0) {
             return cond();
@@ -271,12 +271,12 @@ public:
             return false_expr();
         }
     }
-    virtual void detach_children(NodeHandler &handler) override {
+    void detach_children(NodeHandler &handler) override {
         handler.handle(std::move(_cond));
         handler.handle(std::move(_true_expr));
         handler.handle(std::move(_false_expr));
     }
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         vespalib::string str;
         str += "if(";
         str += _cond->dump(ctx);
@@ -290,7 +290,7 @@ public:
         str += ")";
         return str;
     }
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class Let : public Node {
@@ -304,16 +304,16 @@ public:
     const vespalib::string &name() const { return _name; }
     const Node &value() const { return *_value; }
     const Node &expr() const { return *_expr; }
-    virtual size_t num_children() const override { return (_value && _expr) ? 2 : 0; }
-    virtual const Node &get_child(size_t idx) const override {
+    size_t num_children() const override { return (_value && _expr) ? 2 : 0; }
+    const Node &get_child(size_t idx) const override {
         assert(idx < 2);
         return (idx == 0) ? value() : expr();
     }
-    virtual void detach_children(NodeHandler &handler) override {
+    void detach_children(NodeHandler &handler) override {
         handler.handle(std::move(_value));
         handler.handle(std::move(_expr));
     }
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         vespalib::string str;
         str += "let(";
         str += _name;
@@ -326,7 +326,7 @@ public:
         str += ")";
         return str;
     }
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
 };
 
 class Error : public Leaf {
@@ -335,8 +335,8 @@ private:
 public:
     Error(const vespalib::string &message_in) : _message(message_in) {}
     const vespalib::string &message() const { return _message; }
-    virtual vespalib::string dump(DumpContext &) const { return _message; }
-    virtual void accept(NodeVisitor &visitor) const override;
+    vespalib::string dump(DumpContext &) const override { return _message; }
+    void accept(NodeVisitor &visitor) const override;
 };
 
 } // namespace vespalib::eval::nodes
diff --git a/eval/src/vespa/eval/eval/call_nodes.h b/eval/src/vespa/eval/eval/call_nodes.h
index 01283a00e42..87a9c6007cb 100644
--- a/eval/src/vespa/eval/eval/call_nodes.h
+++ b/eval/src/vespa/eval/eval/call_nodes.h
@@ -30,14 +30,14 @@ public:
     Call(const vespalib::string &name_in, size_t num_params_in)
         : _name(name_in), _num_params(num_params_in), _is_const(false) {}
     ~Call();
-    virtual bool is_const() const override { return _is_const; }
+    bool is_const() const override { return _is_const; }
     const vespalib::string &name() const { return _name; }
     size_t num_params() const { return _num_params; }
     size_t num_args() const { return _args.size(); }
     const Node &arg(size_t i) const { return *_args[i]; }
-    virtual size_t num_children() const override { return num_args(); }
-    virtual const Node &get_child(size_t idx) const override { return arg(idx); }
-    virtual void detach_children(NodeHandler &handler) override {
+    size_t num_children() const override { return num_args(); }
+    const Node &get_child(size_t idx) const override { return arg(idx); }
+    void detach_children(NodeHandler &handler) override {
         for (size_t i = 0; i < _args.size(); ++i) {
             handler.handle(std::move(_args[i]));
         }
@@ -51,7 +51,7 @@ public:
         }
         _args.push_back(std::move(arg_in));
     }
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         vespalib::string str;
         str += _name;
         str += "(";
@@ -106,7 +106,7 @@ struct CallHelper : Call {
     typedef CallHelper<T> Helper;
     CallHelper(const vespalib::string &name_in, size_t num_params_in)
         : Call(name_in, num_params_in) {}
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
     static Call_UP create() { return Call_UP(new T()); }
 };
 
diff --git a/eval/src/vespa/eval/eval/function.cpp b/eval/src/vespa/eval/eval/function.cpp
index 5be5147fa3a..dd8d7743041 100644
--- a/eval/src/vespa/eval/eval/function.cpp
+++ b/eval/src/vespa/eval/eval/function.cpp
@@ -83,15 +83,15 @@ struct ExplicitParams : Params {
             lookup_add(param);
         }
     }
-    virtual bool implicit() const { return false; }
-    virtual size_t resolve(vespalib::stringref token) const override {
+    bool implicit() const override { return false; }
+    size_t resolve(vespalib::stringref token) const override {
         return lookup(token);
     }
 };
 
 struct ImplicitParams : Params {
-    virtual bool implicit() const { return true; }
-    virtual size_t resolve(vespalib::stringref token) const override {
+    bool implicit() const override { return true; }
+    size_t resolve(vespalib::stringref token) const override {
         return const_cast<ImplicitParams*>(this)->lookup_add(token);
     }
 };
diff --git a/eval/src/vespa/eval/eval/interpreted_function.cpp b/eval/src/vespa/eval/eval/interpreted_function.cpp
index b308de6b3c0..82d34e1017d 100644
--- a/eval/src/vespa/eval/eval/interpreted_function.cpp
+++ b/eval/src/vespa/eval/eval/interpreted_function.cpp
@@ -239,10 +239,10 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser {
 
     //-------------------------------------------------------------------------
 
-    virtual void visit(const Number &node) {
+    void visit(const Number&node) override {
         program.emplace_back(op_load_const, wrap_param<Value>(stash.create<DoubleValue>(node.value())));
     }
-    virtual void visit(const Symbol &node) {
+    void visit(const Symbol&node) override {
         if (node.id() >= 0) { // param value
             program.emplace_back(op_load_param, node.id());
         } else { // let binding
@@ -250,19 +250,19 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser {
             program.emplace_back(op_load_let, let_offset);
         }
     }
-    virtual void visit(const String &node) {
+    void visit(const String&node) override {
         program.emplace_back(op_load_const, wrap_param<Value>(stash.create<DoubleValue>(node.hash())));
     }
-    virtual void visit(const Array &node) {
+    void visit(const Array&node) override {
         program.emplace_back(op_load_const, wrap_param<Value>(stash.create<DoubleValue>(node.size())));
     }
-    virtual void visit(const Neg &) {
+    void visit(const Neg &) override {
         program.emplace_back(op_unary<operation::Neg>);
     }
-    virtual void visit(const Not &) {
+    void visit(const Not &) override {
         program.emplace_back(op_unary<operation::Not>);
     }
-    virtual void visit(const If &node) {
+    void visit(const If&node) override {
         node.cond().traverse(*this);
         size_t after_cond = program.size();
         program.emplace_back(op_skip_if_false);
@@ -273,16 +273,16 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser {
         program[after_cond].update_param(after_true - after_cond);
         program[after_true].update_param(program.size() - after_true - 1);
     }
-    virtual void visit(const Let &node) {
+    void visit(const Let&node) override {
         node.value().traverse(*this);
         program.emplace_back(op_store_let);
         node.expr().traverse(*this);
         program.emplace_back(op_evict_let);
     }
-    virtual void visit(const Error &) {
+    void visit(const Error &) override {
         program.emplace_back(op_load_const, wrap_param<Value>(stash.create<ErrorValue>()));
     }
-    virtual void visit(const TensorSum &node) {
+    void visit(const TensorSum&node) override {
         if (is_typed(node) && is_typed_tensor_product_of_params(node.get_child(0))) {
             assert(program.size() >= 3); // load,load,mul
             program.pop_back(); // mul
@@ -307,23 +307,23 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser {
                                  wrap_param<vespalib::string>(stash.create<vespalib::string>(node.dimension())));
         }
     }
-    virtual void visit(const TensorMap &node) {
+    void visit(const TensorMap&node) override {
         const auto &token = stash.create<CompileCache::Token::UP>(CompileCache::compile(node.lambda(), PassParams::SEPARATE));
         program.emplace_back(op_tensor_map, wrap_param<CompiledFunction>(token.get()->get()));
     }
-    virtual void visit(const TensorJoin &node) {
+    void visit(const TensorJoin&node) override {
         const auto &token = stash.create<CompileCache::Token::UP>(CompileCache::compile(node.lambda(), PassParams::SEPARATE));
         program.emplace_back(op_tensor_join, wrap_param<CompiledFunction>(token.get()->get()));
     }
-    virtual void visit(const TensorReduce &node) {
+    void visit(const TensorReduce&node) override {
         ReduceParams &params = stash.create<ReduceParams>(node.aggr(), node.dimensions());
         program.emplace_back(op_tensor_reduce, wrap_param<ReduceParams>(params));
     }
-    virtual void visit(const TensorRename &node) {
+    void visit(const TensorRename&node) override {
         RenameParams &params = stash.create<RenameParams>(node.from(), node.to());
         program.emplace_back(op_tensor_rename, wrap_param<RenameParams>(params));
     }
-    virtual void visit(const TensorLambda &node) {
+    void visit(const TensorLambda&node) override {
         const auto &type = node.type();
         TensorSpec spec(type.to_spec());
         const auto &token = stash.create<CompileCache::Token::UP>(CompileCache::compile(node.lambda(), PassParams::ARRAY));
@@ -340,47 +340,47 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser {
         auto tensor = tensor_engine.create(spec);
         program.emplace_back(op_load_const, wrap_param<Value>(stash.create<TensorValue>(std::move(tensor))));
     }
-    virtual void visit(const TensorConcat &node) {
+    void visit(const TensorConcat&node) override {
         vespalib::string &dimension = stash.create<vespalib::string>(node.dimension());
         program.emplace_back(op_tensor_concat, wrap_param<vespalib::string>(dimension));
     }
-    virtual void visit(const Add &) {
+    void visit(const Add &) override {
         program.emplace_back(op_binary<operation::Add>);
     }
-    virtual void visit(const Sub &) {
+    void visit(const Sub &) override {
         program.emplace_back(op_binary<operation::Sub>);
     }
-    virtual void visit(const Mul &) {
+    void visit(const Mul &) override {
         program.emplace_back(op_binary<operation::Mul>);
     }
-    virtual void visit(const Div &) {
+    void visit(const Div &) override {
         program.emplace_back(op_binary<operation::Div>);
     }
-    virtual void visit(const Pow &) {
+    void visit(const Pow &) override {
         program.emplace_back(op_binary<operation::Pow>);
     }
-    virtual void visit(const Equal &) {
+    void visit(const Equal &) override {
         program.emplace_back(op_binary<operation::Equal>);
     }
-    virtual void visit(const NotEqual &) {
+    void visit(const NotEqual &) override {
         program.emplace_back(op_binary<operation::NotEqual>);
     }
-    virtual void visit(const Approx &) {
+    void visit(const Approx &) override {
         program.emplace_back(op_binary<operation::Approx>);
     }
-    virtual void visit(const Less &) {
+    void visit(const Less &) override {
         program.emplace_back(op_binary<operation::Less>);
     }
-    virtual void visit(const LessEqual &) {
+    void visit(const LessEqual &) override {
         program.emplace_back(op_binary<operation::LessEqual>);
     }
-    virtual void visit(const Greater &) {
+    void visit(const Greater &) override {
         program.emplace_back(op_binary<operation::Greater>);
     }
-    virtual void visit(const GreaterEqual &) {
+    void visit(const GreaterEqual &) override {
         program.emplace_back(op_binary<operation::GreaterEqual>);
     }
-    virtual void visit(const In &node) {
+    void visit(const In&node) override {
         std::vector<size_t> checks;
         node.lhs().traverse(*this);
         auto array = as<Array>(node.rhs());
@@ -400,91 +400,91 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser {
         }
         program.emplace_back(op_not_member);
     }
-    virtual void visit(const And &) {
+    void visit(const And &) override {
         program.emplace_back(op_binary<operation::And>);
     }
-    virtual void visit(const Or &) {
+    void visit(const Or &) override {
         program.emplace_back(op_binary<operation::Or>);
     }
-    virtual void visit(const Cos &) {
+    void visit(const Cos &) override {
         program.emplace_back(op_unary<operation::Cos>);
     }
-    virtual void visit(const Sin &) {
+    void visit(const Sin &) override {
         program.emplace_back(op_unary<operation::Sin>);
     }
-    virtual void visit(const Tan &) {
+    void visit(const Tan &) override {
         program.emplace_back(op_unary<operation::Tan>);
     }
-    virtual void visit(const Cosh &) {
+    void visit(const Cosh &) override {
         program.emplace_back(op_unary<operation::Cosh>);
     }
-    virtual void visit(const Sinh &) {
+    void visit(const Sinh &) override {
         program.emplace_back(op_unary<operation::Sinh>);
     }
-    virtual void visit(const Tanh &) {
+    void visit(const Tanh &) override {
         program.emplace_back(op_unary<operation::Tanh>);
     }
-    virtual void visit(const Acos &) {
+    void visit(const Acos &) override {
         program.emplace_back(op_unary<operation::Acos>);
     }
-    virtual void visit(const Asin &) {
+    void visit(const Asin &) override {
         program.emplace_back(op_unary<operation::Asin>);
     }
-    virtual void visit(const Atan &) {
+    void visit(const Atan &) override {
         program.emplace_back(op_unary<operation::Atan>);
     }
-    virtual void visit(const Exp &) {
+    void visit(const Exp &) override {
         program.emplace_back(op_unary<operation::Exp>);
     }
-    virtual void visit(const Log10 &) {
+    void visit(const Log10 &) override {
         program.emplace_back(op_unary<operation::Log10>);
     }
-    virtual void visit(const Log &) {
+    void visit(const Log &) override {
         program.emplace_back(op_unary<operation::Log>);
     }
-    virtual void visit(const Sqrt &) {
+    void visit(const Sqrt &) override {
         program.emplace_back(op_unary<operation::Sqrt>);
     }
-    virtual void visit(const Ceil &) {
+    void visit(const Ceil &) override {
         program.emplace_back(op_unary<operation::Ceil>);
     }
-    virtual void visit(const Fabs &) {
+    void visit(const Fabs &) override {
         program.emplace_back(op_unary<operation::Fabs>);
     }
-    virtual void visit(const Floor &) {
+    void visit(const Floor &) override {
         program.emplace_back(op_unary<operation::Floor>);
     }
-    virtual void visit(const Atan2 &) {
+    void visit(const Atan2 &) override {
         program.emplace_back(op_binary<operation::Atan2>);
     }
-    virtual void visit(const Ldexp &) {
+    void visit(const Ldexp &) override {
         program.emplace_back(op_binary<operation::Ldexp>);
     }
-    virtual void visit(const Pow2 &) {
+    void visit(const Pow2 &) override {
         program.emplace_back(op_binary<operation::Pow>);
     }
-    virtual void visit(const Fmod &) {
+    void visit(const Fmod &) override {
         program.emplace_back(op_binary<operation::Fmod>);
     }
-    virtual void visit(const Min &) {
+    void visit(const Min &) override {
         program.emplace_back(op_binary<operation::Min>);
     }
-    virtual void visit(const Max &) {
+    void visit(const Max &) override {
         program.emplace_back(op_binary<operation::Max>);
     }
-    virtual void visit(const IsNan &) {
+    void visit(const IsNan &) override {
         program.emplace_back(op_unary<operation::IsNan>);
     }
-    virtual void visit(const Relu &) {
+    void visit(const Relu &) override {
         program.emplace_back(op_unary<operation::Relu>);
     }
-    virtual void visit(const Sigmoid &) {
+    void visit(const Sigmoid &) override {
         program.emplace_back(op_unary<operation::Sigmoid>);
     }
 
     //-------------------------------------------------------------------------
 
-    virtual bool open(const Node &node) {
+    bool open(const Node&node) override {
         if (check_type<Array, If, Let, In>(node)) {
             node.accept(*this);
             return false;
@@ -492,7 +492,7 @@ struct ProgramBuilder : public NodeVisitor, public NodeTraverser {
         return true;
     }
 
-    virtual void close(const Node &node) {
+    void close(const Node&node) override {
         node.accept(*this);
     }
 };
diff --git a/eval/src/vespa/eval/eval/key_gen.cpp b/eval/src/vespa/eval/eval/key_gen.cpp
index 861bcd9b904..6d78ec50049 100644
--- a/eval/src/vespa/eval/eval/key_gen.cpp
+++ b/eval/src/vespa/eval/eval/key_gen.cpp
@@ -1,10 +1,8 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/fastos/fastos.h>
 #include "key_gen.h"
 #include "node_visitor.h"
 #include "node_traverser.h"
-#include "function.h"
 
 namespace vespalib {
 namespace eval {
@@ -24,66 +22,66 @@ struct KeyGen : public NodeVisitor, public NodeTraverser {
     void add_byte(uint8_t value) { key.append(&value, sizeof(value)); }
 
     // visit
-    virtual void visit(const Number   &node) { add_byte( 1); add_double(node.value()); }
-    virtual void visit(const Symbol   &node) { add_byte( 2); add_int(node.id()); }
-    virtual void visit(const String   &node) { add_byte( 3); add_hash(node.hash()); }
-    virtual void visit(const Array    &node) { add_byte( 4); add_size(node.size()); }
-    virtual void visit(const Neg          &) { add_byte( 5); }
-    virtual void visit(const Not          &) { add_byte( 6); }
-    virtual void visit(const If       &node) { add_byte( 7); add_double(node.p_true()); }
-    virtual void visit(const Let          &) { add_byte( 8); }
-    virtual void visit(const Error        &) { add_byte( 9); }
-    virtual void visit(const TensorSum    &) { add_byte(10); } // dimensions should be part of key
-    virtual void visit(const TensorMap    &) { add_byte(11); } // lambda should be part of key
-    virtual void visit(const TensorJoin   &) { add_byte(12); } // lambda should be part of key
-    virtual void visit(const TensorReduce &) { add_byte(13); } // aggr/dimensions should be part of key
-    virtual void visit(const TensorRename &) { add_byte(14); } // dimensions should be part of key
-    virtual void visit(const TensorLambda &) { add_byte(15); } // type/lambda should be part of key
-    virtual void visit(const TensorConcat &) { add_byte(16); } // dimension should be part of key
-    virtual void visit(const Add          &) { add_byte(20); }
-    virtual void visit(const Sub          &) { add_byte(21); }
-    virtual void visit(const Mul          &) { add_byte(22); }
-    virtual void visit(const Div          &) { add_byte(23); }
-    virtual void visit(const Pow          &) { add_byte(24); }
-    virtual void visit(const Equal        &) { add_byte(25); }
-    virtual void visit(const NotEqual     &) { add_byte(26); }
-    virtual void visit(const Approx       &) { add_byte(27); }
-    virtual void visit(const Less         &) { add_byte(28); }
-    virtual void visit(const LessEqual    &) { add_byte(29); }
-    virtual void visit(const Greater      &) { add_byte(30); }
-    virtual void visit(const GreaterEqual &) { add_byte(31); }
-    virtual void visit(const In           &) { add_byte(32); }
-    virtual void visit(const And          &) { add_byte(33); }
-    virtual void visit(const Or           &) { add_byte(34); }
-    virtual void visit(const Cos          &) { add_byte(35); }
-    virtual void visit(const Sin          &) { add_byte(36); }
-    virtual void visit(const Tan          &) { add_byte(37); }
-    virtual void visit(const Cosh         &) { add_byte(38); }
-    virtual void visit(const Sinh         &) { add_byte(39); }
-    virtual void visit(const Tanh         &) { add_byte(40); }
-    virtual void visit(const Acos         &) { add_byte(41); }
-    virtual void visit(const Asin         &) { add_byte(42); }
-    virtual void visit(const Atan         &) { add_byte(43); }
-    virtual void visit(const Exp          &) { add_byte(44); }
-    virtual void visit(const Log10        &) { add_byte(45); }
-    virtual void visit(const Log          &) { add_byte(46); }
-    virtual void visit(const Sqrt         &) { add_byte(47); }
-    virtual void visit(const Ceil         &) { add_byte(48); }
-    virtual void visit(const Fabs         &) { add_byte(49); }
-    virtual void visit(const Floor        &) { add_byte(50); }
-    virtual void visit(const Atan2        &) { add_byte(51); }
-    virtual void visit(const Ldexp        &) { add_byte(52); }
-    virtual void visit(const Pow2         &) { add_byte(53); }
-    virtual void visit(const Fmod         &) { add_byte(54); }
-    virtual void visit(const Min          &) { add_byte(55); }
-    virtual void visit(const Max          &) { add_byte(56); }
-    virtual void visit(const IsNan        &) { add_byte(57); }
-    virtual void visit(const Relu         &) { add_byte(58); }
-    virtual void visit(const Sigmoid      &) { add_byte(59); }
+    void visit(const Number   &node) override { add_byte( 1); add_double(node.value()); }
+    void visit(const Symbol   &node) override { add_byte( 2); add_int(node.id()); }
+    void visit(const String   &node) override { add_byte( 3); add_hash(node.hash()); }
+    void visit(const Array    &node) override { add_byte( 4); add_size(node.size()); }
+    void visit(const Neg          &) override { add_byte( 5); }
+    void visit(const Not          &) override { add_byte( 6); }
+    void visit(const If       &node) override { add_byte( 7); add_double(node.p_true()); }
+    void visit(const Let          &) override { add_byte( 8); }
+    void visit(const Error        &) override { add_byte( 9); }
+    void visit(const TensorSum    &) override { add_byte(10); } // dimensions should be part of key
+    void visit(const TensorMap    &) override { add_byte(11); } // lambda should be part of key
+    void visit(const TensorJoin   &) override { add_byte(12); } // lambda should be part of key
+    void visit(const TensorReduce &) override { add_byte(13); } // aggr/dimensions should be part of key
+    void visit(const TensorRename &) override { add_byte(14); } // dimensions should be part of key
+    void visit(const TensorLambda &) override { add_byte(15); } // type/lambda should be part of key
+    void visit(const TensorConcat &) override { add_byte(16); } // dimension should be part of key
+    void visit(const Add          &) override { add_byte(20); }
+    void visit(const Sub          &) override { add_byte(21); }
+    void visit(const Mul          &) override { add_byte(22); }
+    void visit(const Div          &) override { add_byte(23); }
+    void visit(const Pow          &) override { add_byte(24); }
+    void visit(const Equal        &) override { add_byte(25); }
+    void visit(const NotEqual     &) override { add_byte(26); }
+    void visit(const Approx       &) override { add_byte(27); }
+    void visit(const Less         &) override { add_byte(28); }
+    void visit(const LessEqual    &) override { add_byte(29); }
+    void visit(const Greater      &) override { add_byte(30); }
+    void visit(const GreaterEqual &) override { add_byte(31); }
+    void visit(const In           &) override { add_byte(32); }
+    void visit(const And          &) override { add_byte(33); }
+    void visit(const Or           &) override { add_byte(34); }
+    void visit(const Cos          &) override { add_byte(35); }
+    void visit(const Sin          &) override { add_byte(36); }
+    void visit(const Tan          &) override { add_byte(37); }
+    void visit(const Cosh         &) override { add_byte(38); }
+    void visit(const Sinh         &) override { add_byte(39); }
+    void visit(const Tanh         &) override { add_byte(40); }
+    void visit(const Acos         &) override { add_byte(41); }
+    void visit(const Asin         &) override { add_byte(42); }
+    void visit(const Atan         &) override { add_byte(43); }
+    void visit(const Exp          &) override { add_byte(44); }
+    void visit(const Log10        &) override { add_byte(45); }
+    void visit(const Log          &) override { add_byte(46); }
+    void visit(const Sqrt         &) override { add_byte(47); }
+    void visit(const Ceil         &) override { add_byte(48); }
+    void visit(const Fabs         &) override { add_byte(49); }
+    void visit(const Floor        &) override { add_byte(50); }
+    void visit(const Atan2        &) override { add_byte(51); }
+    void visit(const Ldexp        &) override { add_byte(52); }
+    void visit(const Pow2         &) override { add_byte(53); }
+    void visit(const Fmod         &) override { add_byte(54); }
+    void visit(const Min          &) override { add_byte(55); }
+    void visit(const Max          &) override { add_byte(56); }
+    void visit(const IsNan        &) override { add_byte(57); }
+    void visit(const Relu         &) override { add_byte(58); }
+    void visit(const Sigmoid      &) override { add_byte(59); }
 
     // traverse
-    virtual bool open(const Node &node) { node.accept(*this); return true; }
-    virtual void close(const Node &) {}
+    bool open(const Node &node) override { node.accept(*this); return true; }
+    void close(const Node &) override {}
 };
 
 } // namespace vespalib::eval::<unnamed>
diff --git a/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp b/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp
index 5b607280403..ac4c4e597ca 100644
--- a/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp
+++ b/eval/src/vespa/eval/eval/llvm/llvm_wrapper.cpp
@@ -242,7 +242,7 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser {
 
     //-------------------------------------------------------------------------
 
-    bool open(const Node &node) {
+    bool open(const Node &node) override {
         if (node.is_const()) {
             push_double(node.get_const_value());
             return false;
@@ -261,7 +261,7 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser {
         return true;
     }
 
-    void close(const Node &node) {
+    void close(const Node &node) override {
         node.accept(*this);
         if (inside_forest && (forest_end == &node)) {
             inside_forest = false;
@@ -348,10 +348,10 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser {
 
     // basic nodes
 
-    virtual void visit(const Number &item) {
+    void visit(const Number &item) override {
         push_double(item.value());
     }
-    virtual void visit(const Symbol &item) {
+    void visit(const Symbol &item) override {
         if (item.id() >= 0) {
             push(get_param(item.id()));
         } else {
@@ -360,22 +360,22 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser {
             push(let_values[let_offset]);
         }
     }
-    virtual void visit(const String &item) {
+    void visit(const String &item) override {
         push_double(item.hash());
     }
-    virtual void visit(const Array &item) {
+    void visit(const Array &item) override {
         // NB: visit not open
         push_double(item.size());
     }
-    virtual void visit(const Neg &) {
+    void visit(const Neg &) override {
         llvm::Value *child = pop_double();
         push(builder.CreateFNeg(child, "neg_res"));
     }
-    virtual void visit(const Not &) {
+    void visit(const Not &) override {
         llvm::Value *child = pop_bool();
         push(builder.CreateNot(child, "not_res"));
     }
-    virtual void visit(const If &item) {
+    void visit(const If &item) override {
         // NB: visit not open
         llvm::BasicBlock *true_block = llvm::BasicBlock::Create(context, "true_block", function);
         llvm::BasicBlock *false_block = llvm::BasicBlock::Create(context, "false_block", function);
@@ -402,100 +402,100 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser {
         phi->addIncoming(false_res, false_end);
         push(phi);
     }
-    virtual void visit(const Let &item) {
+    void visit(const Let &item) override {
         // NB: visit not open
         item.value().traverse(*this); // NB: recursion
         let_values.push_back(pop_double());
         item.expr().traverse(*this); // NB: recursion
         let_values.pop_back();
     }
-    virtual void visit(const Error &) {
+    void visit(const Error &) override {
         make_error(0);
     }
 
     // tensor nodes (not supported in compiled expressions)
 
-    virtual void visit(const TensorSum &node) {
+    void visit(const TensorSum &node) override {
         make_error(node.num_children());
     }
-    virtual void visit(const TensorMap &node) {
+    void visit(const TensorMap &node) override {
         make_error(node.num_children());
     }
-    virtual void visit(const TensorJoin &node) {
+    void visit(const TensorJoin &node) override {
         make_error(node.num_children());
     }
-    virtual void visit(const TensorReduce &node) {
+    void visit(const TensorReduce &node) override {
         make_error(node.num_children());
     }
-    virtual void visit(const TensorRename &node) {
+    void visit(const TensorRename &node) override {
         make_error(node.num_children());
     }
-    virtual void visit(const TensorLambda &node) {
+    void visit(const TensorLambda &node) override {
         make_error(node.num_children());
     }
-    virtual void visit(const TensorConcat &node) {
+    void visit(const TensorConcat &node) override {
         make_error(node.num_children());
     }
 
     // operator nodes
 
-    virtual void visit(const Add &) {
+    void visit(const Add &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFAdd(a, b, "add_res"));
     }
-    virtual void visit(const Sub &) {
+    void visit(const Sub &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFSub(a, b, "sub_res"));
     }
-    virtual void visit(const Mul &) {
+    void visit(const Mul &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFMul(a, b, "mul_res"));
     }
-    virtual void visit(const Div &) {
+    void visit(const Div &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFDiv(a, b, "div_res"));
     }
-    virtual void visit(const Pow &) {
+    void visit(const Pow &) override {
         make_call_2(llvm::Intrinsic::pow);
     }
-    virtual void visit(const Equal &) {
+    void visit(const Equal &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFCmpOEQ(a, b, "cmp_eq_res"));
     }
-    virtual void visit(const NotEqual &) {
+    void visit(const NotEqual &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFCmpUNE(a, b, "cmp_ne_res"));
     }
-    virtual void visit(const Approx &) {
+    void visit(const Approx &) override {
         make_call_2("vespalib_eval_approx");
     }
-    virtual void visit(const Less &) {
+    void visit(const Less &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFCmpOLT(a, b, "cmp_lt_res"));
     }
-    virtual void visit(const LessEqual &) {
+    void visit(const LessEqual &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFCmpOLE(a, b, "cmp_le_res"));
     }
-    virtual void visit(const Greater &) {
+    void visit(const Greater &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFCmpOGT(a, b, "cmp_gt_res"));
     }
-    virtual void visit(const GreaterEqual &) {
+    void visit(const GreaterEqual &) override {
         llvm::Value *b = pop_double();
         llvm::Value *a = pop_double();
         push(builder.CreateFCmpOGE(a, b, "cmp_ge_res"));
     }
-    virtual void visit(const In &item) {
+    void visit(const In &item) override {
         // NB: visit not open
         item.lhs().traverse(*this); // NB: recursion
         llvm::Value *lhs = pop_double();
@@ -527,12 +527,12 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser {
             push(builder.CreateFCmpOEQ(lhs, rhs, "rhs_eq"));
         }
     }
-    virtual void visit(const And &) {
+    void visit(const And &) override {
         llvm::Value *b = pop_bool();
         llvm::Value *a = pop_bool();
         push(builder.CreateAnd(a, b, "and_res"));
     }
-    virtual void visit(const Or &) {
+    void visit(const Or &) override {
         llvm::Value *b = pop_bool();
         llvm::Value *a = pop_bool();
         push(builder.CreateOr(a, b, "or_res"));
@@ -540,79 +540,79 @@ struct FunctionBuilder : public NodeVisitor, public NodeTraverser {
 
     // call nodes
 
-    virtual void visit(const Cos &) {
+    void visit(const Cos &) override {
         make_call_1(llvm::Intrinsic::cos);
     }
-    virtual void visit(const Sin &) {
+    void visit(const Sin &) override {
         make_call_1(llvm::Intrinsic::sin);
     }
-    virtual void visit(const Tan &) {
+    void visit(const Tan &) override {
         make_call_1("tan");
     }
-    virtual void visit(const Cosh &) {
+    void visit(const Cosh &) override {
         make_call_1("cosh");
     }
-    virtual void visit(const Sinh &) {
+    void visit(const Sinh &) override {
         make_call_1("sinh");
     }
-    virtual void visit(const Tanh &) {
+    void visit(const Tanh &) override {
         make_call_1("tanh");
     }
-    virtual void visit(const Acos &) {
+    void visit(const Acos &) override {
         make_call_1("acos");
     }
-    virtual void visit(const Asin &) {
+    void visit(const Asin &) override {
         make_call_1("asin");
     }
-    virtual void visit(const Atan &) {
+    void visit(const Atan &) override {
         make_call_1("atan");
     }
-    virtual void visit(const Exp &) {
+    void visit(const Exp &) override {
         make_call_1(llvm::Intrinsic::exp);
     }
-    virtual void visit(const Log10 &) {
+    void visit(const Log10 &) override {
         make_call_1(llvm::Intrinsic::log10);
     }
-    virtual void visit(const Log &) {
+    void visit(const Log &) override {
         make_call_1(llvm::Intrinsic::log);
     }
-    virtual void visit(const Sqrt &) {
+    void visit(const Sqrt &) override {
         make_call_1(llvm::Intrinsic::sqrt);
     }
-    virtual void visit(const Ceil &) {
+    void visit(const Ceil &) override {
         make_call_1(llvm::Intrinsic::ceil);
     }
-    virtual void visit(const Fabs &) {
+    void visit(const Fabs &) override {
         make_call_1(llvm::Intrinsic::fabs);
     }
-    virtual void visit(const Floor &) {
+    void visit(const Floor &) override {
         make_call_1(llvm::Intrinsic::floor);
     }
-    virtual void visit(const Atan2 &) {
+    void visit(const Atan2 &) override {
         make_call_2("atan2");
     }
-    virtual void visit(const Ldexp &) {
+    void visit(const Ldexp &) override {
         make_call_2("vespalib_eval_ldexp");
     }
-    virtual void visit(const Pow2 &) {
+    void visit(const Pow2 &) override {
         make_call_2(llvm::Intrinsic::pow);
     }
-    virtual void visit(const Fmod &) {
+    void visit(const Fmod &) override {
         make_call_2("fmod");
     }
-    virtual void visit(const Min &) {
+    void visit(const Min &) override {
         make_call_2("vespalib_eval_min");
     }
-    virtual void visit(const Max &) {
+    void visit(const Max &) override {
         make_call_2("vespalib_eval_max");
     }
-    virtual void visit(const IsNan &) {
+    void visit(const IsNan &) override {
         make_call_1("vespalib_eval_isnan");
     }
-    virtual void visit(const Relu &) {
+    void visit(const Relu &) override {
         make_call_1("vespalib_eval_relu");
     }
-    virtual void visit(const Sigmoid &) {
+    void visit(const Sigmoid &) override {
         make_call_1("vespalib_eval_sigmoid");
     }
 };
diff --git a/eval/src/vespa/eval/eval/node_types.cpp b/eval/src/vespa/eval/eval/node_types.cpp
index c02060a1060..645baa2e5a6 100644
--- a/eval/src/vespa/eval/eval/node_types.cpp
+++ b/eval/src/vespa/eval/eval/node_types.cpp
@@ -1,11 +1,8 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/fastos/fastos.h>
 #include "check_type.h"
-#include "function.h"
 #include "node_traverser.h"
 #include "node_types.h"
-#include "node_visitor.h"
 
 namespace vespalib {
 namespace eval {
@@ -119,10 +116,10 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser {
 
     //-------------------------------------------------------------------------
 
-    virtual void visit(const Number &node) {
+    void visit(const Number &node) override {
         bind_type(ValueType::double_type(), node);
     }
-    virtual void visit(const Symbol &node) {
+    void visit(const Symbol &node) override {
         if (node.id() >= 0) { // param value
             bind_type(state.param_type(node.id()), node);
         } else { // let binding
@@ -130,15 +127,15 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser {
             bind_type(state.let_type(let_offset), node);
         }
     }
-    virtual void visit(const String &node) {
+    void visit(const String &node) override {
         bind_type(ValueType::double_type(), node);
     }
-    virtual void visit(const Array &node) {
+    void visit(const Array &node) override {
         bind_type(ValueType::double_type(), node);
     }
-    virtual void visit(const Neg &node) { resolve_op1(node); }
-    virtual void visit(const Not &node) { resolve_op1(node); }
-    virtual void visit(const If &node) {
+    void visit(const Neg &node) override { resolve_op1(node); }
+    void visit(const Not &node) override { resolve_op1(node); }
+    void visit(const If &node) override {
         ValueType true_type = state.peek(1);
         ValueType false_type = state.peek(0);
         if (true_type == false_type) {
@@ -149,13 +146,13 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser {
             bind_type(ValueType::any_type(), node);
         }
     }
-    virtual void visit(const Let &node) {
+    void visit(const Let &node) override {
         bind_type(state.peek(0), node);
     }
-    virtual void visit(const Error &node) {
+    void visit(const Error &node) override {
         bind_type(ValueType::error_type(), node);
     }
-    virtual void visit(const TensorSum &node) {
+    void visit(const TensorSum &node) override {
         const ValueType &child = state.peek(0);        
         if (node.dimension().empty()) {
             bind_type(child.reduce({}), node);
@@ -163,69 +160,69 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser {
             bind_type(child.reduce({node.dimension()}), node);
         }
     }
-    virtual void visit(const TensorMap &node) { resolve_op1(node); }
-    virtual void visit(const TensorJoin &node) { resolve_op2(node); }
-    virtual void visit(const TensorReduce &node) {
+    void visit(const TensorMap &node) override { resolve_op1(node); }
+    void visit(const TensorJoin &node) override { resolve_op2(node); }
+    void visit(const TensorReduce &node) override {
         const ValueType &child = state.peek(0);
         bind_type(child.reduce(node.dimensions()), node);
     }
-    virtual void visit(const TensorRename &node) {
+    void visit(const TensorRename &node) override {
         const ValueType &child = state.peek(0);
         bind_type(child.rename(node.from(), node.to()), node);
     }
-    virtual void visit(const TensorLambda &node) {
+    void visit(const TensorLambda &node) override {
         bind_type(node.type(), node);
     }
-    virtual void visit(const TensorConcat &node) {
+    void visit(const TensorConcat &node) override {
         bind_type(ValueType::concat(state.peek(1), state.peek(0), node.dimension()), node);
     }
 
-    virtual void visit(const Add &node) { resolve_op2(node); }
-    virtual void visit(const Sub &node) { resolve_op2(node); }
-    virtual void visit(const Mul &node) { resolve_op2(node); }
-    virtual void visit(const Div &node) { resolve_op2(node); }
-    virtual void visit(const Pow &node) { resolve_op2(node); }
-    virtual void visit(const Equal &node) { resolve_op2(node); }
-    virtual void visit(const NotEqual &node) { resolve_op2(node); }
-    virtual void visit(const Approx &node) { resolve_op2(node); }
-    virtual void visit(const Less &node) { resolve_op2(node); }
-    virtual void visit(const LessEqual &node) { resolve_op2(node); }
-    virtual void visit(const Greater &node) { resolve_op2(node); }
-    virtual void visit(const GreaterEqual &node) { resolve_op2(node); }
-    virtual void visit(const In &node) {
+    void visit(const Add &node) override { resolve_op2(node); }
+    void visit(const Sub &node) override { resolve_op2(node); }
+    void visit(const Mul &node) override { resolve_op2(node); }
+    void visit(const Div &node) override { resolve_op2(node); }
+    void visit(const Pow &node) override { resolve_op2(node); }
+    void visit(const Equal &node) override { resolve_op2(node); }
+    void visit(const NotEqual &node) override { resolve_op2(node); }
+    void visit(const Approx &node) override { resolve_op2(node); }
+    void visit(const Less &node) override { resolve_op2(node); }
+    void visit(const LessEqual &node) override { resolve_op2(node); }
+    void visit(const Greater &node) override { resolve_op2(node); }
+    void visit(const GreaterEqual &node) override { resolve_op2(node); }
+    void visit(const In &node) override {
         bind_type(ValueType::double_type(), node);
     }
-    virtual void visit(const And &node) { resolve_op2(node); }
-    virtual void visit(const Or &node) { resolve_op2(node); }
-    virtual void visit(const Cos &node) { resolve_op1(node); }
-    virtual void visit(const Sin &node) { resolve_op1(node); }
-    virtual void visit(const Tan &node) { resolve_op1(node); }
-    virtual void visit(const Cosh &node) { resolve_op1(node); }
-    virtual void visit(const Sinh &node) { resolve_op1(node); }
-    virtual void visit(const Tanh &node) { resolve_op1(node); }
-    virtual void visit(const Acos &node) { resolve_op1(node); }
-    virtual void visit(const Asin &node) { resolve_op1(node); }
-    virtual void visit(const Atan &node) { resolve_op1(node); }
-    virtual void visit(const Exp &node) { resolve_op1(node); }
-    virtual void visit(const Log10 &node) { resolve_op1(node); }
-    virtual void visit(const Log &node) { resolve_op1(node); }
-    virtual void visit(const Sqrt &node) { resolve_op1(node); }
-    virtual void visit(const Ceil &node) { resolve_op1(node); }
-    virtual void visit(const Fabs &node) { resolve_op1(node); }
-    virtual void visit(const Floor &node) { resolve_op1(node); }
-    virtual void visit(const Atan2 &node) { resolve_op2(node); }
-    virtual void visit(const Ldexp &node) { resolve_op2(node); }
-    virtual void visit(const Pow2 &node) { resolve_op2(node); }
-    virtual void visit(const Fmod &node) { resolve_op2(node); }
-    virtual void visit(const Min &node) { resolve_op2(node); }
-    virtual void visit(const Max &node) { resolve_op2(node); }
-    virtual void visit(const IsNan &node) { resolve_op1(node); }
-    virtual void visit(const Relu &node) { resolve_op1(node); }
-    virtual void visit(const Sigmoid &node) { resolve_op1(node); }
+    void visit(const And &node) override { resolve_op2(node); }
+    void visit(const Or &node) override { resolve_op2(node); }
+    void visit(const Cos &node) override { resolve_op1(node); }
+    void visit(const Sin &node) override { resolve_op1(node); }
+    void visit(const Tan &node) override { resolve_op1(node); }
+    void visit(const Cosh &node) override { resolve_op1(node); }
+    void visit(const Sinh &node) override { resolve_op1(node); }
+    void visit(const Tanh &node) override { resolve_op1(node); }
+    void visit(const Acos &node) override { resolve_op1(node); }
+    void visit(const Asin &node) override { resolve_op1(node); }
+    void visit(const Atan &node) override { resolve_op1(node); }
+    void visit(const Exp &node) override { resolve_op1(node); }
+    void visit(const Log10 &node) override { resolve_op1(node); }
+    void visit(const Log &node) override { resolve_op1(node); }
+    void visit(const Sqrt &node) override { resolve_op1(node); }
+    void visit(const Ceil &node) override { resolve_op1(node); }
+    void visit(const Fabs &node) override { resolve_op1(node); }
+    void visit(const Floor &node) override { resolve_op1(node); }
+    void visit(const Atan2 &node) override { resolve_op2(node); }
+    void visit(const Ldexp &node) override { resolve_op2(node); }
+    void visit(const Pow2 &node) override { resolve_op2(node); }
+    void visit(const Fmod &node) override { resolve_op2(node); }
+    void visit(const Min &node) override { resolve_op2(node); }
+    void visit(const Max &node) override { resolve_op2(node); }
+    void visit(const IsNan &node) override { resolve_op1(node); }
+    void visit(const Relu &node) override { resolve_op1(node); }
+    void visit(const Sigmoid &node) override { resolve_op1(node); }
 
     //-------------------------------------------------------------------------
 
-    virtual bool open(const Node &node) {
+    bool open(const Node &node) override {
         auto let = as<Let>(node);
         if (let) {
             add_action(let->expr(), action_unbind_let);
@@ -234,7 +231,7 @@ struct TypeResolver : public NodeVisitor, public NodeTraverser {
         return true;
     }
 
-    virtual void close(const Node &node) {
+    void close(const Node &node) override {
         if (!check_error(node)) {
             node.accept(*this);
         }
diff --git a/eval/src/vespa/eval/eval/node_visitor.h b/eval/src/vespa/eval/eval/node_visitor.h
index 3196a00820e..128533c0410 100644
--- a/eval/src/vespa/eval/eval/node_visitor.h
+++ b/eval/src/vespa/eval/eval/node_visitor.h
@@ -90,62 +90,62 @@ struct NodeVisitor {
  * of all types not specifically handled.
  **/
 struct EmptyNodeVisitor : NodeVisitor {
-    virtual void visit(const nodes::Number       &) {}
-    virtual void visit(const nodes::Symbol       &) {}
-    virtual void visit(const nodes::String       &) {}
-    virtual void visit(const nodes::Array        &) {}
-    virtual void visit(const nodes::Neg          &) {}
-    virtual void visit(const nodes::Not          &) {}
-    virtual void visit(const nodes::If           &) {}
-    virtual void visit(const nodes::Let          &) {}
-    virtual void visit(const nodes::Error        &) {}
-    virtual void visit(const nodes::TensorSum    &) {}
-    virtual void visit(const nodes::TensorMap    &) {}
-    virtual void visit(const nodes::TensorJoin   &) {}
-    virtual void visit(const nodes::TensorReduce &) {}
-    virtual void visit(const nodes::TensorRename &) {}
-    virtual void visit(const nodes::TensorLambda &) {}
-    virtual void visit(const nodes::TensorConcat &) {}
-    virtual void visit(const nodes::Add          &) {}
-    virtual void visit(const nodes::Sub          &) {}
-    virtual void visit(const nodes::Mul          &) {}
-    virtual void visit(const nodes::Div          &) {}
-    virtual void visit(const nodes::Pow          &) {}
-    virtual void visit(const nodes::Equal        &) {}
-    virtual void visit(const nodes::NotEqual     &) {}
-    virtual void visit(const nodes::Approx       &) {}
-    virtual void visit(const nodes::Less         &) {}
-    virtual void visit(const nodes::LessEqual    &) {}
-    virtual void visit(const nodes::Greater      &) {}
-    virtual void visit(const nodes::GreaterEqual &) {}
-    virtual void visit(const nodes::In           &) {}
-    virtual void visit(const nodes::And          &) {}
-    virtual void visit(const nodes::Or           &) {}
-    virtual void visit(const nodes::Cos          &) {}
-    virtual void visit(const nodes::Sin          &) {}
-    virtual void visit(const nodes::Tan          &) {}
-    virtual void visit(const nodes::Cosh         &) {}
-    virtual void visit(const nodes::Sinh         &) {}
-    virtual void visit(const nodes::Tanh         &) {}
-    virtual void visit(const nodes::Acos         &) {}
-    virtual void visit(const nodes::Asin         &) {}
-    virtual void visit(const nodes::Atan         &) {}
-    virtual void visit(const nodes::Exp          &) {}
-    virtual void visit(const nodes::Log10        &) {}
-    virtual void visit(const nodes::Log          &) {}
-    virtual void visit(const nodes::Sqrt         &) {}
-    virtual void visit(const nodes::Ceil         &) {}
-    virtual void visit(const nodes::Fabs         &) {}
-    virtual void visit(const nodes::Floor        &) {}
-    virtual void visit(const nodes::Atan2        &) {}
-    virtual void visit(const nodes::Ldexp        &) {}
-    virtual void visit(const nodes::Pow2         &) {}
-    virtual void visit(const nodes::Fmod         &) {}
-    virtual void visit(const nodes::Min          &) {}
-    virtual void visit(const nodes::Max          &) {}
-    virtual void visit(const nodes::IsNan        &) {}
-    virtual void visit(const nodes::Relu         &) {}
-    virtual void visit(const nodes::Sigmoid      &) {}
+    virtual void visit(const nodes::Number       &) override {}
+    virtual void visit(const nodes::Symbol       &) override {}
+    virtual void visit(const nodes::String       &) override {}
+    virtual void visit(const nodes::Array        &) override {}
+    virtual void visit(const nodes::Neg          &) override {}
+    virtual void visit(const nodes::Not          &) override {}
+    virtual void visit(const nodes::If           &) override {}
+    virtual void visit(const nodes::Let          &) override {}
+    void visit(const nodes::Error        &) override {}
+    void visit(const nodes::TensorSum    &) override {}
+    void visit(const nodes::TensorMap    &) override {}
+    void visit(const nodes::TensorJoin   &) override {}
+    void visit(const nodes::TensorReduce &) override {}
+    void visit(const nodes::TensorRename &) override {}
+    void visit(const nodes::TensorLambda &) override {}
+    void visit(const nodes::TensorConcat &) override {}
+    void visit(const nodes::Add          &) override {}
+    void visit(const nodes::Sub          &) override {}
+    void visit(const nodes::Mul          &) override {}
+    void visit(const nodes::Div          &) override {}
+    void visit(const nodes::Pow          &) override {}
+    void visit(const nodes::Equal        &) override {}
+    void visit(const nodes::NotEqual     &) override {}
+    void visit(const nodes::Approx       &) override {}
+    void visit(const nodes::Less         &) override {}
+    void visit(const nodes::LessEqual    &) override {}
+    void visit(const nodes::Greater      &) override {}
+    void visit(const nodes::GreaterEqual &) override {}
+    void visit(const nodes::In           &) override {}
+    void visit(const nodes::And          &) override {}
+    void visit(const nodes::Or           &) override {}
+    void visit(const nodes::Cos          &) override {}
+    void visit(const nodes::Sin          &) override {}
+    void visit(const nodes::Tan          &) override {}
+    void visit(const nodes::Cosh         &) override {}
+    void visit(const nodes::Sinh         &) override {}
+    void visit(const nodes::Tanh         &) override {}
+    void visit(const nodes::Acos         &) override {}
+    void visit(const nodes::Asin         &) override {}
+    void visit(const nodes::Atan         &) override {}
+    void visit(const nodes::Exp          &) override {}
+    void visit(const nodes::Log10        &) override {}
+    void visit(const nodes::Log          &) override {}
+    void visit(const nodes::Sqrt         &) override {}
+    void visit(const nodes::Ceil         &) override {}
+    void visit(const nodes::Fabs         &) override {}
+    void visit(const nodes::Floor        &) override {}
+    void visit(const nodes::Atan2        &) override {}
+    void visit(const nodes::Ldexp        &) override {}
+    void visit(const nodes::Pow2         &) override {}
+    void visit(const nodes::Fmod         &) override {}
+    void visit(const nodes::Min          &) override {}
+    void visit(const nodes::Max          &) override {}
+    void visit(const nodes::IsNan        &) override {}
+    void visit(const nodes::Relu         &) override {}
+    void visit(const nodes::Sigmoid      &) override {}
 };
 
 } // namespace vespalib::eval
diff --git a/eval/src/vespa/eval/eval/operator_nodes.h b/eval/src/vespa/eval/eval/operator_nodes.h
index a0726137015..93b30d7695b 100644
--- a/eval/src/vespa/eval/eval/operator_nodes.h
+++ b/eval/src/vespa/eval/eval/operator_nodes.h
@@ -42,13 +42,13 @@ public:
     Order order() const { return _order; }
     const Node &lhs() const { return *_lhs; }
     const Node &rhs() const { return *_rhs; }
-    virtual bool is_const() const override { return _is_const; }
-    virtual size_t num_children() const override { return (_lhs && _rhs) ? 2 : 0; }
-    virtual const Node &get_child(size_t idx) const override {
+    bool is_const() const override { return _is_const; }
+    size_t num_children() const override { return (_lhs && _rhs) ? 2 : 0; }
+    const Node &get_child(size_t idx) const override {
         assert(idx < 2);
         return (idx == 0) ? lhs() : rhs();
     }
-    virtual void detach_children(NodeHandler &handler) override {
+    void detach_children(NodeHandler &handler) override {
         handler.handle(std::move(_lhs));
         handler.handle(std::move(_rhs));
     }
@@ -70,7 +70,7 @@ public:
         _is_const = (_lhs->is_const() && _rhs->is_const());
     }
 
-    virtual vespalib::string dump(DumpContext &ctx) const {
+    vespalib::string dump(DumpContext &ctx) const override {
         vespalib::string str;
         str += "(";
         str += _lhs->dump(ctx);
@@ -129,7 +129,7 @@ struct OperatorHelper : Operator {
     using Helper = OperatorHelper<T>;
     OperatorHelper(const vespalib::string &op_str_in, int priority_in, Operator::Order order_in)
         : Operator(op_str_in, priority_in, order_in) {}
-    virtual void accept(NodeVisitor &visitor) const override;
+    void accept(NodeVisitor &visitor) const override;
     static Operator_UP create() { return Operator_UP(new T()); }
 };
 
@@ -140,13 +140,13 @@ private:
     bool _is_forest;
 public:
     Add() : Helper("+", 101, LEFT), _is_forest(false) {}
-    virtual bool is_forest() const override { return _is_forest; }
+    bool is_forest() const override { return _is_forest; }
     bool check_forest() const {
         bool lhs_ok = (lhs().is_tree() || lhs().is_forest());
         bool rhs_ok = (rhs().is_tree() || rhs().is_forest());
         return (lhs_ok && rhs_ok);
     }
-    virtual void bind(Node_UP lhs_in, Node_UP rhs_in) override {
+    void bind(Node_UP lhs_in, Node_UP rhs_in) override {
         OperatorHelper<Add>::bind(std::move(lhs_in), std::move(rhs_in));
         _is_forest = check_forest();
     }
diff --git a/eval/src/vespa/eval/eval/test/tensor_conformance.cpp b/eval/src/vespa/eval/eval/test/tensor_conformance.cpp
index 93b0cde7363..40366f39db9 100644
--- a/eval/src/vespa/eval/eval/test/tensor_conformance.cpp
+++ b/eval/src/vespa/eval/eval/test/tensor_conformance.cpp
@@ -515,7 +515,7 @@ struct Input : TensorFunction::Input {
         ASSERT_GREATER(tensors.size(), offset);
         return tensors[offset];
     }
-    const UnaryOperation &get_map_operation(size_t id) const {
+    const UnaryOperation &get_map_operation(size_t id) const override {
         ASSERT_TRUE(map_op != nullptr);
         ASSERT_EQUAL(id, map_operation_id);
         return *map_op;
diff --git a/eval/src/vespa/eval/eval/value.h b/eval/src/vespa/eval/eval/value.h
index e8b682e84b5..3b2f7eca62c 100644
--- a/eval/src/vespa/eval/eval/value.h
+++ b/eval/src/vespa/eval/eval/value.h
@@ -39,9 +39,9 @@ struct Value {
 };
 
 struct ErrorValue : public Value {
-    virtual bool is_error() const override { return true; }
-    virtual double as_double() const { return error_value; }
-    virtual bool equal(const Value &) const override { return false; }
+    bool is_error() const override { return true; }
+    double as_double() const override { return error_value; }
+    bool equal(const Value &) const override { return false; }
     ValueType type() const override { return ValueType::error_type(); }
 };