Index: clang-tools-extra/trunk/clangd/index/dex/DexIndex.h
===================================================================
--- clang-tools-extra/trunk/clangd/index/dex/DexIndex.h
+++ clang-tools-extra/trunk/clangd/index/dex/DexIndex.h
@@ -41,7 +41,7 @@
 public:
   /// \brief (Re-)Build index for `Symbols`. All symbol pointers must remain
   /// accessible as long as `Symbols` is kept alive.
-  void build(std::shared_ptr<std::vector<const Symbol *>> Symbols);
+  void build(std::shared_ptr<std::vector<const Symbol *>> Syms);
 
   /// \brief Build index from a symbol slab.
   static std::unique_ptr<SymbolIndex> build(SymbolSlab Slab);
Index: clang-tools-extra/trunk/clangd/index/dex/DexIndex.cpp
===================================================================
--- clang-tools-extra/trunk/clangd/index/dex/DexIndex.cpp
+++ clang-tools-extra/trunk/clangd/index/dex/DexIndex.cpp
@@ -30,7 +30,7 @@
 // * Types
 std::vector<Token> generateSearchTokens(const Symbol &Sym) {
   std::vector<Token> Result = generateIdentifierTrigrams(Sym.Name);
-  Result.push_back(Token(Token::Kind::Scope, Sym.Scope));
+  Result.emplace_back(Token::Kind::Scope, Sym.Scope);
   return Result;
 }
 
Index: clang-tools-extra/trunk/clangd/index/dex/Iterator.cpp
===================================================================
--- clang-tools-extra/trunk/clangd/index/dex/Iterator.cpp
+++ clang-tools-extra/trunk/clangd/index/dex/Iterator.cpp
@@ -30,23 +30,26 @@
 
   /// Advances cursor to the next item.
   void advance() override {
-    assert(!reachedEnd() && "DocumentIterator can't advance at the end.");
+    assert(!reachedEnd() && "DOCUMENT iterator can't advance() at the end.");
     ++Index;
   }
 
   /// Applies binary search to advance cursor to the next item with DocID equal
   /// or higher than the given one.
   void advanceTo(DocID ID) override {
-    assert(!reachedEnd() && "DocumentIterator can't advance at the end.");
+    assert(!reachedEnd() && "DOCUMENT iterator can't advance() at the end.");
     Index = std::lower_bound(Index, std::end(Documents), ID);
   }
 
   DocID peek() const override {
-    assert(!reachedEnd() && "DocumentIterator can't call peek() at the end.");
+    assert(!reachedEnd() && "DOCUMENT iterator can't peek() at the end.");
     return *Index;
   }
 
-  float consume() override { return DEFAULT_BOOST_SCORE; }
+  float consume() override {
+    assert(!reachedEnd() && "DOCUMENT iterator can't consume() at the end.");
+    return DEFAULT_BOOST_SCORE;
+  }
 
   size_t estimateSize() const override { return Documents.size(); }
 
@@ -84,7 +87,7 @@
 public:
   AndIterator(std::vector<std::unique_ptr<Iterator>> AllChildren)
       : Children(std::move(AllChildren)) {
-    assert(!Children.empty() && "AndIterator should have at least one child.");
+    assert(!Children.empty() && "AND iterator should have at least one child.");
     // Establish invariants.
     sync();
     // When children are sorted by the estimateSize(), sync() calls are more
@@ -105,14 +108,14 @@
 
   /// Advances all children to the next common item.
   void advance() override {
-    assert(!reachedEnd() && "AndIterator can't call advance() at the end.");
+    assert(!reachedEnd() && "AND iterator can't advance() at the end.");
     Children.front()->advance();
     sync();
   }
 
   /// Advances all children to the next common item with DocumentID >= ID.
   void advanceTo(DocID ID) override {
-    assert(!reachedEnd() && "AndIterator can't call advanceTo() at the end.");
+    assert(!reachedEnd() && "AND iterator can't advanceTo() at the end.");
     Children.front()->advanceTo(ID);
     sync();
   }
@@ -120,7 +123,7 @@
   DocID peek() const override { return Children.front()->peek(); }
 
   float consume() override {
-    assert(!reachedEnd() && "AndIterator can't consume() at the end.");
+    assert(!reachedEnd() && "AND iterator can't consume() at the end.");
     return std::accumulate(
         begin(Children), end(Children), DEFAULT_BOOST_SCORE,
         [&](float Current, const std::unique_ptr<Iterator> &Child) {
@@ -192,7 +195,7 @@
 public:
   OrIterator(std::vector<std::unique_ptr<Iterator>> AllChildren)
       : Children(std::move(AllChildren)) {
-    assert(Children.size() > 0 && "Or Iterator must have at least one child.");
+    assert(Children.size() > 0 && "OR iterator must have at least one child.");
   }
 
   /// Returns true if all children are exhausted.
@@ -205,8 +208,7 @@
 
   /// Moves each child pointing to the smallest DocID to the next item.
   void advance() override {
-    assert(!reachedEnd() &&
-           "OrIterator can't call advance() after it reached the end.");
+    assert(!reachedEnd() && "OR iterator can't advance() at the end.");
     const auto SmallestID = peek();
     for (const auto &Child : Children)
       if (!Child->reachedEnd() && Child->peek() == SmallestID)
@@ -215,7 +217,7 @@
 
   /// Advances each child to the next existing element with DocumentID >= ID.
   void advanceTo(DocID ID) override {
-    assert(!reachedEnd() && "Can't advance iterator after it reached the end.");
+    assert(!reachedEnd() && "OR iterator can't advanceTo() at the end.");
     for (const auto &Child : Children)
       if (!Child->reachedEnd())
         Child->advanceTo(ID);
@@ -224,8 +226,7 @@
   /// Returns the element under cursor of the child with smallest Child->peek()
   /// value.
   DocID peek() const override {
-    assert(!reachedEnd() &&
-           "OrIterator can't peek() after it reached the end.");
+    assert(!reachedEnd() && "OR iterator can't peek() at the end.");
     DocID Result = std::numeric_limits<DocID>::max();
 
     for (const auto &Child : Children)
@@ -238,8 +239,7 @@
   // Returns the maximum boosting score among all Children when iterator is not
   // exhausted and points to the given ID, DEFAULT_BOOST_SCORE otherwise.
   float consume() override {
-    assert(!reachedEnd() &&
-           "OrIterator can't consume() after it reached the end.");
+    assert(!reachedEnd() && "OR iterator can't consume() at the end.");
     const DocID ID = peek();
     return std::accumulate(
         begin(Children), end(Children), DEFAULT_BOOST_SCORE,
@@ -284,21 +284,24 @@
   bool reachedEnd() const override { return Index >= Size; }
 
   void advance() override {
-    assert(!reachedEnd() && "Can't advance iterator after it reached the end.");
+    assert(!reachedEnd() && "TRUE iterator can't advance() at the end.");
     ++Index;
   }
 
   void advanceTo(DocID ID) override {
-    assert(!reachedEnd() && "Can't advance iterator after it reached the end.");
+    assert(!reachedEnd() && "TRUE iterator can't advanceTo() at the end.");
     Index = std::min(ID, Size);
   }
 
   DocID peek() const override {
-    assert(!reachedEnd() && "TrueIterator can't call peek() at the end.");
+    assert(!reachedEnd() && "TRUE iterator can't peek() at the end.");
     return Index;
   }
 
-  float consume() override { return DEFAULT_BOOST_SCORE; }
+  float consume() override {
+    assert(!reachedEnd() && "TRUE iterator can't consume() at the end.");
+    return DEFAULT_BOOST_SCORE;
+  }
 
   size_t estimateSize() const override { return Size; }
 
@@ -364,7 +367,7 @@
   /// Decreases the limit in case the element consumed at top of the query tree
   /// comes from the underlying iterator.
   float consume() override {
-    assert(!reachedEnd() && "LimitIterator can't consume at the end.");
+    assert(!reachedEnd() && "LimitIterator can't consume() at the end.");
     --ItemsLeft;
     return Child->consume();
   }
@@ -389,7 +392,7 @@
 std::vector<std::pair<DocID, float>> consume(Iterator &It) {
   std::vector<std::pair<DocID, float>> Result;
   for (; !It.reachedEnd(); It.advance())
-    Result.push_back(std::make_pair(It.peek(), It.consume()));
+    Result.emplace_back(It.peek(), It.consume());
   return Result;
 }
 
@@ -417,8 +420,8 @@
 }
 
 std::unique_ptr<Iterator> createLimit(std::unique_ptr<Iterator> Child,
-                                      size_t Size) {
-  return llvm::make_unique<LimitIterator>(move(Child), Size);
+                                      size_t Limit) {
+  return llvm::make_unique<LimitIterator>(move(Child), Limit);
 }
 
 } // namespace dex
Index: clang-tools-extra/trunk/clangd/index/dex/Trigram.cpp
===================================================================
--- clang-tools-extra/trunk/clangd/index/dex/Trigram.cpp
+++ clang-tools-extra/trunk/clangd/index/dex/Trigram.cpp
@@ -87,10 +87,10 @@
     if (Roles[I] != Head && Roles[I] != Tail)
       continue;
     for (const unsigned J : Next[I]) {
-      if (!J)
+      if (J == 0)
         continue;
       for (const unsigned K : Next[J]) {
-        if (!K)
+        if (K == 0)
           continue;
         add({{LowercaseIdentifier[I], LowercaseIdentifier[J],
               LowercaseIdentifier[K]}});
@@ -113,8 +113,8 @@
   // Additional pass is necessary to count valid identifier characters.
   // Depending on that, this function might return incomplete trigram.
   unsigned ValidSymbolsCount = 0;
-  for (size_t I = 0; I < Roles.size(); ++I)
-    if (Roles[I] == Head || Roles[I] == Tail)
+  for (const auto Role : Roles)
+    if (Role == Head || Role == Tail)
       ++ValidSymbolsCount;
 
   std::string LowercaseQuery = Query.lower();