Merge pull request #27236 from vespa-engine/balder/minor-code-health

Modernize code while reading it.

16 files changed, 220 insertions, 182 deletions

diff --git a/searchlib/src/vespa/searchlib/aggregation/groupinglevel.cpp b/searchlib/src/vespa/searchlib/aggregation/groupinglevel.cpp
index 73938437f3e..770834ba32f 100644
--- a/searchlib/src/vespa/searchlib/aggregation/groupinglevel.cpp
+++ b/searchlib/src/vespa/searchlib/aggregation/groupinglevel.cpp
@@ -19,7 +19,7 @@ GroupingLevel::GroupingLevel() :
     _frozen(false),
     _classify(),
     _collect(),
-    _grouper(NULL)
+    _grouper(nullptr)
 { }
 
 GroupingLevel::~GroupingLevel() = default;
@@ -63,11 +63,6 @@ GroupingLevel::Grouper::Grouper(const Grouping * grouping, uint32_t level) :
 {
 }
 
-bool GroupingLevel::Grouper::isFrosen(size_t level) const
-{
-    return level < _grouping->getFirstLevel();
-}
-
 bool GroupingLevel::Grouper::hasNext(size_t level) const
 {
     return level < _grouping->getLevels().size();
@@ -77,7 +72,7 @@ template<typename Doc>
 void GroupingLevel::SingleValueGrouper::groupDoc(Group & g, const ResultNode & result, const Doc & doc, HitRank rank) const
 {
     Group * next = g.groupSingle(result, rank, _grouping->getLevels()[_level]);
-    if ((next != NULL) && doNext()) { // do next level ?
+    if ((next != nullptr) && doNext()) { // do next level ?
         next->aggregate(*_grouping, _level + 1, doc, rank);
     }
 }
diff --git a/searchlib/src/vespa/searchlib/aggregation/groupinglevel.h b/searchlib/src/vespa/searchlib/aggregation/groupinglevel.h
index 3ef9610f560..f1e85b50ea4 100644
--- a/searchlib/src/vespa/searchlib/aggregation/groupinglevel.h
+++ b/searchlib/src/vespa/searchlib/aggregation/groupinglevel.h
@@ -28,10 +28,8 @@ private:
         virtual Grouper * clone() const = 0;
     protected:
         Grouper(const Grouping * grouping, uint32_t level);
-        bool isFrozen() const { return _frozen; }
         bool  hasNext() const { return _hasNext; }
         bool   doNext() const { return _doNext; }
-        bool isFrosen(size_t level) const;
         bool  hasNext(size_t level) const;
         const Grouping * _grouping;
         uint32_t   _level;
diff --git a/searchlib/src/vespa/searchlib/aggregation/perdocexpression.h b/searchlib/src/vespa/searchlib/aggregation/perdocexpression.h
index 7f98263197d..6128aa234ee 100644
--- a/searchlib/src/vespa/searchlib/aggregation/perdocexpression.h
+++ b/searchlib/src/vespa/searchlib/aggregation/perdocexpression.h
@@ -29,7 +29,6 @@
 #include <vespa/searchlib/expression/catfunctionnode.h>
 #include <vespa/searchlib/expression/xorbitfunctionnode.h>
 #include <vespa/searchlib/expression/md5bitfunctionnode.h>
-#include <vespa/searchlib/expression/resultvector.h>
 #include <vespa/searchlib/expression/fixedwidthbucketfunctionnode.h>
 #include <vespa/searchlib/expression/rangebucketpredef.h>
 #include <vespa/searchlib/expression/timestamp.h>
diff --git a/searchlib/src/vespa/searchlib/expression/attribute_map_lookup_node.cpp b/searchlib/src/vespa/searchlib/expression/attribute_map_lookup_node.cpp
index 52ee467fac8..c1f61afdfd5 100644
--- a/searchlib/src/vespa/searchlib/expression/attribute_map_lookup_node.cpp
+++ b/searchlib/src/vespa/searchlib/expression/attribute_map_lookup_node.cpp
@@ -1,6 +1,7 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "attribute_map_lookup_node.h"
+#include "resultvector.h"
 #include <vespa/searchlib/attribute/stringbase.h>
 #include <vespa/searchcommon/attribute/attributecontent.h>
 #include <vespa/searchcommon/attribute/iattributecontext.h>
diff --git a/searchlib/src/vespa/searchlib/expression/attributenode.cpp b/searchlib/src/vespa/searchlib/expression/attributenode.cpp
index 413cb50ca49..7e46de934f0 100644
--- a/searchlib/src/vespa/searchlib/expression/attributenode.cpp
+++ b/searchlib/src/vespa/searchlib/expression/attributenode.cpp
@@ -1,6 +1,7 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "attributenode.h"
+#include "resultvector.h"
 #include "enumattributeresult.h"
 #include <vespa/searchcommon/attribute/iattributecontext.h>
 
@@ -17,7 +18,7 @@ template <typename V>
 class AttributeNode::IntegerHandler : public AttributeNode::Handler
 {
 public:
-    IntegerHandler(ResultNode & result) :
+    IntegerHandler(ResultNode & result) noexcept :
         Handler(),
         _vector(((V &)result).getVector()),
         _wVector()
@@ -31,7 +32,7 @@ private:
 class AttributeNode::FloatHandler : public AttributeNode::Handler
 {
 public:
-    FloatHandler(ResultNode & result) :
+    FloatHandler(ResultNode & result) noexcept :
         Handler(),
         _vector(((FloatResultNodeVector &)result).getVector()),
         _wVector()
@@ -45,7 +46,7 @@ private:
 class AttributeNode::StringHandler : public AttributeNode::Handler
 {
 public:
-    StringHandler(ResultNode & result) :
+    StringHandler(ResultNode & result) noexcept :
         Handler(),
         _vector(((StringResultNodeVector &)result).getVector()),
         _wVector()
@@ -59,7 +60,7 @@ private:
 class AttributeNode::EnumHandler : public AttributeNode::Handler
 {
 public:
-    EnumHandler(ResultNode & result) :
+    EnumHandler(ResultNode & result) noexcept :
         Handler(),
         _vector(((EnumResultNodeVector &)result).getVector()),
         _wVector()
diff --git a/searchlib/src/vespa/searchlib/expression/attributenode.h b/searchlib/src/vespa/searchlib/expression/attributenode.h
index d668bd3f662..67ec6a3302f 100644
--- a/searchlib/src/vespa/searchlib/expression/attributenode.h
+++ b/searchlib/src/vespa/searchlib/expression/attributenode.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "functionnode.h"
-#include "resultvector.h"
 #include "attributeresult.h"
 #include <vespa/vespalib/objects/objectoperation.h>
 #include <vespa/vespalib/objects/objectpredicate.h>
diff --git a/searchlib/src/vespa/searchlib/expression/debugwaitfunctionnode.h b/searchlib/src/vespa/searchlib/expression/debugwaitfunctionnode.h
index 2371482825d..4a3ca0cf64d 100644
--- a/searchlib/src/vespa/searchlib/expression/debugwaitfunctionnode.h
+++ b/searchlib/src/vespa/searchlib/expression/debugwaitfunctionnode.h
@@ -2,9 +2,6 @@
 #pragma once
 
 #include "unaryfunctionnode.h"
-#include "stringresultnode.h"
-#include "resultvector.h"
-#include <vespa/searchlib/common/sortspec.h>
 
 namespace search::expression {
 
diff --git a/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.cpp b/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.cpp
index f7c8941c3e2..1aafd523832 100644
--- a/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.cpp
+++ b/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.cpp
@@ -4,14 +4,13 @@
 #include "floatresultnode.h"
 #include "integerbucketresultnode.h"
 #include "floatbucketresultnode.h"
+#include "resultvector.h"
 #include <vespa/vespalib/util/stringfmt.h>
 #include <stdexcept>
 #include <cmath>
 #include <limits>
 
-
-namespace search {
-namespace expression {
+namespace search::expression {
 
 IMPLEMENT_EXPRESSIONNODE(FixedWidthBucketFunctionNode, UnaryFunctionNode);
 
@@ -79,7 +78,7 @@ FixedWidthBucketFunctionNode::FloatBucketHandler::update(ResultNode &result, con
     bucket.setRange(from, to);
 }
 
-FixedWidthBucketFunctionNode::~FixedWidthBucketFunctionNode() {}
+FixedWidthBucketFunctionNode::~FixedWidthBucketFunctionNode() = default;
 
 void
 FixedWidthBucketFunctionNode::onPrepareResult()
@@ -87,20 +86,16 @@ FixedWidthBucketFunctionNode::onPrepareResult()
     const ExpressionNode &child = getArg();
     const ResultNode     &input = *child.getResult();
     if (input.getClass().inherits(IntegerResultNode::classId)) {
-        ResultNode::UP res(new IntegerBucketResultNode());
-        setResultType(std::move(res));
+        setResultType(std::make_unique<IntegerBucketResultNode>());
         _bucketHandler.reset(new IntegerBucketHandler(_width->getInteger()));
     } else if (input.getClass().inherits(FloatResultNode::classId)) {
-        ResultNode::UP res(new FloatBucketResultNode());
-        setResultType(std::move(res));
+        setResultType(std::make_unique<FloatBucketResultNode>());
         _bucketHandler.reset(new FloatBucketHandler(_width->getFloat()));
     } else if (input.getClass().inherits(IntegerResultNodeVector::classId)) {
-        ResultNode::UP res(new IntegerBucketResultNodeVector());
-        setResultType(std::move(res));
+        setResultType(std::make_unique<IntegerBucketResultNodeVector>());
         _bucketHandler.reset(new IntegerVectorBucketHandler(_width->getInteger()));
     } else if (input.getClass().inherits(FloatResultNodeVector::classId)) {
-        ResultNode::UP res(new FloatBucketResultNodeVector());
-        setResultType(std::move(res));
+        setResultType(std::make_unique<FloatBucketResultNodeVector>());
         _bucketHandler.reset(new FloatVectorBucketHandler(_width->getFloat()));
     } else {
         throw std::runtime_error(vespalib::make_string("cannot create appropriate bucket for type '%s'", input.getClass().name()));
@@ -130,7 +125,6 @@ FixedWidthBucketFunctionNode::onDeserialize(vespalib::Deserializer &is)
 }
 
 }
-}
 
 // this function was added by ../../forcelink.sh
 void forcelink_file_searchlib_expression_fixedwidthbucketfunctionnode() {}
diff --git a/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.h b/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.h
index 000bdf733c5..fcc4ba0ad5d 100644
--- a/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.h
+++ b/searchlib/src/vespa/searchlib/expression/fixedwidthbucketfunctionnode.h
@@ -5,11 +5,9 @@
 #include "numericresultnode.h"
 #include "integerbucketresultnode.h"
 #include "floatbucketresultnode.h"
-#include "resultvector.h"
 #include <memory>
 
-namespace search {
-namespace expression {
+namespace search::expression {
 
 class FixedWidthBucketFunctionNode : public UnaryFunctionNode
 {
@@ -19,7 +17,7 @@ public:
         using CP = vespalib::CloneablePtr<BucketHandler>;
         virtual void update(ResultNode &result, const ResultNode &value) const = 0;
         virtual BucketHandler *clone() const = 0;
-        virtual ~BucketHandler() {}
+        virtual ~BucketHandler() = default;
     };
 
     // update integer result bucket based on integer value
@@ -60,7 +58,7 @@ public:
     DECLARE_NBO_SERIALIZE;
     FixedWidthBucketFunctionNode() : UnaryFunctionNode(), _width(), _bucketHandler() {}
     FixedWidthBucketFunctionNode(ExpressionNode::UP arg) : UnaryFunctionNode(std::move(arg)), _width(), _bucketHandler() {}
-    ~FixedWidthBucketFunctionNode();
+    ~FixedWidthBucketFunctionNode() override;
     FixedWidthBucketFunctionNode &setWidth(const NumericResultNode::CP &width) {
         _width = width;
         return *this;
@@ -68,4 +66,3 @@ public:
 };
 
 }
-}
diff --git a/searchlib/src/vespa/searchlib/expression/functionnode.h b/searchlib/src/vespa/searchlib/expression/functionnode.h
index 4e23a2f3c60..c2b7dff6a7a 100644
--- a/searchlib/src/vespa/searchlib/expression/functionnode.h
+++ b/searchlib/src/vespa/searchlib/expression/functionnode.h
@@ -4,8 +4,7 @@
 #include "expressionnode.h"
 #include "resultnode.h"
 
-namespace search {
-namespace expression {
+namespace search::expression {
 
 class FunctionNode : public ExpressionNode
 {
@@ -15,9 +14,9 @@ public:
     DECLARE_ABSTRACT_EXPRESSIONNODE(FunctionNode);
     const ResultNode * getResult() const override { return _tmpResult.get(); }
     ResultNode & updateResult() const { return *_tmpResult; }
-    virtual void reset() { _tmpResult.reset(NULL); }
+    virtual void reset() { _tmpResult.reset(nullptr); }
 
-    FunctionNode &setResult(const ResultNode::CP res) { _tmpResult = res; return *this; }
+    FunctionNode &setResult(const ResultNode::CP res) { _tmpResult = std::move(res); return *this; }
 protected:
     void setResultType(ResultNode::UP res) { _tmpResult = std::move(res); }
     void selectMembers(const vespalib::ObjectPredicate & predicate, vespalib::ObjectOperation & operation) override;
@@ -26,5 +25,3 @@ private:
 };
 
 }
-}
-
diff --git a/searchlib/src/vespa/searchlib/expression/functionnodes.cpp b/searchlib/src/vespa/searchlib/expression/functionnodes.cpp
index cc6a8c137a7..109b4a59a05 100644
--- a/searchlib/src/vespa/searchlib/expression/functionnodes.cpp
+++ b/searchlib/src/vespa/searchlib/expression/functionnodes.cpp
@@ -83,19 +83,22 @@ IMPLEMENT_EXPRESSIONNODE(ToRawFunctionNode,    UnaryFunctionNode);
 IMPLEMENT_EXPRESSIONNODE(XorBitFunctionNode,   UnaryBitFunctionNode);
 IMPLEMENT_EXPRESSIONNODE(MD5BitFunctionNode,   UnaryBitFunctionNode);
 
-void ExpressionNode::onArgument(const ResultNode & arg, ResultNode & result) const
+void
+ExpressionNode::onArgument(const ResultNode & arg, ResultNode & result) const
 {
     (void) arg;
     (void) result;
     throw std::runtime_error(make_string("Class %s does not implement onArgument(const ResultNode & arg, ResultNode & result). Probably an indication that it tries to take a multivalued argument, which it can not.", getClass().name()));
 }
 
-void ExpressionNode::executeIterative(const ResultNode & arg, ResultNode & result) const
+void
+ExpressionNode::executeIterative(const ResultNode & arg, ResultNode & result) const
 {
     onArgument(arg, result);
 }
 
-void ExpressionNode::wireAttributes(const search::attribute::IAttributeContext &)
+void
+ExpressionNode::wireAttributes(const search::attribute::IAttributeContext &)
 {
 }
 
@@ -141,7 +144,8 @@ private:
     std::map<size_t, std::map<size_t, size_t> > _typeConversion;
 };
 
-ResultNode::UP ArithmeticTypeConversion::getType(const ResultNode & arg1, const ResultNode & arg2)
+ResultNode::UP
+ArithmeticTypeConversion::getType(const ResultNode & arg1, const ResultNode & arg2)
 {
     size_t baseTypeId = getType(getBaseType2(arg1), getBaseType2(arg2));
     size_t dimension = std::max(getDimension(arg1), getDimension(arg2));
@@ -162,13 +166,15 @@ ResultNode::UP ArithmeticTypeConversion::getType(const ResultNode & arg1, const
     return result;
 }
 
-ResultNode::UP ArithmeticTypeConversion::getType(const ResultNode & arg)
+ResultNode::UP
+ArithmeticTypeConversion::getType(const ResultNode & arg)
 {
     size_t baseTypeId = getBaseType(arg);
     return ResultNode::UP(static_cast<ResultNode *>(Identifiable::classFromId(baseTypeId)->create()));
 }
 
-size_t ArithmeticTypeConversion::getBaseType(const ResultNode & r)
+size_t
+ArithmeticTypeConversion::getBaseType(const ResultNode & r)
 {
     if (r.getClass().inherits(ResultNodeVector::classId)) {
         return getBaseType(* r.createBaseType());
@@ -177,7 +183,8 @@ size_t ArithmeticTypeConversion::getBaseType(const ResultNode & r)
     }
 }
 
-size_t ArithmeticTypeConversion::getBaseType2(const ResultNode & r)
+size_t
+ArithmeticTypeConversion::getBaseType2(const ResultNode & r)
 {
     if (r.getClass().inherits(ResultNodeVector::classId)) {
         return getBaseType2(* r.createBaseType());
@@ -193,7 +200,8 @@ namespace {
 }
 
 
-void MultiArgFunctionNode::onPrepare(bool preserveAccurateTypes)
+void
+MultiArgFunctionNode::onPrepare(bool preserveAccurateTypes)
 {
     for(size_t i(0), m(_args.size()); i < m; i++) {
         _args[i]->prepare(preserveAccurateTypes);
@@ -201,7 +209,8 @@ void MultiArgFunctionNode::onPrepare(bool preserveAccurateTypes)
     prepareResult();
 }
 
-void MultiArgFunctionNode::onPrepareResult()
+void
+MultiArgFunctionNode::onPrepareResult()
 {
     if (_args.size() == 1) {
         setResultType(ArithmeticTypeConversion::getType(*_args[0]->getResult()));
@@ -215,7 +224,8 @@ void MultiArgFunctionNode::onPrepareResult()
     }
 }
 
-bool MultiArgFunctionNode::onExecute() const
+bool
+MultiArgFunctionNode::onExecute() const
 {
     for(size_t i(0), m(_args.size()); i < m; i++) {
         _args[i]->execute();
@@ -223,7 +233,8 @@ bool MultiArgFunctionNode::onExecute() const
     return calculate(_args, updateResult());
 }
 
-bool MultiArgFunctionNode::onCalculate(const ExpressionNodeVector & args, ResultNode & result) const
+bool
+MultiArgFunctionNode::onCalculate(const ExpressionNodeVector & args, ResultNode & result) const
 {
     result.set(*args[0]->getResult());
     for (size_t i(1), m(args.size()); i < m; i++) {
@@ -232,28 +243,33 @@ bool MultiArgFunctionNode::onCalculate(const ExpressionNodeVector & args, Result
     return true;
 }
 
-void BitFunctionNode::onPrepareResult()
+void
+BitFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new Int64ResultNode(0)));
+    setResultType(std::make_unique<Int64ResultNode>(0));
 }
 
-void StrCatFunctionNode::onPrepareResult()
+void
+StrCatFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new StringResultNode()));
+    setResultType(std::make_unique<StringResultNode>());
 }
 
-void CatFunctionNode::onPrepareResult()
+void
+CatFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new RawResultNode()));
+    setResultType(std::make_unique<RawResultNode>());
 }
 
-void CatFunctionNode::onPrepare(bool preserveAccurateTypes)
+void
+CatFunctionNode::onPrepare(bool preserveAccurateTypes)
 {
     (void) preserveAccurateTypes;
     MultiArgFunctionNode::onPrepare(true);
 }
 
-void BitFunctionNode::onArgument(const ResultNode & arg, ResultNode & result) const
+void
+BitFunctionNode::onArgument(const ResultNode & arg, ResultNode & result) const
 {
     onArgument(arg, static_cast<Int64ResultNode &>(result));
 }
@@ -268,7 +284,8 @@ void AndFunctionNode::onArgument(const ResultNode & arg, Int64ResultNode & resul
 void OrFunctionNode::onArgument(const ResultNode & arg, Int64ResultNode & result)  const { result.orOp(arg); }
 void XorFunctionNode::onArgument(const ResultNode & arg, Int64ResultNode & result) const { result.xorOp(arg); }
 
-ResultNode::CP MaxFunctionNode::getInitialValue() const
+ResultNode::CP
+MaxFunctionNode::getInitialValue() const
 {
     ResultNode::CP initial;
     const ResultNode & arg(*getArg(0).getResult());
@@ -282,7 +299,8 @@ ResultNode::CP MaxFunctionNode::getInitialValue() const
     return initial;
 }
 
-ResultNode::CP MinFunctionNode::getInitialValue() const
+ResultNode::CP
+MinFunctionNode::getInitialValue() const
 {
     ResultNode::CP initial;
     const ResultNode & arg(*getArg(0).getResult());
@@ -296,98 +314,115 @@ ResultNode::CP MinFunctionNode::getInitialValue() const
     return initial;
 }
 
-ResultNode & ModuloFunctionNode::flatten(const ResultNodeVector &, ResultNode &) const
+ResultNode &
+ModuloFunctionNode::flatten(const ResultNodeVector &, ResultNode &) const
 {
    throw std::runtime_error("ModuloFunctionNode::flatten() const not implemented since it shall never be used.");
 }
 
-ResultNode & DivideFunctionNode::flatten(const ResultNodeVector &, ResultNode &) const
+ResultNode &
+DivideFunctionNode::flatten(const ResultNodeVector &, ResultNode &) const
 {
    throw std::runtime_error("DivideFunctionNode::flatten() const not implemented since it shall never be used.");
 }
 
-ResultNode::CP ModuloFunctionNode::getInitialValue() const
+ResultNode::CP
+ModuloFunctionNode::getInitialValue() const
 {
    throw std::runtime_error("ModuloFunctionNode::getInitialValue() const not implemented since it shall never be used.");
 }
 
-ResultNode::CP DivideFunctionNode::getInitialValue() const
+ResultNode::CP
+DivideFunctionNode::getInitialValue() const
 {
    throw std::runtime_error("DivideFunctionNode::getInitialValue() const not implemented since it shall never be used.");
 }
 
 UnaryBitFunctionNode::~UnaryBitFunctionNode() = default;
 
-void UnaryBitFunctionNode::onPrepareResult()
+void
+UnaryBitFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new RawResultNode()));
+    setResultType(std::make_unique<RawResultNode>());
 }
 
-void UnaryBitFunctionNode::onPrepare(bool preserveAccurateTypes)
+void
+UnaryBitFunctionNode::onPrepare(bool preserveAccurateTypes)
 {
     (void) preserveAccurateTypes;
     UnaryFunctionNode::onPrepare(true);
 }
 
-void UnaryFunctionNode::onPrepareResult()
+void
+UnaryFunctionNode::onPrepareResult()
 {
     setResultType(std::unique_ptr<ResultNode>(getArg().getResult()->clone()));
 }
 
-void ToStringFunctionNode::onPrepareResult()
+void
+ToStringFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new StringResultNode()));
+    setResultType(std::make_unique<StringResultNode>());
 }
 
-bool ToStringFunctionNode::onExecute() const
+bool
+ToStringFunctionNode::onExecute() const
 {
     getArg().execute();
     updateResult().set(*getArg().getResult());
     return true;
 }
 
-void ToRawFunctionNode::onPrepareResult()
+void
+ToRawFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new RawResultNode()));
+    setResultType(std::make_unique<RawResultNode>());
 }
 
-bool ToRawFunctionNode::onExecute() const
+bool
+ToRawFunctionNode::onExecute() const
 {
     getArg().execute();
     updateResult().set(*getArg().getResult());
     return true;
 }
 
-void ToIntFunctionNode::onPrepareResult()
+void
+ToIntFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new Int64ResultNode()));
+    setResultType(std::make_unique<Int64ResultNode>());
 }
 
-bool ToIntFunctionNode::onExecute() const
+bool
+ToIntFunctionNode::onExecute() const
 {
     getArg().execute();
     updateResult().set(*getArg().getResult());
     return true;
 }
 
-void ToFloatFunctionNode::onPrepareResult()
+void
+ToFloatFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new FloatResultNode()));
+    setResultType(std::make_unique<FloatResultNode>());
 }
 
-bool ToFloatFunctionNode::onExecute() const
+bool
+ToFloatFunctionNode::onExecute() const
 {
     getArg().execute();
     updateResult().set(*getArg().getResult());
     return true;
 }
 
-void StrLenFunctionNode::onPrepareResult()
+void
+StrLenFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new Int64ResultNode()));
+    setResultType(std::make_unique<Int64ResultNode>());
 }
 
-bool StrLenFunctionNode::onExecute() const
+bool
+StrLenFunctionNode::onExecute() const
 {
     getArg().execute();
     char buf[32];
@@ -395,12 +430,14 @@ bool StrLenFunctionNode::onExecute() const
     return true;
 }
 
-void NormalizeSubjectFunctionNode::onPrepareResult()
+void
+NormalizeSubjectFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new StringResultNode()));
+    setResultType(std::make_unique<StringResultNode>());
 }
 
-bool NormalizeSubjectFunctionNode::onExecute() const
+bool
+NormalizeSubjectFunctionNode::onExecute() const
 {
     getArg().execute();
     char buf[32];
@@ -422,12 +459,14 @@ bool NormalizeSubjectFunctionNode::onExecute() const
     return true;
 }
 
-void NumElemFunctionNode::onPrepareResult()
+void
+NumElemFunctionNode::onPrepareResult()
 {
-    setResultType(std::unique_ptr<ResultNode>(new Int64ResultNode(1)));
+    setResultType(std::make_unique<Int64ResultNode>(1));
 }
 
-bool NumElemFunctionNode::onExecute() const
+bool
+NumElemFunctionNode::onExecute() const
 {
     getArg().execute();
     if (getArg().getResult()->inherits(ResultNodeVector::classId)) {
@@ -436,7 +475,8 @@ bool NumElemFunctionNode::onExecute() const
     return true;
 }
 
-bool NegateFunctionNode::onExecute() const
+bool
+NegateFunctionNode::onExecute() const
 {
     getArg().execute();
     updateResult().assign(*getArg().getResult());
@@ -444,7 +484,8 @@ bool NegateFunctionNode::onExecute() const
     return true;
 }
 
-bool SortFunctionNode::onExecute() const
+bool
+SortFunctionNode::onExecute() const
 {
     getArg().execute();
     updateResult().assign(*getArg().getResult());
@@ -452,7 +493,8 @@ bool SortFunctionNode::onExecute() const
     return true;
 }
 
-bool ReverseFunctionNode::onExecute() const
+bool
+ReverseFunctionNode::onExecute() const
 {
     getArg().execute();
     updateResult().assign(*getArg().getResult());
@@ -460,7 +502,8 @@ bool ReverseFunctionNode::onExecute() const
     return true;
 }
 
-bool StrCatFunctionNode::onExecute() const
+bool
+StrCatFunctionNode::onExecute() const
 {
     asciistream os;
     StrCatSerializer nos(os);
@@ -472,7 +515,8 @@ bool StrCatFunctionNode::onExecute() const
     return true;
 }
 
-bool CatFunctionNode::onExecute() const
+bool
+CatFunctionNode::onExecute() const
 {
     nbostream os;
     CatSerializer nos(os);
@@ -484,15 +528,16 @@ bool CatFunctionNode::onExecute() const
     return true;
 }
 
-XorBitFunctionNode::XorBitFunctionNode() {}
-XorBitFunctionNode::~XorBitFunctionNode() {}
+XorBitFunctionNode::XorBitFunctionNode() = default;
+XorBitFunctionNode::~XorBitFunctionNode() = default;
 
 XorBitFunctionNode::XorBitFunctionNode(ExpressionNode::UP arg, unsigned numBits) :
     UnaryBitFunctionNode(std::move(arg), numBits),
     _tmpXor(getNumBytes(), 0)
 {}
 
-bool UnaryBitFunctionNode::onExecute() const
+bool
+UnaryBitFunctionNode::onExecute() const
 {
     _tmpOs.clear();
     getArg().execute();
@@ -501,13 +546,15 @@ bool UnaryBitFunctionNode::onExecute() const
     return internalExecute(_tmpOs);
 }
 
-void XorBitFunctionNode::onPrepareResult()
+void
+XorBitFunctionNode::onPrepareResult()
 {
     UnaryBitFunctionNode::onPrepareResult();
     _tmpXor.resize(getNumBytes());
 }
 
-bool XorBitFunctionNode::internalExecute(const nbostream & os) const
+bool
+XorBitFunctionNode::internalExecute(const nbostream & os) const
 {
     const size_t numBytes(_tmpXor.size());
     memset(&_tmpXor[0], 0, numBytes);
@@ -524,7 +571,8 @@ bool XorBitFunctionNode::internalExecute(const nbostream & os) const
     return true;
 }
 
-bool MD5BitFunctionNode::internalExecute(const nbostream & os) const
+bool
+MD5BitFunctionNode::internalExecute(const nbostream & os) const
 {
     const unsigned int MD5_DIGEST_LENGTH = 16;
     unsigned char md5ScratchPad[MD5_DIGEST_LENGTH];
@@ -533,11 +581,13 @@ bool MD5BitFunctionNode::internalExecute(const nbostream & os) const
     return true;
 }
 
-Serializer & FunctionNode::onSerialize(Serializer & os) const
+Serializer &
+FunctionNode::onSerialize(Serializer & os) const
 {
     return os << _tmpResult;
 }
-Deserializer & FunctionNode::onDeserialize(Deserializer & is)
+Deserializer &
+FunctionNode::onDeserialize(Deserializer & is)
 {
     return is >> _tmpResult;
 }
@@ -548,11 +598,13 @@ ConstantNode::visitMembers(vespalib::ObjectVisitor &visitor) const
     visit(visitor, "Value", _result);
 }
 
-Serializer & ConstantNode::onSerialize(Serializer & os) const
+Serializer &
+ConstantNode::onSerialize(Serializer & os) const
 {
     return os << _result;
 }
-Deserializer & ConstantNode::onDeserialize(Deserializer & is)
+Deserializer &
+ConstantNode::onDeserialize(Deserializer & is)
 {
     return is >> _result;
 }
@@ -565,14 +617,16 @@ FunctionNode::visitMembers(vespalib::ObjectVisitor & visitor) const
     visit(visitor, "tmpResult", _tmpResult);
 }
 
-void FunctionNode::selectMembers(const vespalib::ObjectPredicate & predicate, vespalib::ObjectOperation & operation)
+void
+FunctionNode::selectMembers(const vespalib::ObjectPredicate & predicate, vespalib::ObjectOperation & operation)
 {
     if (_tmpResult.get()) {
         _tmpResult->select(predicate, operation);
     }
 }
 
-void MultiArgFunctionNode::selectMembers(const vespalib::ObjectPredicate & predicate, vespalib::ObjectOperation & operation)
+void
+MultiArgFunctionNode::selectMembers(const vespalib::ObjectPredicate & predicate, vespalib::ObjectOperation & operation)
 {
     FunctionNode::selectMembers(predicate, operation);
     for(size_t i(0), m(_args.size()); i < m; i++) {
@@ -580,23 +634,26 @@ void MultiArgFunctionNode::selectMembers(const vespalib::ObjectPredicate & predi
     }
 }
 
-Serializer & MultiArgFunctionNode::onSerialize(Serializer & os) const
+Serializer &
+MultiArgFunctionNode::onSerialize(Serializer & os) const
 {
     FunctionNode::onSerialize(os);
     os << _args;
     return os;
 }
-Deserializer & MultiArgFunctionNode::onDeserialize(Deserializer & is)
+
+Deserializer &
+MultiArgFunctionNode::onDeserialize(Deserializer & is)
 {
     FunctionNode::onDeserialize(is);
     return is >> _args;
 }
 
-MultiArgFunctionNode::MultiArgFunctionNode() : FunctionNode() { }
+MultiArgFunctionNode::MultiArgFunctionNode() noexcept : FunctionNode() { }
 MultiArgFunctionNode::MultiArgFunctionNode(const MultiArgFunctionNode &) = default;
 MultiArgFunctionNode & MultiArgFunctionNode::operator = (const MultiArgFunctionNode &) = default;
 
-MultiArgFunctionNode::~MultiArgFunctionNode() {}
+MultiArgFunctionNode::~MultiArgFunctionNode() = default;
 
 void
 MultiArgFunctionNode::visitMembers(vespalib::ObjectVisitor &visitor) const
@@ -605,12 +662,14 @@ MultiArgFunctionNode::visitMembers(vespalib::ObjectVisitor &visitor) const
     visit(visitor, "args", _args);
 }
 
-Serializer & UnaryBitFunctionNode::onSerialize(Serializer & os) const
+Serializer &
+UnaryBitFunctionNode::onSerialize(Serializer & os) const
 {
     UnaryFunctionNode::onSerialize(os);
     return os << _numBits;
 }
-Deserializer & UnaryBitFunctionNode::onDeserialize(Deserializer & is)
+Deserializer &
+UnaryBitFunctionNode::onDeserialize(Deserializer & is)
 {
     UnaryFunctionNode::onDeserialize(is);
     return is >> _numBits;
diff --git a/searchlib/src/vespa/searchlib/expression/multiargfunctionnode.h b/searchlib/src/vespa/searchlib/expression/multiargfunctionnode.h
index 6702fa37215..d38e2f9a6d5 100644
--- a/searchlib/src/vespa/searchlib/expression/multiargfunctionnode.h
+++ b/searchlib/src/vespa/searchlib/expression/multiargfunctionnode.h
@@ -3,8 +3,7 @@
 
 #include "functionnode.h"
 
-namespace search {
-namespace expression {
+namespace search::expression {
 
 class MultiArgFunctionNode : public FunctionNode
 {
@@ -13,11 +12,11 @@ public:
     DECLARE_NBO_SERIALIZE;
     void visitMembers(vespalib::ObjectVisitor & visitor) const override;
     DECLARE_ABSTRACT_EXPRESSIONNODE(MultiArgFunctionNode);
-    MultiArgFunctionNode();
+    MultiArgFunctionNode() noexcept;
     MultiArgFunctionNode(const MultiArgFunctionNode &);
     MultiArgFunctionNode & operator = (const MultiArgFunctionNode &);
-    MultiArgFunctionNode(MultiArgFunctionNode &&) = default;
-    MultiArgFunctionNode & operator = (MultiArgFunctionNode &&) = default;
+    MultiArgFunctionNode(MultiArgFunctionNode &&) noexcept = default;
+    MultiArgFunctionNode & operator = (MultiArgFunctionNode &&) noexcept = default;
     ~MultiArgFunctionNode();
     MultiArgFunctionNode & appendArg(ExpressionNode::UP arg) { return addArg(std::move(arg)); }
     MultiArgFunctionNode & addArg(ExpressionNode::UP arg) {
@@ -42,5 +41,3 @@ private:
 };
 
 }
-}
-
diff --git a/searchlib/src/vespa/searchlib/expression/orfunctionnode.h b/searchlib/src/vespa/searchlib/expression/orfunctionnode.h
index a657d896eb2..e2522eedc4f 100644
--- a/searchlib/src/vespa/searchlib/expression/orfunctionnode.h
+++ b/searchlib/src/vespa/searchlib/expression/orfunctionnode.h
@@ -3,14 +3,13 @@
 
 #include "bitfunctionnode.h"
 
-namespace search {
-namespace expression {
+namespace search::expression {
 
 class OrFunctionNode : public BitFunctionNode
 {
 public:
     DECLARE_EXPRESSIONNODE(OrFunctionNode);
-    OrFunctionNode() { }
+    OrFunctionNode() noexcept = default;
 private:
     ResultNode::CP getInitialValue() const override { return  ResultNode::CP(new Int64ResultNode(0)); }
     ResultNode & flatten(const ResultNodeVector & v, ResultNode & result) const override { return v.flattenOr(result); }
@@ -18,4 +17,3 @@ private:
 };
 
 }
-}
diff --git a/searchlib/src/vespa/searchlib/expression/rangebucketpredef.h b/searchlib/src/vespa/searchlib/expression/rangebucketpredef.h
index 313ef62404d..fb892702444 100644
--- a/searchlib/src/vespa/searchlib/expression/rangebucketpredef.h
+++ b/searchlib/src/vespa/searchlib/expression/rangebucketpredef.h
@@ -7,8 +7,7 @@
 #include "floatresultnode.h"
 #include "stringresultnode.h"
 
-namespace search {
-namespace expression {
+namespace search::expression {
 
 class RangeBucketPreDefFunctionNode : public UnaryFunctionNode
 {
@@ -57,8 +56,8 @@ private:
 public:
     DECLARE_EXPRESSIONNODE(RangeBucketPreDefFunctionNode);
     DECLARE_NBO_SERIALIZE;
-    RangeBucketPreDefFunctionNode() : UnaryFunctionNode(), _predef(), _result(NULL), _nullResult(NULL) {}
-    RangeBucketPreDefFunctionNode(ExpressionNode::UP arg) : UnaryFunctionNode(std::move(arg)), _predef(), _result(NULL), _nullResult(NULL) {}
+    RangeBucketPreDefFunctionNode() : UnaryFunctionNode(), _predef(), _result(nullptr), _nullResult(nullptr) {}
+    RangeBucketPreDefFunctionNode(ExpressionNode::UP arg) : UnaryFunctionNode(std::move(arg)), _predef(), _result(nullptr), _nullResult(nullptr) {}
     RangeBucketPreDefFunctionNode(const RangeBucketPreDefFunctionNode & rhs);
     RangeBucketPreDefFunctionNode & operator = (const RangeBucketPreDefFunctionNode & rhs);
     ~RangeBucketPreDefFunctionNode();
@@ -72,4 +71,3 @@ public:
 };
 
 }
-}
diff --git a/searchlib/src/vespa/searchlib/expression/resultvector.h b/searchlib/src/vespa/searchlib/expression/resultvector.h
index fa0e2d9a71f..22fac0b214b 100644
--- a/searchlib/src/vespa/searchlib/expression/resultvector.h
+++ b/searchlib/src/vespa/searchlib/expression/resultvector.h
@@ -83,8 +83,8 @@ public:
     using Vector = std::vector<B>;
     using BaseType = B;
     ~ResultNodeVectorT() override;
-    const Vector & getVector() const { return _result; }
-    Vector & getVector() { return _result; }
+    const Vector & getVector() const noexcept { return _result; }
+    Vector & getVector() noexcept { return _result; }
     const ResultNode * find(const ResultNode & key) const override;
     void sort() override;
     void reverse() override;
@@ -113,14 +113,16 @@ template <typename B, typename C, typename G>
 ResultNodeVectorT<B, C, G>::~ResultNodeVectorT() = default;
 
 template <typename B, typename C, typename G>
-ResultNodeVector & ResultNodeVectorT<B, C, G>::set(size_t index, const ResultNode & node)
+ResultNodeVector &
+ResultNodeVectorT<B, C, G>::set(size_t index, const ResultNode & node)
 {
     _result[index].set(node);
     return *this;
 }
 
 template <typename B, typename C, typename G>
-ResultNodeVector & ResultNodeVectorT<B, C, G>::push_back_safe(const ResultNode & node)
+ResultNodeVector &
+ResultNodeVectorT<B, C, G>::push_back_safe(const ResultNode & node)
 {
     if (node.inherits(B::classId)) {
         _result.push_back(static_cast<const B &>(node));
@@ -133,14 +135,16 @@ ResultNodeVector & ResultNodeVectorT<B, C, G>::push_back_safe(const ResultNode &
 }
 
 template <typename B, typename C, typename G>
-ResultNodeVector & ResultNodeVectorT<B, C, G>::push_back(const ResultNode & node)
+ResultNodeVector &
+ResultNodeVectorT<B, C, G>::push_back(const ResultNode & node)
 {
     _result.push_back(static_cast<const B &>(node));
     return *this;
 }
 
 template <typename B, typename C, typename G>
-int ResultNodeVectorT<B, C, G>::onCmp(const Identifiable & rhs) const
+int
+ResultNodeVectorT<B, C, G>::onCmp(const Identifiable & rhs) const
 {
     const ResultNodeVectorT & b(static_cast<const ResultNodeVectorT &>(rhs));
     int diff = _result.size() - b._result.size();
@@ -151,20 +155,23 @@ int ResultNodeVectorT<B, C, G>::onCmp(const Identifiable & rhs) const
 }
 
 template <typename B, typename C, typename G>
-void ResultNodeVectorT<B, C, G>::sort()
+void
+ResultNodeVectorT<B, C, G>::sort()
 {
     using LC = cmpT<B>;
     std::sort(_result.begin(), _result.end(), typename LC::less());
 }
 
 template <typename B, typename C, typename G>
-void ResultNodeVectorT<B, C, G>::reverse()
+void
+ResultNodeVectorT<B, C, G>::reverse()
 {
     std::reverse(_result.begin(), _result.end());
 }
 
 template <typename B, typename C, typename G>
-size_t ResultNodeVectorT<B, C, G>::hash() const
+size_t
+ResultNodeVectorT<B, C, G>::hash() const
 {
     size_t h(0);
     for(typename Vector::const_iterator it(_result.begin()), mt(_result.end()); it != mt; it++) {
@@ -174,7 +181,8 @@ size_t ResultNodeVectorT<B, C, G>::hash() const
 }
 
 template <typename B, typename C, typename G>
-void ResultNodeVectorT<B, C, G>::negate()
+void
+ResultNodeVectorT<B, C, G>::negate()
 {
     for(typename Vector::iterator it(_result.begin()), mt(_result.end()); it != mt; it++) {
         it->negate();
@@ -182,25 +190,28 @@ void ResultNodeVectorT<B, C, G>::negate()
 }
 
 template <typename B, typename C, typename G>
-const ResultNode * ResultNodeVectorT<B, C, G>::find(const ResultNode & key) const
+const ResultNode *
+ResultNodeVectorT<B, C, G>::find(const ResultNode & key) const
 {
     G getter;
     typename Vector::const_iterator found = std::lower_bound(_result.begin(), _result.end(), getter(key), typename C::less() );
     if (found != _result.end()) {
         typename C::equal equal;
-        return equal(*found, getter(key)) ? &(*found) : NULL;
+        return equal(*found, getter(key)) ? &(*found) : nullptr;
     }
-    return NULL;
+    return nullptr;
 }
 
 template <typename B, typename C, typename G>
-vespalib::Serializer & ResultNodeVectorT<B, C, G>::onSerialize(vespalib::Serializer & os) const
+vespalib::Serializer &
+ResultNodeVectorT<B, C, G>::onSerialize(vespalib::Serializer & os) const
 {
     return serialize(_result, os);
 }
 
 template <typename B, typename C, typename G>
-vespalib::Deserializer & ResultNodeVectorT<B, C, G>::onDeserialize(vespalib::Deserializer & is)
+vespalib::Deserializer &
+ResultNodeVectorT<B, C, G>::onDeserialize(vespalib::Deserializer & is)
 {
     return deserialize(_result, is);
 }
@@ -226,8 +237,8 @@ public:
         B v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
-            v.multiply(vec[i]);
+        for (const B & item : vec) {
+            v.multiply(item);
         }
         r.set(v);
         return r;
@@ -236,8 +247,8 @@ public:
         Int64ResultNode v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
-            v.andOp(vec[i]);
+        for (const B & item : vec) {
+            v.andOp(item);
         }
         r.set(v);
         return r;
@@ -246,8 +257,8 @@ public:
         Int64ResultNode v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
-            v.orOp(vec[i]);
+        for (const B & item : vec) {
+            v.orOp(item);
         }
         r.set(v);
         return r;
@@ -256,8 +267,8 @@ public:
         Int64ResultNode v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
-            v.xorOp(vec[i]);
+        for (const B & item : vec) {
+            v.xorOp(item);
         }
         r.set(v);
         return r;
@@ -266,8 +277,8 @@ public:
         B v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
-            v.add(vec[i]);
+        for (const B & item : vec) {
+            v.add(item);
         }
         r.set(v);
         return r;
@@ -276,8 +287,8 @@ public:
         B v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
-            v.max(vec[i]);
+        for (const B & item : vec) {
+            v.max(item);
         }
         r.set(v);
         return r;
@@ -286,8 +297,8 @@ public:
         B v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
-            v.min(vec[i]);
+        for (const B & item : vec) {
+            v.min(item);
         }
         r.set(v);
         return r;
@@ -296,10 +307,10 @@ public:
         B v;
         v.set(r);
         const std::vector<B> & vec(this->getVector());
-        for (size_t i(0), m(vec.size()); i < m; i++) {
+        for (const B & item : vec) {
             B squared;
-            squared.set(vec[i]);
-            squared.multiply(vec[i]);
+            squared.set(item);
+            squared.multiply(item);
             v.add(squared);
         }
         r.set(v);
@@ -311,7 +322,7 @@ public:
 class BoolResultNodeVector : public NumericResultNodeVectorT<BoolResultNode>
 {
 public:
-    BoolResultNodeVector() { }
+    BoolResultNodeVector() noexcept = default;
     DECLARE_RESULTNODE(BoolResultNodeVector);
 
     const IntegerBucketResultNode& getNullBucket() const override { return IntegerBucketResultNode::getNull(); }
@@ -320,7 +331,7 @@ public:
 class Int8ResultNodeVector : public NumericResultNodeVectorT<Int8ResultNode>
 {
 public:
-    Int8ResultNodeVector() { }
+    Int8ResultNodeVector() noexcept = default;
     DECLARE_RESULTNODE(Int8ResultNodeVector);
 
     const IntegerBucketResultNode& getNullBucket() const override { return IntegerBucketResultNode::getNull(); }
@@ -329,7 +340,7 @@ public:
 class Int16ResultNodeVector : public NumericResultNodeVectorT<Int16ResultNode>
 {
 public:
-    Int16ResultNodeVector() { }
+    Int16ResultNodeVector() = default;
     DECLARE_RESULTNODE(Int16ResultNodeVector);
 
     const IntegerBucketResultNode& getNullBucket() const override { return IntegerBucketResultNode::getNull(); }
@@ -338,7 +349,7 @@ public:
 class Int32ResultNodeVector : public NumericResultNodeVectorT<Int32ResultNode>
 {
 public:
-    Int32ResultNodeVector() { }
+    Int32ResultNodeVector() = default;
     DECLARE_RESULTNODE(Int32ResultNodeVector);
 
     const IntegerBucketResultNode& getNullBucket() const override { return IntegerBucketResultNode::getNull(); }
@@ -347,7 +358,7 @@ public:
 class Int64ResultNodeVector : public NumericResultNodeVectorT<Int64ResultNode>
 {
 public:
-    Int64ResultNodeVector() { }
+    Int64ResultNodeVector() = default;
     DECLARE_RESULTNODE(Int64ResultNodeVector);
 
     const IntegerBucketResultNode& getNullBucket() const override { return IntegerBucketResultNode::getNull(); }
@@ -358,14 +369,14 @@ using IntegerResultNodeVector = Int64ResultNodeVector;
 class EnumResultNodeVector : public NumericResultNodeVectorT<EnumResultNode>
 {
 public:
-    EnumResultNodeVector() {}
+    EnumResultNodeVector() = default;
     DECLARE_RESULTNODE(EnumResultNodeVector);
 };
 
 class FloatResultNodeVector : public NumericResultNodeVectorT<FloatResultNode>
 {
 public:
-    FloatResultNodeVector() { }
+    FloatResultNodeVector() = default;
     DECLARE_RESULTNODE(FloatResultNodeVector);
 
     const FloatBucketResultNode& getNullBucket() const override { return FloatBucketResultNode::getNull(); }
@@ -374,7 +385,7 @@ public:
 class StringResultNodeVector : public ResultNodeVectorT<StringResultNode, cmpT<ResultNode>, vespalib::Identity>
 {
 public:
-    StringResultNodeVector() { }
+    StringResultNodeVector() = default;
     DECLARE_RESULTNODE(StringResultNodeVector);
 
     const StringBucketResultNode& getNullBucket() const override { return StringBucketResultNode::getNull(); }
@@ -383,7 +394,7 @@ public:
 class RawResultNodeVector : public ResultNodeVectorT<RawResultNode, cmpT<ResultNode>, vespalib::Identity>
 {
 public:
-    RawResultNodeVector() { }
+    RawResultNodeVector() = default;
     DECLARE_RESULTNODE(RawResultNodeVector);
 
     const RawBucketResultNode& getNullBucket() const override { return RawBucketResultNode::getNull(); }
@@ -392,28 +403,28 @@ public:
 class IntegerBucketResultNodeVector : public ResultNodeVectorT<IntegerBucketResultNode, contains<IntegerBucketResultNode, int64_t>, GetInteger >
 {
 public:
-    IntegerBucketResultNodeVector() { }
+    IntegerBucketResultNodeVector() = default;
     DECLARE_RESULTNODE(IntegerBucketResultNodeVector);
 };
 
 class FloatBucketResultNodeVector : public ResultNodeVectorT<FloatBucketResultNode, contains<FloatBucketResultNode, double>, GetFloat >
 {
 public:
-    FloatBucketResultNodeVector() { }
+    FloatBucketResultNodeVector() = default;
     DECLARE_RESULTNODE(FloatBucketResultNodeVector);
 };
 
 class StringBucketResultNodeVector : public ResultNodeVectorT<StringBucketResultNode, contains<StringBucketResultNode, ResultNode::ConstBufferRef>, GetString >
 {
 public:
-    StringBucketResultNodeVector() { }
+    StringBucketResultNodeVector() = default;
     DECLARE_RESULTNODE(StringBucketResultNodeVector);
 };
 
 class RawBucketResultNodeVector : public ResultNodeVectorT<RawBucketResultNode, contains<RawBucketResultNode, ResultNode::ConstBufferRef>, GetString >
 {
 public:
-    RawBucketResultNodeVector() { }
+    RawBucketResultNodeVector() = default;
     DECLARE_RESULTNODE(RawBucketResultNodeVector);
 };
 
diff --git a/searchlib/src/vespa/searchlib/expression/unaryfunctionnode.h b/searchlib/src/vespa/searchlib/expression/unaryfunctionnode.h
index 6283204e88b..96e54d78ec9 100644
--- a/searchlib/src/vespa/searchlib/expression/unaryfunctionnode.h
+++ b/searchlib/src/vespa/searchlib/expression/unaryfunctionnode.h
@@ -3,14 +3,13 @@
 
 #include "multiargfunctionnode.h"
 
-namespace search {
-namespace expression {
+namespace search::expression {
 
 class UnaryFunctionNode : public MultiArgFunctionNode
 {
 public:
     DECLARE_ABSTRACT_EXPRESSIONNODE(UnaryFunctionNode);
-    UnaryFunctionNode() { }
+    UnaryFunctionNode() noexcept = default;
     UnaryFunctionNode(ExpressionNode::UP arg) :
         MultiArgFunctionNode()
     {
@@ -23,5 +22,3 @@ private:
 };
 
 }
-}
-