Change from typedef to using in searchlib C++ code.

52 files changed, 276 insertions, 289 deletions

diff --git a/searchlib/src/tests/attribute/attribute_test.cpp b/searchlib/src/tests/attribute/attribute_test.cpp
index a0906e2a488..5c0e2c26bd2 100644
--- a/searchlib/src/tests/attribute/attribute_test.cpp
+++ b/searchlib/src/tests/attribute/attribute_test.cpp
@@ -179,7 +179,7 @@ using attribute::Config;
 class AttributeTest : public ::testing::Test
 {
 protected:
-    typedef AttributeVector::SP AttributePtr;
+    using AttributePtr = AttributeVector::SP;
 
     void addDocs(const AttributePtr & v, size_t sz);
     void addClearedDocs(const AttributePtr & v, size_t sz);
@@ -1303,7 +1303,7 @@ AttributeTest::testArithmeticValueUpdate(const AttributePtr & ptr)
 {
     LOG(info, "testArithmeticValueUpdate: vector '%s'", ptr->getName().c_str());
 
-    typedef document::ArithmeticValueUpdate Arith;
+    using Arith = document::ArithmeticValueUpdate;
     auto & vec = static_cast<VectorType &>(*ptr.get());
     addDocs(ptr, 13);
     EXPECT_EQ(ptr->getStatus().getUpdateCount(), 0u);
@@ -1472,7 +1472,7 @@ AttributeTest::testArithmeticWithUndefinedValue(const AttributePtr & ptr, BaseTy
 {
     LOG(info, "testArithmeticWithUndefinedValue: vector '%s'", ptr->getName().c_str());
 
-    typedef document::ArithmeticValueUpdate Arith;
+    using Arith = document::ArithmeticValueUpdate;
     auto & vec = static_cast<VectorType &>(*ptr.get());
     addDocs(ptr, 1);
     ASSERT_TRUE(vec.update(0, before));
@@ -1519,8 +1519,8 @@ AttributeTest::testMapValueUpdate(const AttributePtr & ptr, BufferType initValue
                                   bool removeIfZero, bool createIfNonExistant)
 {
     LOG(info, "testMapValueUpdate: vector '%s'", ptr->getName().c_str());
-    typedef MapValueUpdate MapVU;
-    typedef ArithmeticValueUpdate ArithVU;
+    using MapVU = MapValueUpdate;
+    using ArithVU = ArithmeticValueUpdate;
     auto & vec = static_cast<VectorType &>(*ptr.get());
 
     addDocs(ptr, 7);
diff --git a/searchlib/src/tests/attribute/attributemanager/attributemanager_test.cpp b/searchlib/src/tests/attribute/attributemanager/attributemanager_test.cpp
index 9b6187bcc77..1d3995bc494 100644
--- a/searchlib/src/tests/attribute/attributemanager/attributemanager_test.cpp
+++ b/searchlib/src/tests/attribute/attributemanager/attributemanager_test.cpp
@@ -183,12 +183,12 @@ assertCollectionType(CollectionType exp, AttributesConfig::Attribute::Collection
 
 TEST("require that config can be converted")
 {
-    typedef BT AVBT;
-    typedef CollectionType AVCT;
+    using AVBT = BT;
+    using AVCT = CollectionType;
     using CACA = AttributesConfig::Attribute;
     using CACAD = CACA::Datatype;
     using CACAC = CACA::Collectiontype;
-    typedef ConfigConverter CC;
+    using CC = ConfigConverter;
 
     EXPECT_TRUE(assertDataType(AVBT::STRING, CACAD::STRING));
     EXPECT_TRUE(assertDataType(AVBT::INT8, CACAD::INT8));
diff --git a/searchlib/src/tests/attribute/benchmark/attributebenchmark.cpp b/searchlib/src/tests/attribute/benchmark/attributebenchmark.cpp
index 39e5d713d08..0b90b4eae95 100644
--- a/searchlib/src/tests/attribute/benchmark/attributebenchmark.cpp
+++ b/searchlib/src/tests/attribute/benchmark/attributebenchmark.cpp
@@ -18,9 +18,9 @@ LOG_SETUP("attributebenchmark");
 
 using std::shared_ptr;
 
-typedef std::vector<uint32_t> NumVector;
-typedef std::vector<vespalib::string> StringVector;
-typedef search::attribute::Config AttrConfig;
+using NumVector = std::vector<uint32_t>;
+using StringVector = std::vector<vespalib::string>;
+using AttrConfig = search::attribute::Config;
 using search::attribute::BasicType;
 using search::attribute::CollectionType;
 
diff --git a/searchlib/src/tests/attribute/benchmark/attributesearcher.h b/searchlib/src/tests/attribute/benchmark/attributesearcher.h
index 43531b48f05..d6e14d6793d 100644
--- a/searchlib/src/tests/attribute/benchmark/attributesearcher.h
+++ b/searchlib/src/tests/attribute/benchmark/attributesearcher.h
@@ -62,7 +62,7 @@ public:
 class AttributeSearcher : public Runnable
 {
 protected:
-    typedef AttributeVector::SP AttributePtr;
+    using AttributePtr = AttributeVector::SP;
 
     const AttributePtr    & _attrPtr;
     vespalib::Timer         _timer;
diff --git a/searchlib/src/tests/attribute/benchmark/attributeupdater.h b/searchlib/src/tests/attribute/benchmark/attributeupdater.h
index e1aea8c7d90..88220a8cfb8 100644
--- a/searchlib/src/tests/attribute/benchmark/attributeupdater.h
+++ b/searchlib/src/tests/attribute/benchmark/attributeupdater.h
@@ -90,8 +90,8 @@ template <typename Vector, typename T, typename BT>
 class AttributeUpdater
 {
 protected:
-    typedef AttributeVector::SP AttributePtr;
-    typedef std::map<uint32_t, std::vector<T> > AttributeCommit;
+    using AttributePtr = AttributeVector::SP;
+    using AttributeCommit = std::map<uint32_t, std::vector<T> >;
 
     const AttributePtr & _attrPtr;
     Vector & _attrVec;
@@ -156,7 +156,7 @@ template <typename Vector, typename T, typename BT>
 class AttributeUpdaterThread : public AttributeUpdater<Vector, T, BT>, public Runnable
 {
 private:
-    typedef AttributeVector::SP AttributePtr;
+    using AttributePtr = AttributeVector::SP;
 
 public:
     AttributeUpdaterThread(const AttributePtr & attrPtr, const std::vector<T> & values,
diff --git a/searchlib/src/tests/attribute/bitvector/bitvector_test.cpp b/searchlib/src/tests/attribute/bitvector/bitvector_test.cpp
index 7cfe7eaab75..6e622c840b6 100644
--- a/searchlib/src/tests/attribute/bitvector/bitvector_test.cpp
+++ b/searchlib/src/tests/attribute/bitvector/bitvector_test.cpp
@@ -37,11 +37,11 @@ using search::fef::TermFieldMatchData;
 using search::queryeval::SearchIterator;
 
 using SearchContextPtr = std::unique_ptr<SearchContext>;
-typedef std::unique_ptr<search::queryeval::SearchIterator> SearchBasePtr;
+using SearchBasePtr = std::unique_ptr<search::queryeval::SearchIterator>;
 
 struct BitVectorTest
 {
-    typedef AttributeVector::SP AttributePtr;
+    using AttributePtr = AttributeVector::SP;
 
     BitVectorTest() { }
 
@@ -477,8 +477,8 @@ BitVectorTest::test(BasicType bt,
     if (dwa != nullptr) {
         search::IDocumentWeightAttribute::LookupResult lres = 
             dwa->lookup(getSearchStr<VectorType>(), dwa->get_dictionary_snapshot());
-        typedef search::queryeval::DocumentWeightSearchIterator DWSI;
-        typedef search::queryeval::SearchIterator SI;
+        using DWSI = search::queryeval::DocumentWeightSearchIterator;
+        using SI = search::queryeval::SearchIterator;
         TermFieldMatchData md;
         SI::UP dwsi(new DWSI(md, *dwa, lres));
         if (!enableOnlyBitVector) {
diff --git a/searchlib/src/tests/attribute/enumeratedsave/enumeratedsave_test.cpp b/searchlib/src/tests/attribute/enumeratedsave/enumeratedsave_test.cpp
index 90127e9ae7b..820f39089d1 100644
--- a/searchlib/src/tests/attribute/enumeratedsave/enumeratedsave_test.cpp
+++ b/searchlib/src/tests/attribute/enumeratedsave/enumeratedsave_test.cpp
@@ -44,7 +44,7 @@ using search::attribute::SearchContextParams;
 using search::fef::TermFieldMatchData;
 
 using SearchContextPtr = std::unique_ptr<SearchContext>;
-typedef std::unique_ptr<search::queryeval::SearchIterator> SearchBasePtr;
+using SearchBasePtr = std::unique_ptr<search::queryeval::SearchIterator>;
 
 
 class MemAttrFileWriter : public IAttributeFileWriter
@@ -93,7 +93,7 @@ private:
     MemAttrFileWriter _udatWriter;
 
 public:
-    typedef std::shared_ptr<MemAttr> SP;
+    using SP = std::shared_ptr<MemAttr>;
 
     MemAttr();
     ~MemAttr() override;
@@ -129,7 +129,7 @@ MemAttr::~MemAttr() = default;
 class EnumeratedSaveTest
 {
 private:
-    typedef AttributeVector::SP AttributePtr;
+    using AttributePtr = AttributeVector::SP;
 
     template <typename VectorType>
     VectorType & as(AttributePtr &v);
@@ -623,9 +623,7 @@ EnumeratedSaveTest::testReload(AttributePtr v0,
                                bool fastSearch,
                                search::DictionaryConfig dictionary_config)
 {
-    // typedef AttributePtr AVP;
-
-    bool flagAttr = 
+    bool flagAttr =
         cfg.collectionType() == CollectionType::ARRAY &&
         cfg.basicType() == BasicType::INT8 &&
         fastSearch;
diff --git a/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp b/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp
index 2f60d64ec37..22584db7dd9 100644
--- a/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp
+++ b/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp
@@ -109,9 +109,9 @@ struct StringEntry {
 };
 
 struct Reader {
-    typedef StringEnumStore::Index Index;
-    typedef std::vector<Index> IndexVector;
-    typedef std::vector<StringEntry> ExpectedVector;
+    using Index = StringEnumStore::Index;
+    using IndexVector = std::vector<Index>;
+    using ExpectedVector = std::vector<StringEntry>;
     uint32_t _generation;
     IndexVector _indices;
     ExpectedVector _expected;
diff --git a/searchlib/src/tests/attribute/postinglist/postinglist.cpp b/searchlib/src/tests/attribute/postinglist/postinglist.cpp
index 1eed3a015e1..3f07faa159f 100644
--- a/searchlib/src/tests/attribute/postinglist/postinglist.cpp
+++ b/searchlib/src/tests/attribute/postinglist/postinglist.cpp
@@ -27,8 +27,8 @@ class AttributePostingListTest : public vespalib::TestApp
 {
 private:
     /* Limited STL version for validation of full version */
-    typedef std::set<uint32_t> STLPostingList;
-    typedef std::map<int, STLPostingList> STLValueTree;
+    using STLPostingList = std::set<uint32_t>;
+    using STLValueTree = std::map<int, STLPostingList>;
 
     class RandomValue
     {
@@ -96,18 +96,16 @@ private:
     std::vector<RandomValue> _randomValues;
 
 public:
-    typedef vespalib::datastore::DataStore<int> IntKeyStore;
-    typedef vespalib::btree::BTreeKeyData<uint32_t, vespalib::btree::BTreeNoLeafData>
-    AttributePosting;
-    typedef vespalib::btree::BTreeStore<uint32_t,
+    using IntKeyStore = vespalib::datastore::DataStore<int>;
+    using AttributePosting = vespalib::btree::BTreeKeyData<uint32_t, vespalib::btree::BTreeNoLeafData>;
+    using PostingList = vespalib::btree::BTreeStore<uint32_t,
                               vespalib::btree::BTreeNoLeafData,
                               vespalib::btree::NoAggregated,
                               std::less<uint32_t>,
-                              vespalib::btree::BTreeDefaultTraits>
-    PostingList;
-    typedef PostingList::NodeAllocatorType PostingListNodeAllocator;
-    typedef vespalib::datastore::EntryRef PostingIdx;
-    typedef vespalib::datastore::EntryRef StoreIndex;
+                              vespalib::btree::BTreeDefaultTraits>;
+    using PostingListNodeAllocator = PostingList::NodeAllocatorType;
+    using PostingIdx = vespalib::datastore::EntryRef;
+    using StoreIndex = vespalib::datastore::EntryRef;
 
     class IntComp {
     private:
@@ -127,14 +125,14 @@ public:
         }
     };
 
-    typedef vespalib::btree::BTreeRoot<StoreIndex, PostingIdx,
+    using IntEnumTree = vespalib::btree::BTreeRoot<StoreIndex, PostingIdx,
                              vespalib::btree::NoAggregated,
-                             const IntComp &> IntEnumTree;
-    typedef IntEnumTree::NodeAllocatorType IntEnumNodeAllocator;
-    typedef IntEnumTree Tree;
-    typedef IntEnumNodeAllocator TreeManager;
-    typedef IntKeyStore ValueHandle;
-    typedef std::vector<RandomValue> RandomValuesVector;
+                             const IntComp &>;
+    using IntEnumNodeAllocator = IntEnumTree::NodeAllocatorType;
+    using Tree = IntEnumTree;
+    using TreeManager = IntEnumNodeAllocator;
+    using ValueHandle = IntKeyStore;
+    using RandomValuesVector = std::vector<RandomValue>;
 private:
     GenerationHandler _handler;
     IntKeyStore *_intKeyStore;
@@ -607,7 +605,7 @@ AttributePostingListTest::doCompactEnumStore(Tree &tree,
         std::atomic_thread_fence(std::memory_order_release);
         i.writeKey(nv);
     }
-    typedef GenerationHandler::generation_t generation_t;
+    using generation_t = GenerationHandler::generation_t;
     for (std::vector<uint32_t>::const_iterator
              it = toHold.begin(), ite = toHold.end(); it != ite; ++it) {
         valueHandle.holdBuffer(*it);
diff --git a/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp b/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp
index 5ce20c06ab5..00e2a82d24e 100644
--- a/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp
+++ b/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp
@@ -51,7 +51,7 @@ using search::fef::TermFieldMatchData;
 using search::queryeval::SearchIterator;
 
 using SearchContextPtr = std::unique_ptr<SearchContext>;
-typedef std::unique_ptr<search::queryeval::SearchIterator> SearchBasePtr;
+using SearchBasePtr = std::unique_ptr<search::queryeval::SearchIterator>;
 
 void
 toStr(std::stringstream &ss, SearchIterator &it, TermFieldMatchData *md)
@@ -91,36 +91,30 @@ using AttributePtr = AttributeVector::SP;
 class PostingListAttributeTest : public ::testing::Test
 {
 protected:
-    typedef IntegerAttribute::largeint_t     largeint_t;
-    typedef std::set<AttributeVector::DocId> DocSet;
+    using largeint_t = IntegerAttribute::largeint_t;
+    using DocSet = std::set<AttributeVector::DocId>;
 
-    typedef SingleValueNumericPostingAttribute<
-        EnumAttribute<IntegerAttributeTemplate<int32_t> > >
-    Int32PostingListAttribute;
-    typedef MultiValueNumericPostingAttribute<
+    using Int32PostingListAttribute = SingleValueNumericPostingAttribute<
+        EnumAttribute<IntegerAttributeTemplate<int32_t> > >;
+    using Int32ArrayPostingListAttribute = MultiValueNumericPostingAttribute<
         EnumAttribute<IntegerAttributeTemplate<int32_t> >,
-        IEnumStore::AtomicIndex>
-    Int32ArrayPostingListAttribute;
-    typedef MultiValueNumericPostingAttribute<
+        IEnumStore::AtomicIndex>;
+    using Int32WsetPostingListAttribute = MultiValueNumericPostingAttribute<
         EnumAttribute<IntegerAttributeTemplate<int32_t> >,
-        multivalue::WeightedValue<IEnumStore::AtomicIndex> >
-    Int32WsetPostingListAttribute;
+        multivalue::WeightedValue<IEnumStore::AtomicIndex> >;
 
-    typedef SingleValueNumericPostingAttribute<
-        EnumAttribute<FloatingPointAttributeTemplate<float> > >
-    FloatPostingListAttribute;
-    typedef MultiValueNumericPostingAttribute<
+    using FloatPostingListAttribute = SingleValueNumericPostingAttribute<
+        EnumAttribute<FloatingPointAttributeTemplate<float> > >;
+    using FloatArrayPostingListAttribute = MultiValueNumericPostingAttribute<
         EnumAttribute<FloatingPointAttributeTemplate<float> >,
-        IEnumStore::AtomicIndex>
-    FloatArrayPostingListAttribute;
-    typedef MultiValueNumericPostingAttribute<
+        IEnumStore::AtomicIndex>;
+    using FloatWsetPostingListAttribute = MultiValueNumericPostingAttribute<
         EnumAttribute<FloatingPointAttributeTemplate<float> >,
-        multivalue::WeightedValue<IEnumStore::AtomicIndex> >
-    FloatWsetPostingListAttribute;
+        multivalue::WeightedValue<IEnumStore::AtomicIndex> >;
 
-    typedef SingleValueStringPostingAttribute StringPostingListAttribute;
-    typedef ArrayStringPostingAttribute StringArrayPostingListAttribute;
-    typedef WeightedSetStringPostingAttribute StringWsetPostingListAttribute;
+    using StringPostingListAttribute = SingleValueStringPostingAttribute;
+    using StringArrayPostingListAttribute = ArrayStringPostingAttribute;
+    using StringWsetPostingListAttribute = WeightedSetStringPostingAttribute;
 
     template <typename VectorType>
     void populate(VectorType &v);
@@ -737,7 +731,7 @@ PostingListAttributeTest::testArithmeticValueUpdate(const AttributePtr & ptr)
 {
     LOG(info, "testArithmeticValueUpdate: vector '%s'", ptr->getName().c_str());
 
-    typedef document::ArithmeticValueUpdate Arith;
+    using Arith = document::ArithmeticValueUpdate;
     AttributeType & vec = static_cast<AttributeType &>(*ptr.get());
 
     addDocs(ptr, 4);
diff --git a/searchlib/src/tests/attribute/searchable/attribute_searchable_adapter_test.cpp b/searchlib/src/tests/attribute/searchable/attribute_searchable_adapter_test.cpp
index 6df60f2ac4c..41216b750d1 100644
--- a/searchlib/src/tests/attribute/searchable/attribute_searchable_adapter_test.cpp
+++ b/searchlib/src/tests/attribute/searchable/attribute_searchable_adapter_test.cpp
@@ -264,14 +264,14 @@ bool search(const string &term, IAttributeManager &attribute_manager,
 }
 
 template <typename T> struct AttributeVectorTypeFinder {
-    typedef search::SingleValueStringAttribute Type;
+    using Type = search::SingleValueStringAttribute;
     static void add(Type & a, const T & v) {
         a.update(a.getNumDocs()-1, v);
         a.commit();
     }
 };
 template <> struct AttributeVectorTypeFinder<int64_t> {
-    typedef search::SingleValueNumericAttribute<search::IntegerAttributeTemplate<int64_t> > Type;
+    using Type = search::SingleValueNumericAttribute<search::IntegerAttributeTemplate<int64_t> >;
     static void add(Type & a, int64_t v) { a.set(a.getNumDocs()-1, v); a.commit(); }
 };
 
@@ -288,8 +288,8 @@ void add_docs(AttributeVector *attr, size_t n) {
 
 template <typename T>
 MyAttributeManager makeAttributeManager(T value) {
-    typedef AttributeVectorTypeFinder<T> AT;
-    typedef typename AT::Type AttributeVectorType;
+    using AT = AttributeVectorTypeFinder<T>;
+    using AttributeVectorType = typename AT::Type;
     AttributeVectorType *attr = new AttributeVectorType(field);
     add_docs(attr, num_docs);
     AT::add(*attr, value);
diff --git a/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp b/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp
index 54db8feee93..40d4b20aaf2 100644
--- a/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp
+++ b/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp
@@ -127,7 +127,7 @@ public:
     template <typename V, typename T>
     static SearchContextPtr getSearch(const V & vec, const T & term, TermType termType=TermType::WORD);
 private:
-    typedef std::map<vespalib::string, Config> ConfigMap;
+    using ConfigMap = std::map<vespalib::string, Config>;
     // Map of all config objects
     ConfigMap _integerCfg;
     ConfigMap _floatCfg;
diff --git a/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp b/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
index 2289000a273..4bcba209c13 100644
--- a/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
+++ b/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
@@ -20,12 +20,12 @@ using search::attribute::StringSearchHelper;
 using vespalib::datastore::EntryRef;
 using namespace search;
 
-typedef ArrayStringAttribute ArrayStr;
-typedef WeightedSetStringAttribute WeightedSetStr;
-typedef ArrayStringPostingAttribute ArrayStrPosting;
-typedef WeightedSetStringPostingAttribute WeightedSetStrPosting;
-typedef attribute::Config Config;
-typedef attribute::BasicType BasicType;
+using ArrayStr = ArrayStringAttribute;
+using WeightedSetStr = WeightedSetStringAttribute;
+using ArrayStrPosting = ArrayStringPostingAttribute;
+using WeightedSetStrPosting = WeightedSetStringPostingAttribute;
+using Config = attribute::Config;
+using BasicType = attribute::BasicType;
 
 template <typename Attribute>
 void
diff --git a/searchlib/src/tests/bitvector/bitvectorbenchmark.cpp b/searchlib/src/tests/bitvector/bitvectorbenchmark.cpp
index 26b0ccff656..266241adf59 100644
--- a/searchlib/src/tests/bitvector/bitvectorbenchmark.cpp
+++ b/searchlib/src/tests/bitvector/bitvectorbenchmark.cpp
@@ -152,7 +152,7 @@ BitVectorBenchmark::testCountSpeed3()
 
 void BitVectorBenchmark::testOrSpeed2()
 {
-    typedef uint64_t T;
+    using T = uint64_t;
     T * a = reinterpret_cast<T *>(_bv[0]->getStart());
     const T * b = reinterpret_cast<const T *>(_bv[1]->getStart());
     size_t sz = _bv[0]->size()/(8*sizeof(*a));
diff --git a/searchlib/src/tests/diskindex/fusion/fusion_test.cpp b/searchlib/src/tests/diskindex/fusion/fusion_test.cpp
index b3d8e46cb3a..272d74cde2c 100644
--- a/searchlib/src/tests/diskindex/fusion/fusion_test.cpp
+++ b/searchlib/src/tests/diskindex/fusion/fusion_test.cpp
@@ -184,9 +184,9 @@ assert_interleaved_features(DiskIndex &d, const vespalib::string &field, const v
 void
 validateDiskIndex(DiskIndex &dw, bool f2HasElements, bool f3HasWeights)
 {
-    typedef DiskIndex::LookupResult LR;
-    typedef index::PostingListHandle PH;
-    typedef search::queryeval::SearchIterator SB;
+    using LR = DiskIndex::LookupResult;
+    using PH = index::PostingListHandle;
+    using SB = search::queryeval::SearchIterator;
 
     const Schema &schema(dw.getSchema());
 
@@ -385,7 +385,7 @@ FusionTest::requireThatFusionIsWorking(const vespalib::string &prefix, bool dire
     ib.close();
 
     vespalib::string tsName = dump2dir + "/.teststamp";
-    typedef search::FileKit FileKit;
+    using FileKit = search::FileKit;
     ASSERT_TRUE(FileKit::createStamp(tsName));
     ASSERT_TRUE(FileKit::hasStamp(tsName));
     ASSERT_TRUE(FileKit::removeStamp(tsName));
diff --git a/searchlib/src/tests/features/beta/beta_features.cpp b/searchlib/src/tests/features/beta/beta_features.cpp
index f3a134f39e3..f31b27c58fa 100644
--- a/searchlib/src/tests/features/beta/beta_features.cpp
+++ b/searchlib/src/tests/features/beta/beta_features.cpp
@@ -42,7 +42,7 @@ using CollectionType = FieldInfo::CollectionType;
 //---------------------------------------------------------------------------------------------------------------------
 // TermPositionList
 //---------------------------------------------------------------------------------------------------------------------
-typedef std::pair<uint32_t, uint32_t> TermPosition;
+using TermPosition = std::pair<uint32_t, uint32_t>;
 class TermPositionList : public std::vector<TermPosition> {
 public:
     TermPositionList &add(uint32_t termId, uint32_t pos) {
diff --git a/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp b/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp
index eed59fdde5e..1a9a602020c 100644
--- a/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp
+++ b/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp
@@ -21,11 +21,11 @@ using search::AttributeFactory;
 using search::IntegerAttribute;
 using search::FloatingPointAttribute;
 
-typedef search::attribute::Config AVC;
-typedef search::attribute::BasicType AVBT;
-typedef search::attribute::CollectionType AVCT;
-typedef search::AttributeVector::SP AttributePtr;
-typedef FtTestApp FTA;
+using AVC = search::attribute::Config;
+using AVBT = search::attribute::BasicType;
+using AVCT = search::attribute::CollectionType;
+using AttributePtr = search::AttributeVector::SP;
+using FTA = FtTestApp;
 using CollectionType = FieldInfo::CollectionType;
 
 struct SetupFixture
diff --git a/searchlib/src/tests/features/featurebenchmark.cpp b/searchlib/src/tests/features/featurebenchmark.cpp
index a3188ce21fa..5f4255d4cb4 100644
--- a/searchlib/src/tests/features/featurebenchmark.cpp
+++ b/searchlib/src/tests/features/featurebenchmark.cpp
@@ -29,21 +29,21 @@ using search::AttributeFactory;
 using search::IntegerAttribute;
 using search::StringAttribute;
 
-typedef search::attribute::Config           AVC;
-typedef search::attribute::BasicType        AVBT;
-typedef search::attribute::CollectionType AVCT;
+using AVC = search::attribute::Config;
+using AVBT = search::attribute::BasicType;
+using AVCT = search::attribute::CollectionType;
 
-typedef AttributeVector::SP             AttributePtr;
+using AttributePtr = AttributeVector::SP;
 
 using CollectionType = FieldInfo::CollectionType;
 
 class Benchmark : public FtTestApp {
 public:
-    typedef std::vector<std::pair<vespalib::string, vespalib::string> > KeyValueVector;
+    using KeyValueVector = std::vector<std::pair<vespalib::string, vespalib::string> >;
 
     class Config {
     private:
-        typedef std::map<vespalib::string, vespalib::string> StringMap;
+        using StringMap = std::map<vespalib::string, vespalib::string>;
         StringMap _config;
 
         bool isKnown(const vespalib::string & key) const;
diff --git a/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp b/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp
index 532f646ae4d..4067d5b6125 100644
--- a/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp
+++ b/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp
@@ -18,11 +18,11 @@ using search::FloatingPointAttribute;
 using CollectionType = FieldInfo::CollectionType;
 using DataType = FieldInfo::DataType;
 
-typedef search::attribute::Config AVC;
-typedef search::attribute::BasicType AVBT;
-typedef search::attribute::CollectionType AVCT;
-typedef search::AttributeVector::SP AttributePtr;
-typedef FtTestApp FTA;
+using AVC = search::attribute::Config;
+using AVBT = search::attribute::BasicType;
+using AVCT = search::attribute::CollectionType;
+using AttributePtr = search::AttributeVector::SP;
+using FTA = FtTestApp;
 
 struct SetupFixture
 {
diff --git a/searchlib/src/tests/features/prod_features.cpp b/searchlib/src/tests/features/prod_features.cpp
index 73b66f36172..03563196379 100644
--- a/searchlib/src/tests/features/prod_features.cpp
+++ b/searchlib/src/tests/features/prod_features.cpp
@@ -2037,7 +2037,7 @@ Test::testRankingExpression()
 vespalib::string
 Test::getExpression(const vespalib::string &parameter) const
 {
-    typedef search::fef::FeatureNameBuilder FNB;
+    using FNB = search::fef::FeatureNameBuilder;
     return FNB().baseName("rankingExpression").parameter(parameter).buildName();
 }
 
@@ -2148,7 +2148,7 @@ Test::testTermDistance()
     }
 
     { // test executor
-        typedef TermDistanceCalculator::Result Result;
+        using Result = TermDistanceCalculator::Result;
         const uint32_t UV = TermDistanceCalculator::UNDEFINED_VALUE;
 
         EXPECT_TRUE(assertTermDistance(Result(), "a b", "x x"));
diff --git a/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp b/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp
index b2143bacfd9..3eb5306277d 100644
--- a/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp
+++ b/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp
@@ -29,11 +29,11 @@ using vespalib::eval::Function;
 using vespalib::eval::TensorSpec;
 using vespalib::eval::SimpleValue;
 
-typedef search::attribute::Config AVC;
-typedef search::attribute::BasicType AVBT;
-typedef search::attribute::CollectionType AVCT;
-typedef search::AttributeVector::SP AttributePtr;
-typedef FtTestApp FTA;
+using AVC = search::attribute::Config;
+using AVBT = search::attribute::BasicType;
+using AVCT = search::attribute::CollectionType;
+using AttributePtr = search::AttributeVector::SP;
+using FTA = FtTestApp;
 
 Value::UP make_tensor(const TensorSpec &spec) {
     return SimpleValue::from_spec(spec);
diff --git a/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp b/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
index e832812a2e1..4e3a289592f 100644
--- a/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
+++ b/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
@@ -29,11 +29,11 @@ using vespalib::eval::Function;
 using vespalib::eval::TensorSpec;
 using vespalib::eval::SimpleValue;
 
-typedef search::attribute::Config AVC;
-typedef search::attribute::BasicType AVBT;
-typedef search::attribute::CollectionType AVCT;
-typedef search::AttributeVector::SP AttributePtr;
-typedef FtTestApp FTA;
+using AVC = search::attribute::Config;
+using AVBT = search::attribute::BasicType;
+using AVCT = search::attribute::CollectionType;
+using AttributePtr = search::AttributeVector::SP;
+using FTA = FtTestApp;
 
 Value::UP make_tensor(const TensorSpec &spec) {
     return SimpleValue::from_spec(spec);
diff --git a/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp b/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp
index 08ae2701eb9..af4ea97808d 100644
--- a/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp
+++ b/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp
@@ -25,7 +25,7 @@ public:
 void
 Test::testWriteAndRead()
 {
-    typedef search::attribute::AttributeContent<uint32_t> UintContent;
+    using UintContent = search::attribute::AttributeContent<uint32_t>;
     UintContent buf;
     EXPECT_EQUAL(buf.capacity(), 16u);
     EXPECT_EQUAL(buf.size(), 0u);
diff --git a/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp b/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp
index f52881fa327..0738c1b4a37 100644
--- a/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp
+++ b/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp
@@ -6,7 +6,7 @@ LOG_SETUP("featurenamebuilder_test");
 
 using namespace search::fef;
 
-typedef FeatureNameBuilder B;
+using B = FeatureNameBuilder;
 
 TEST_SETUP(Test);
 
diff --git a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
index b95478072de..90ee5519cc4 100644
--- a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
+++ b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
@@ -25,7 +25,7 @@ using vespalib::eval::FastValueBuilderFactory;
 using vespalib::make_string_short::fmt;
 
 
-typedef Blueprint::SP       BPSP;
+using BPSP = Blueprint::SP;
 
 struct Fixture
 {
diff --git a/searchlib/src/tests/fef/parameter/parameter_test.cpp b/searchlib/src/tests/fef/parameter/parameter_test.cpp
index 6bce9fec8ff..2aa6d213fa5 100644
--- a/searchlib/src/tests/fef/parameter/parameter_test.cpp
+++ b/searchlib/src/tests/fef/parameter/parameter_test.cpp
@@ -21,11 +21,11 @@ public:
 
 class ParameterTest : public vespalib::TestApp {
 private:
-    typedef ParameterDescriptions PDS;
-    typedef ParameterType PT;
-    typedef Parameter P;
-    typedef StringList SL;
-    typedef ParameterValidator::Result PVR;
+    using PDS = ParameterDescriptions;
+    using PT = ParameterType;
+    using P = Parameter;
+    using SL = StringList;
+    using PVR = ParameterValidator::Result;
 
     bool assertParameter(const Parameter & exp, const Parameter & act);
     bool validate(const IIndexEnvironment & env,
diff --git a/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp b/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp
index f42ff600f78..54a7d6ea286 100644
--- a/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp
+++ b/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp
@@ -43,8 +43,8 @@ void testSetup(State &state) {
     state.term.addField(7); // docfreq = 2
     state.term.addField(5); // docfreq = 3
 
-    typedef search::fef::ITermFieldRangeAdapter FRA;
-    typedef search::fef::SimpleTermFieldRangeAdapter SFR;
+    using FRA = search::fef::ITermFieldRangeAdapter;
+    using SFR = search::fef::SimpleTermFieldRangeAdapter;
 
     // lookup terms
     {
diff --git a/searchlib/src/tests/fef/termmatchdatamerger/termmatchdatamerger_test.cpp b/searchlib/src/tests/fef/termmatchdatamerger/termmatchdatamerger_test.cpp
index 4618a29cf49..58389f8f1a8 100644
--- a/searchlib/src/tests/fef/termmatchdatamerger/termmatchdatamerger_test.cpp
+++ b/searchlib/src/tests/fef/termmatchdatamerger/termmatchdatamerger_test.cpp
@@ -6,8 +6,8 @@
 
 using namespace search::fef;
 
-typedef TermMatchDataMerger::Input MDMI;
-typedef TermMatchDataMerger::Inputs MDMIs;
+using MDMI = TermMatchDataMerger::Input;
+using MDMIs = TermMatchDataMerger::Inputs;
 
 namespace {
 
diff --git a/searchlib/src/tests/grouping/grouping_test.cpp b/searchlib/src/tests/grouping/grouping_test.cpp
index 2eab66cb3b7..adf4320ede3 100644
--- a/searchlib/src/tests/grouping/grouping_test.cpp
+++ b/searchlib/src/tests/grouping/grouping_test.cpp
@@ -83,9 +83,9 @@ public:
     }
 };
 
-typedef AttrBuilder<SingleIntegerExtAttribute, int64_t> IntAttrBuilder;
-typedef AttrBuilder<SingleFloatExtAttribute, double> FloatAttrBuilder;
-typedef AttrBuilder<SingleStringExtAttribute, const char *> StringAttrBuilder;
+using IntAttrBuilder = AttrBuilder<SingleIntegerExtAttribute, int64_t>;
+using FloatAttrBuilder = AttrBuilder<SingleFloatExtAttribute, double>;
+using StringAttrBuilder = AttrBuilder<SingleStringExtAttribute, const char *>;
 
 using StringArrayAttrBuilder = AttrBuilder<MultiStringExtAttribute, const char *>;
 using IntArrayAttrBuilder = AttrBuilder<MultiIntegerExtAttribute, int64_t>;
@@ -1825,10 +1825,10 @@ Test::checkBucket(const NumericResultNode &width, const NumericResultNode &value
 void
 Test::testFixedWidthBuckets()
 {
-    typedef Int64ResultNode       Int;
-    typedef FloatResultNode         Float;
-    typedef IntegerBucketResultNode IntBucket;
-    typedef FloatBucketResultNode   FloatBucket;
+    using Int = Int64ResultNode;
+    using Float = FloatResultNode;
+    using IntBucket = IntegerBucketResultNode;
+    using FloatBucket = FloatBucketResultNode;
 
     // positive int buckets
     EXPECT_TRUE(checkBucket(Int(10), Int(0),   IntBucket(0,10)));
diff --git a/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp b/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
index e82079073e7..cd2f4a58552 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
@@ -69,9 +69,9 @@ public:
     }
 };
 
-typedef AttrBuilder<SingleIntegerExtAttribute, int64_t> IntAttrBuilder;
-typedef AttrBuilder<SingleFloatExtAttribute, double> FloatAttrBuilder;
-typedef AttrBuilder<SingleStringExtAttribute, const char *> StringAttrBuilder;
+using IntAttrBuilder = AttrBuilder<SingleIntegerExtAttribute, int64_t>;
+using FloatAttrBuilder = AttrBuilder<SingleFloatExtAttribute, double>;
+using StringAttrBuilder = AttrBuilder<SingleStringExtAttribute, const char *>;
 
 //-----------------------------------------------------------------------------
 
diff --git a/searchlib/src/tests/groupingengine/groupingengine_test.cpp b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
index d54b68388e4..6e5a7e895dd 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_test.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
@@ -68,9 +68,9 @@ public:
     }
 };
 
-typedef AttrBuilder<SingleIntegerExtAttribute, int64_t> IntAttrBuilder;
-typedef AttrBuilder<SingleFloatExtAttribute, double> FloatAttrBuilder;
-typedef AttrBuilder<SingleStringExtAttribute, const char *> StringAttrBuilder;
+using IntAttrBuilder = AttrBuilder<SingleIntegerExtAttribute, int64_t>;
+using FloatAttrBuilder = AttrBuilder<SingleFloatExtAttribute, double>;
+using StringAttrBuilder = AttrBuilder<SingleStringExtAttribute, const char *>;
 
 //-----------------------------------------------------------------------------
 
@@ -1823,10 +1823,10 @@ Test::checkBucket(const NumericResultNode &width, const NumericResultNode &value
 void
 Test::testFixedWidthBuckets()
 {
-    typedef Int64ResultNode       Int;
-    typedef FloatResultNode         Float;
-    typedef IntegerBucketResultNode IntBucket;
-    typedef FloatBucketResultNode   FloatBucket;
+    using Int = Int64ResultNode;
+    using Float = FloatResultNode;
+    using IntBucket = IntegerBucketResultNode;
+    using FloatBucket = FloatBucketResultNode;
 
     // positive int buckets
     EXPECT_TRUE(checkBucket(Int(10), Int(0),   IntBucket(0,10)));
diff --git a/searchlib/src/tests/hitcollector/hitcollector_test.cpp b/searchlib/src/tests/hitcollector/hitcollector_test.cpp
index f02fdbea3bc..b4c015070db 100644
--- a/searchlib/src/tests/hitcollector/hitcollector_test.cpp
+++ b/searchlib/src/tests/hitcollector/hitcollector_test.cpp
@@ -12,7 +12,7 @@ using namespace search;
 using namespace search::fef;
 using namespace search::queryeval;
 
-typedef std::map<uint32_t, feature_t> ScoreMap;
+using ScoreMap = std::map<uint32_t, feature_t>;
 
 using Ranges = std::pair<Scores, Scores>;
 
diff --git a/searchlib/src/tests/indexmetainfo/indexmetainfo_test.cpp b/searchlib/src/tests/indexmetainfo/indexmetainfo_test.cpp
index 93ad6c75a1b..256ef80343f 100644
--- a/searchlib/src/tests/indexmetainfo/indexmetainfo_test.cpp
+++ b/searchlib/src/tests/indexmetainfo/indexmetainfo_test.cpp
@@ -6,7 +6,7 @@
 
 using search::IndexMetaInfo;
 
-typedef IndexMetaInfo::Snapshot Snap;
+using Snap = IndexMetaInfo::Snapshot;
 
 TEST_SETUP(Test)
 
diff --git a/searchlib/src/tests/predicate/predicate_tree_analyzer_test.cpp b/searchlib/src/tests/predicate/predicate_tree_analyzer_test.cpp
index b004c2c5c42..e8508b0292a 100644
--- a/searchlib/src/tests/predicate/predicate_tree_analyzer_test.cpp
+++ b/searchlib/src/tests/predicate/predicate_tree_analyzer_test.cpp
@@ -19,7 +19,7 @@ using std::map;
 using std::string;
 
 namespace {
-typedef PredicateSlimeBuilder Builder;
+using Builder = PredicateSlimeBuilder;
 
 TEST("require that minfeature is 1 for simple term") {
     auto slime(Builder().feature("foo").value("bar").build());
diff --git a/searchlib/src/tests/query/customtypevisitor_test.cpp b/searchlib/src/tests/query/customtypevisitor_test.cpp
index b1e979b5bcb..86288fda498 100644
--- a/searchlib/src/tests/query/customtypevisitor_test.cpp
+++ b/searchlib/src/tests/query/customtypevisitor_test.cpp
@@ -50,32 +50,32 @@ struct MyTrue : TrueQueryNode {};
 struct MyFalse : FalseQueryNode {};
 
 struct MyQueryNodeTypes {
-    typedef MyAnd And;
-    typedef MyAndNot AndNot;
-    typedef MyEquiv Equiv;
-    typedef MyNumberTerm NumberTerm;
-    typedef MyLocationTerm LocationTerm;
-    typedef MyNear Near;
-    typedef MyONear ONear;
-    typedef MyOr Or;
-    typedef MyPhrase Phrase;
-    typedef MySameElement SameElement;
-    typedef MyPrefixTerm PrefixTerm;
-    typedef MyRangeTerm RangeTerm;
-    typedef MyRank Rank;
-    typedef MyStringTerm StringTerm;
-    typedef MySubstrTerm SubstringTerm;
-    typedef MySuffixTerm SuffixTerm;
-    typedef MyFuzzyTerm FuzzyTerm;
-    typedef MyWeakAnd WeakAnd;
-    typedef MyWeightedSetTerm WeightedSetTerm;
-    typedef MyDotProduct DotProduct;
-    typedef MyWandTerm WandTerm;
-    typedef MyPredicateQuery PredicateQuery;
-    typedef MyRegExpTerm RegExpTerm;
-    typedef MyNearestNeighborTerm NearestNeighborTerm;
-    typedef MyFalse FalseQueryNode;
-    typedef MyTrue TrueQueryNode;
+    using And = MyAnd;
+    using AndNot = MyAndNot;
+    using Equiv = MyEquiv;
+    using NumberTerm = MyNumberTerm;
+    using LocationTerm = MyLocationTerm;
+    using Near = MyNear;
+    using ONear = MyONear;
+    using Or = MyOr;
+    using Phrase = MyPhrase;
+    using SameElement = MySameElement;
+    using PrefixTerm = MyPrefixTerm;
+    using RangeTerm = MyRangeTerm;
+    using Rank = MyRank;
+    using StringTerm = MyStringTerm;
+    using SubstringTerm = MySubstrTerm;
+    using SuffixTerm = MySuffixTerm;
+    using FuzzyTerm = MyFuzzyTerm;
+    using WeakAnd = MyWeakAnd;
+    using WeightedSetTerm = MyWeightedSetTerm;
+    using DotProduct = MyDotProduct;
+    using WandTerm = MyWandTerm;
+    using PredicateQuery = MyPredicateQuery;
+    using RegExpTerm = MyRegExpTerm;
+    using NearestNeighborTerm = MyNearestNeighborTerm;
+    using FalseQueryNode = MyFalse;
+    using TrueQueryNode = MyTrue;
 };
 
 class MyCustomVisitor : public CustomTypeVisitor<MyQueryNodeTypes>
diff --git a/searchlib/src/tests/query/querybuilder_test.cpp b/searchlib/src/tests/query/querybuilder_test.cpp
index aad632fdb70..32285918826 100644
--- a/searchlib/src/tests/query/querybuilder_test.cpp
+++ b/searchlib/src/tests/query/querybuilder_test.cpp
@@ -174,31 +174,28 @@ as_node(Node* node)
 
 template <class NodeTypes>
 void checkQueryTreeTypes(Node *node) {
-    typedef typename NodeTypes::And And;
-    typedef typename NodeTypes::AndNot AndNot;
-    typedef typename NodeTypes::NumberTerm NumberTerm;
-    //typedef typename NodeTypes::NumberTerm FloatTrm;
-    typedef typename NodeTypes::Near Near;
-    typedef typename NodeTypes::ONear ONear;
-    typedef typename NodeTypes::SameElement SameElement;
-    typedef typename NodeTypes::Or Or;
-    typedef typename NodeTypes::Phrase Phrase;
-    typedef typename NodeTypes::PrefixTerm PrefixTerm;
-    typedef typename NodeTypes::RangeTerm RangeTerm;
-    typedef typename NodeTypes::Rank Rank;
-    typedef typename NodeTypes::StringTerm StringTerm;
-    //typedef typename NodeTypes::SubstringTerm SubstrTr;
-    typedef typename NodeTypes::SuffixTerm SuffixTerm;
-    typedef typename NodeTypes::LocationTerm LocationTerm;
-    //typedef typename NodeTypes::WeightedSetTerm WeightedSetTerm;
-    typedef typename NodeTypes::DotProduct DotProduct;
-    typedef typename NodeTypes::WandTerm WandTerm;
-    typedef typename NodeTypes::WeakAnd WeakAnd;
-    typedef typename NodeTypes::PredicateQuery PredicateQuery;
-    typedef typename NodeTypes::RegExpTerm RegExpTerm;
-    typedef typename NodeTypes::TrueQueryNode TrueNode;
-    typedef typename NodeTypes::FalseQueryNode FalseNode;
-    typedef typename NodeTypes::FuzzyTerm FuzzyTerm;
+    using And = typename NodeTypes::And;
+    using AndNot = typename NodeTypes::AndNot;
+    using NumberTerm = typename NodeTypes::NumberTerm;
+    using Near = typename NodeTypes::Near;
+    using ONear = typename NodeTypes::ONear;
+    using SameElement = typename NodeTypes::SameElement;
+    using Or = typename NodeTypes::Or;
+    using Phrase = typename NodeTypes::Phrase;
+    using PrefixTerm = typename NodeTypes::PrefixTerm;
+    using RangeTerm = typename NodeTypes::RangeTerm;
+    using Rank = typename NodeTypes::Rank;
+    using StringTerm = typename NodeTypes::StringTerm;
+    using SuffixTerm = typename NodeTypes::SuffixTerm;
+    using LocationTerm = typename NodeTypes::LocationTerm;
+    using DotProduct = typename NodeTypes::DotProduct;
+    using WandTerm = typename NodeTypes::WandTerm;
+    using WeakAnd = typename NodeTypes::WeakAnd;
+    using PredicateQuery = typename NodeTypes::PredicateQuery;
+    using RegExpTerm = typename NodeTypes::RegExpTerm;
+    using TrueNode = typename NodeTypes::TrueQueryNode;
+    using FalseNode = typename NodeTypes::FalseQueryNode;
+    using FuzzyTerm = typename NodeTypes::FuzzyTerm;
 
     ASSERT_TRUE(node);
     auto* and_node = as_node<And>(node);
@@ -334,30 +331,30 @@ void checkQueryTreeTypes(Node *node) {
 }
 
 struct AbstractTypes {
-    typedef search::query::And And;
-    typedef search::query::AndNot AndNot;
-    typedef search::query::NumberTerm NumberTerm;
-    typedef search::query::LocationTerm LocationTerm;
-    typedef search::query::Near Near;
-    typedef search::query::ONear ONear;
-    typedef search::query::SameElement SameElement;
-    typedef search::query::Or Or;
-    typedef search::query::Phrase Phrase;
-    typedef search::query::PrefixTerm PrefixTerm;
-    typedef search::query::RangeTerm RangeTerm;
-    typedef search::query::Rank Rank;
-    typedef search::query::StringTerm StringTerm;
-    typedef search::query::SubstringTerm SubstringTerm;
-    typedef search::query::SuffixTerm SuffixTerm;
-    typedef search::query::WeightedSetTerm WeightedSetTerm;
-    typedef search::query::DotProduct DotProduct;
-    typedef search::query::WandTerm WandTerm;
-    typedef search::query::WeakAnd WeakAnd;
-    typedef search::query::PredicateQuery PredicateQuery;
-    typedef search::query::RegExpTerm RegExpTerm;
-    typedef search::query::TrueQueryNode TrueQueryNode;
-    typedef search::query::FalseQueryNode FalseQueryNode;
-    typedef search::query::FuzzyTerm FuzzyTerm;
+    using And = search::query::And;
+    using AndNot = search::query::AndNot;
+    using NumberTerm = search::query::NumberTerm;
+    using LocationTerm = search::query::LocationTerm;
+    using Near = search::query::Near;
+    using ONear = search::query::ONear;
+    using SameElement = search::query::SameElement;
+    using Or = search::query::Or;
+    using Phrase = search::query::Phrase;
+    using PrefixTerm = search::query::PrefixTerm;
+    using RangeTerm = search::query::RangeTerm;
+    using Rank = search::query::Rank;
+    using StringTerm = search::query::StringTerm;
+    using SubstringTerm = search::query::SubstringTerm;
+    using SuffixTerm = search::query::SuffixTerm;
+    using WeightedSetTerm = search::query::WeightedSetTerm;
+    using DotProduct = search::query::DotProduct;
+    using WandTerm = search::query::WandTerm;
+    using WeakAnd = search::query::WeakAnd;
+    using PredicateQuery = search::query::PredicateQuery;
+    using RegExpTerm = search::query::RegExpTerm;
+    using TrueQueryNode = search::query::TrueQueryNode;
+    using FalseQueryNode = search::query::FalseQueryNode;
+    using FuzzyTerm = search::query::FuzzyTerm;
 };
 
 // Builds a tree with simplequery and checks that the results have the
@@ -461,32 +458,32 @@ struct MyFuzzyTerm : FuzzyTerm {
 };
 
 struct MyQueryNodeTypes {
-    typedef MyAnd And;
-    typedef MyAndNot AndNot;
-    typedef MyEquiv Equiv;
-    typedef MyNumberTerm NumberTerm;
-    typedef MyLocationTerm LocationTerm;
-    typedef MyNear Near;
-    typedef MyONear ONear;
-    typedef MyOr Or;
-    typedef MyPhrase Phrase;
-    typedef MySameElement SameElement;
-    typedef MyPrefixTerm PrefixTerm;
-    typedef MyRangeTerm RangeTerm;
-    typedef MyRank Rank;
-    typedef MyStringTerm StringTerm;
-    typedef MySubstringTerm SubstringTerm;
-    typedef MySuffixTerm SuffixTerm;
-    typedef MyWeakAnd WeakAnd;
-    typedef MyWeightedSetTerm WeightedSetTerm;
-    typedef MyDotProduct DotProduct;
-    typedef MyWandTerm WandTerm;
-    typedef MyPredicateQuery PredicateQuery;
-    typedef MyRegExpTerm RegExpTerm;
-    typedef MyNearestNeighborTerm NearestNeighborTerm;
-    typedef MyTrue TrueQueryNode;
-    typedef MyFalse FalseQueryNode;
-    typedef MyFuzzyTerm FuzzyTerm;
+    using And = MyAnd;
+    using AndNot = MyAndNot;
+    using Equiv = MyEquiv;
+    using NumberTerm = MyNumberTerm;
+    using LocationTerm = MyLocationTerm;
+    using Near = MyNear;
+    using ONear = MyONear;
+    using Or = MyOr;
+    using Phrase = MyPhrase;
+    using SameElement = MySameElement;
+    using PrefixTerm = MyPrefixTerm;
+    using RangeTerm = MyRangeTerm;
+    using Rank = MyRank;
+    using StringTerm = MyStringTerm;
+    using SubstringTerm = MySubstringTerm;
+    using SuffixTerm = MySuffixTerm;
+    using WeakAnd = MyWeakAnd;
+    using WeightedSetTerm = MyWeightedSetTerm;
+    using DotProduct = MyDotProduct;
+    using WandTerm = MyWandTerm;
+    using PredicateQuery = MyPredicateQuery;
+    using RegExpTerm = MyRegExpTerm;
+    using NearestNeighborTerm = MyNearestNeighborTerm;
+    using TrueQueryNode = MyTrue;
+    using FalseQueryNode = MyFalse;
+    using FuzzyTerm = MyFuzzyTerm;
 };
 
 TEST("require that Custom Query Trees Can Be Built") {
diff --git a/searchlib/src/tests/queryeval/blueprint/mysearch.h b/searchlib/src/tests/queryeval/blueprint/mysearch.h
index 23cfc8583cd..6c91a23e80b 100644
--- a/searchlib/src/tests/queryeval/blueprint/mysearch.h
+++ b/searchlib/src/tests/queryeval/blueprint/mysearch.h
@@ -12,8 +12,8 @@ namespace search::queryeval {
 class MySearch : public MultiSearch
 {
 public:
-    typedef search::fef::TermFieldMatchDataArray TFMDA;
-    typedef search::fef::MatchData               MatchData;
+    using TFMDA = search::fef::TermFieldMatchDataArray;
+    using MatchData = search::fef::MatchData;
 
 private:
     vespalib::string _tag;
@@ -103,7 +103,7 @@ public:
 
 class MyLeaf : public SimpleLeafBlueprint
 {
-    typedef search::fef::TermFieldMatchDataArray TFMDA;
+    using TFMDA = search::fef::TermFieldMatchDataArray;
     bool _got_global_filter;
 
 public:
diff --git a/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_bench.cpp b/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_bench.cpp
index b5d4ec71a3b..397014f498f 100644
--- a/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_bench.cpp
+++ b/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_bench.cpp
@@ -53,7 +53,7 @@ void Test::setup()
     }
 }
 
-typedef std::vector<uint32_t> H;
+using H = std::vector<uint32_t>;
 
 H
 seek(SearchIterator & s, uint32_t docIdLimit)
diff --git a/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_test.cpp b/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_test.cpp
index 01175608bc5..d0ccbaeb180 100644
--- a/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_test.cpp
+++ b/searchlib/src/tests/queryeval/multibitvectoriterator/multibitvectoriterator_test.cpp
@@ -90,7 +90,7 @@ void Test::setup()
     }
 }
 
-typedef std::vector<uint32_t> H;
+using H = std::vector<uint32_t>;
 
 H
 seekNoReset(SearchIterator & s, uint32_t start, uint32_t docIdLimit)
@@ -565,7 +565,7 @@ Test::testOptimizeAndOr(bool invert)
 void
 Test::testEndGuard(bool invert)
 {
-    typedef AndSearch T;
+    using T = AndSearch;
     TermFieldMatchData tfmd;
 
     MultiSearch::Children children;
diff --git a/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp b/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp
index 55ca42f7369..83ffae0524c 100644
--- a/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp
+++ b/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp
@@ -18,10 +18,10 @@ using namespace search::query;
 using namespace search::queryeval;
 using namespace search::queryeval::test;
 
-typedef search::feature_t feature_t;
-typedef wand::score_t score_t;
-typedef ParallelWeakAndSearch::MatchParams MatchParams;
-typedef ParallelWeakAndSearch::RankParams RankParams;
+using feature_t = search::feature_t;
+using score_t = wand::score_t;
+using MatchParams = ParallelWeakAndSearch::MatchParams;
+using RankParams = ParallelWeakAndSearch::RankParams;
 using search::test::DocumentWeightAttributeHelper;
 using search::IDocumentWeightAttribute;
 using search::fef::TermFieldMatchData;
@@ -115,8 +115,8 @@ WandTestSpec<HeapType>::WandTestSpec(uint32_t scoresToTrack, uint32_t scoresAdju
 template <typename HeapType>
 WandTestSpec<HeapType>::~WandTestSpec() {}
 
-typedef WandTestSpec<TestHeap> WandSpecWithTestHeap;
-typedef WandTestSpec<SharedWeakAndPriorityQueue> WandSpecWithRealHeap;
+using WandSpecWithTestHeap = WandTestSpec<TestHeap>;
+using WandSpecWithRealHeap = WandTestSpec<SharedWeakAndPriorityQueue>;
 
 FakeResult
 doSearch(SearchIterator &sb, const TermFieldMatchData &tfmd)
diff --git a/searchlib/src/tests/queryeval/predicate/predicate_search_test.cpp b/searchlib/src/tests/queryeval/predicate/predicate_search_test.cpp
index 890c73ce17c..d15175ba5d1 100644
--- a/searchlib/src/tests/queryeval/predicate/predicate_search_test.cpp
+++ b/searchlib/src/tests/queryeval/predicate/predicate_search_test.cpp
@@ -85,9 +85,9 @@ make_posting_lists_vector(MyPostingList (&plists)[N]) {
 }
 
 TermFieldMatchDataArray tfmda;
-typedef std::vector<uint8_t> CV;
-typedef std::vector<uint8_t> MF;
-typedef std::vector<uint16_t> IR;
+using CV = std::vector<uint8_t>;
+using MF = std::vector<uint8_t>;
+using IR = std::vector<uint16_t>;
 
 TEST("Require that the skipping is efficient") {
     const uint8_t min_feature[] = { 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
diff --git a/searchlib/src/tests/queryeval/queryeval.cpp b/searchlib/src/tests/queryeval/queryeval.cpp
index 5d34e491708..62815f285c4 100644
--- a/searchlib/src/tests/queryeval/queryeval.cpp
+++ b/searchlib/src/tests/queryeval/queryeval.cpp
@@ -605,7 +605,7 @@ TEST("testDump") {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wshadow"
 #endif
-    typedef SourceBlenderSearch::Child Source;
+    using Source = SourceBlenderSearch::Child;
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
diff --git a/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp b/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp
index df01744d619..ac7dabd786b 100644
--- a/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp
+++ b/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp
@@ -84,7 +84,7 @@ private:
     Writer _writer;
 
 public:
-    typedef std::unique_ptr<Graph> UP;
+    using UP = std::unique_ptr<Graph>;
     Graph(const std::string &file) : _writer(file) {}
     void addValue(double x, double y) { _writer.fmt("%g %g\n", x, y); }
 };
@@ -99,7 +99,7 @@ private:
     static int  _plots;
 
 public:
-    typedef std::unique_ptr<Plot> UP;
+    using UP = std::unique_ptr<Plot>;
 
     Plot(const std::string &title) : _name(vespalib::make_string("plot.%d", _plots++)), _graphs(0),
                                      _writer(vespalib::make_string("%s.gnuplot", _name.c_str())) {
diff --git a/searchlib/src/tests/queryeval/weak_and/rise_wand.h b/searchlib/src/tests/queryeval/weak_and/rise_wand.h
index 7a5e46c05ea..250993bf139 100644
--- a/searchlib/src/tests/queryeval/weak_and/rise_wand.h
+++ b/searchlib/src/tests/queryeval/weak_and/rise_wand.h
@@ -28,10 +28,10 @@ template <typename Scorer, typename Cmp>
 class RiseWand : public search::queryeval::SearchIterator
 {
 public:
-    typedef uint32_t docid_t;
-    typedef uint64_t score_t;
-    typedef search::queryeval::wand::Terms Terms;
-    typedef search::queryeval::SearchIterator *PostingStreamPtr;
+    using docid_t = uint32_t;
+    using score_t = uint64_t;
+    using Terms = search::queryeval::wand::Terms;
+    using PostingStreamPtr = search::queryeval::SearchIterator*;
 
 private:
     // comparator class that compares two streams. The variables a and b are
@@ -125,8 +125,8 @@ public:
     void doUnpack(uint32_t docid) override;
 };
 
-typedef RiseWand<TermFreqScorer, std::greater_equal<uint64_t> > TermFrequencyRiseWand;
-typedef RiseWand<DotProductScorer, std::greater<uint64_t> > DotProductRiseWand;
+using TermFrequencyRiseWand = RiseWand<TermFreqScorer, std::greater_equal<uint64_t> >;
+using DotProductRiseWand = RiseWand<DotProductScorer, std::greater<uint64_t> >;
 
 } // namespacve rise
 
diff --git a/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp b/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
index 87eec226221..fd73243b4fa 100644
--- a/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
+++ b/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
@@ -18,8 +18,8 @@ using namespace search::fef;
 using namespace search::queryeval;
 using namespace vespalib;
 
-typedef ParallelWeakAndSearch::MatchParams PWMatchParams;
-typedef ParallelWeakAndSearch::RankParams PWRankParams;
+using PWMatchParams = ParallelWeakAndSearch::MatchParams;
+using PWRankParams = ParallelWeakAndSearch::RankParams;
 
 namespace {
 
diff --git a/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp b/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp
index 828538b5e8e..e1593f7ad1d 100644
--- a/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp
+++ b/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp
@@ -13,7 +13,7 @@ using namespace search::fef;
 using namespace search::queryeval;
 using namespace search::queryeval::test;
 
-typedef SearchHistory History;
+using History = SearchHistory;
 
 namespace {
 
diff --git a/searchlib/src/tests/queryeval/weak_and_heap/weak_and_heap_test.cpp b/searchlib/src/tests/queryeval/weak_and_heap/weak_and_heap_test.cpp
index 42d40367b03..1304168b179 100644
--- a/searchlib/src/tests/queryeval/weak_and_heap/weak_and_heap_test.cpp
+++ b/searchlib/src/tests/queryeval/weak_and_heap/weak_and_heap_test.cpp
@@ -3,7 +3,7 @@
 #include <vespa/searchlib/queryeval/wand/weak_and_heap.h>
 
 using namespace search::queryeval;
-typedef wand::score_t score_t;
+using score_t = wand::score_t;
 
 struct Scores : public std::vector<score_t> {
     Scores &s(score_t val) {
diff --git a/searchlib/src/tests/queryeval/weak_and_scorers/weak_and_scorers_test.cpp b/searchlib/src/tests/queryeval/weak_and_scorers/weak_and_scorers_test.cpp
index d94fd12e532..c5c0ea9a528 100644
--- a/searchlib/src/tests/queryeval/weak_and_scorers/weak_and_scorers_test.cpp
+++ b/searchlib/src/tests/queryeval/weak_and_scorers/weak_and_scorers_test.cpp
@@ -8,7 +8,7 @@ using namespace search::queryeval;
 using search::fef::TermFieldMatchData;
 using search::fef::TermFieldMatchDataPosition;
 
-typedef wand::Term Term;
+using Term = wand::Term;
 
 struct TestIterator : public SearchIterator
 {
@@ -18,7 +18,7 @@ struct TestIterator : public SearchIterator
     TermFieldMatchData _tfmd;
     uint32_t           _unpackDocId;
 
-    typedef std::unique_ptr<TestIterator> UP;
+    using UP = std::unique_ptr<TestIterator>;
     TestIterator(int32_t maxWeight, int32_t termWeight, bool useInfo)
         : _info(0, maxWeight),
           _termWeight(termWeight),
diff --git a/searchlib/src/tests/ranksetup/ranksetup_test.cpp b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
index 63209446746..50d9d36f575 100644
--- a/searchlib/src/tests/ranksetup/ranksetup_test.cpp
+++ b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
@@ -43,7 +43,7 @@ using namespace search::fef::test;
 using search::feature_t;
 using vespalib::make_string_short::fmt;
 
-typedef FeatureNameBuilder FNB;
+using FNB = FeatureNameBuilder;
 
 //-----------------------------------------------------------------------------
 // DumpFeatureVisitor
@@ -785,7 +785,7 @@ RankSetupTest::testFeatureDump()
 void
 RankSetupTest::checkFeatures(std::map<vespalib::string, feature_t> &exp, std::map<vespalib::string, feature_t> &actual)
 {
-    typedef std::map<vespalib::string, feature_t>::const_iterator ITR;
+    using ITR = std::map<vespalib::string, feature_t>::const_iterator;
     if (!EXPECT_EQUAL(exp.size(), actual.size())) {
         return;
     }
diff --git a/searchlib/src/tests/sort/sortbenchmark.cpp b/searchlib/src/tests/sort/sortbenchmark.cpp
index 59d5f16d980..04832593b28 100644
--- a/searchlib/src/tests/sort/sortbenchmark.cpp
+++ b/searchlib/src/tests/sort/sortbenchmark.cpp
@@ -11,7 +11,7 @@ using vespalib::ConstBufferRef;
 class Test : public vespalib::TestApp
 {
 public:
-    typedef std::vector<uint32_t> V;
+    using V = std::vector<uint32_t>;
     std::vector< std::vector<uint32_t> > _data;
     int Main() override;
     void generateVectors(size_t numVectors, size_t values);
diff --git a/searchlib/src/tests/sortspec/multilevelsort.cpp b/searchlib/src/tests/sortspec/multilevelsort.cpp
index 87dc6608c3f..ec14f0c97e1 100644
--- a/searchlib/src/tests/sortspec/multilevelsort.cpp
+++ b/searchlib/src/tests/sortspec/multilevelsort.cpp
@@ -16,10 +16,10 @@ LOG_SETUP("multilevelsort_test");
 
 using namespace search;
 
-typedef FloatingPointAttributeTemplate<float>  Float;
-typedef FloatingPointAttributeTemplate<double> Double;
-typedef std::map<std::string, AttributeVector::SP > VectorMap;
-typedef AttributeVector::SP             AttributePtr;
+using Float = FloatingPointAttributeTemplate<float>;
+using Double = FloatingPointAttributeTemplate<double>;
+using VectorMap = std::map<std::string, AttributeVector::SP >;
+using AttributePtr = AttributeVector::SP;
 using search::attribute::Config;
 using search::attribute::BasicType;
 using search::attribute::CollectionType;
diff --git a/searchlib/src/tests/transactionlog/translogclient_test.cpp b/searchlib/src/tests/transactionlog/translogclient_test.cpp
index 1eae8489c75..af214c34be8 100644
--- a/searchlib/src/tests/transactionlog/translogclient_test.cpp
+++ b/searchlib/src/tests/transactionlog/translogclient_test.cpp
@@ -87,7 +87,7 @@ class CallBackTest : public Callback
 private:
     RPC::Result receive(const Packet & packet) override;
     void eof() override { _eof.set(); }
-    typedef std::map<SerialNum, std::unique_ptr<ByteBuffer>> PacketMap;
+    using PacketMap = std::map<SerialNum, std::unique_ptr<ByteBuffer>>;
     PacketMap _packetMap;
     Eof _eof;
 public:
@@ -146,7 +146,7 @@ CallBackManyTest::receive(const Packet & p)
 class CallBackUpdate : public Callback
 {
 public:
-    typedef std::map<SerialNum, Identifiable *> PacketMap;
+    using PacketMap = std::map<SerialNum, Identifiable *>;
 private:
     RPC::Result receive(const Packet & packet) override;
     void eof() override { _eof.set(); }