[clangd] Dex: add Corpus factory for iterators, rename, fold constant. NFC

[sammccall]

Summary

• Corpus avoids having to pass size to the true iterator, and (soon) any iterator that might optimize down to true.
• Shorten names of factory functions now they're scoped to the Corpus. intersect() and unionOf() rather than createAnd() or createOr() as this seems to read better to me, and fits with other short names. Opinion wanted!
• DEFAULT_BOOST_SCORE --> 1. This is a multiplier, don't obfuscate identity.
• Simplify variadic templates in Iterator.h

[ioeric]

clangd/index/dex/Iterator.h

131 ↗

(On Diff #167687)

Maybe make this a constant and initialize it via a constructor?

clang-tools-extra/trunk/clangd/index/dex/Dex.h

 // changed frequently, it's safe to assume that it has to be built only once
 // (when the clangd process starts). Therefore, it can be easier to store built
 // index on disk and then load it if available.
 class Dex : public SymbolIndex {
 public:
   // All symbols must outlive this index.
   template <typename Range>
   Dex(Range &&Symbols, llvm::ArrayRef<std::string> Schemes)
-      : URISchemes(Schemes) {
+      : Corpus(0), URISchemes(Schemes) {
     // If Schemes don't contain any items, fall back to SymbolCollector's
     // default URI schemes.
     if (URISchemes.empty()) {
       SymbolCollector::Options Opts;
       URISchemes = Opts.URISchemes;
     }
     for (auto &&Sym : Symbols)
       this->Symbols.push_back(&Sym);
private:
   llvm::DenseMap<SymbolID, const Symbol *> LookupTable;
   /// Inverted index is a mapping from the search token to the posting list,
   /// which contains all items which can be characterized by such search token.
   /// For example, if the search token is scope "std::", the corresponding
   /// posting list would contain all indices of symbols defined in namespace
   /// std. Inverted index is used to retrieve posting lists which are processed
   /// during the fuzzyFind process.
   llvm::DenseMap<Token, PostingList> InvertedIndex;
+  Corpus Corpus;
   std::shared_ptr<void> KeepAlive; // poor man's move-only std::any
   // Size of memory retained by KeepAlive.
   size_t BackingDataSize = 0;
 
   std::vector<std::string> URISchemes;
 };
 
 /// Returns Search Token for a number of parent directories of given Path.

clang-tools-extra/trunk/clangd/index/dex/Dex.cpp

if (Sym.Flags & Symbol::IndexedForCodeCompletion)
     Result.emplace_back(RestrictedForCodeCompletion);
   return Result;
 }
 
 // Constructs BOOST iterators for Path Proximities.
 std::vector<std::unique_ptr<Iterator>> createFileProximityIterators(
     llvm::ArrayRef<std::string> ProximityPaths,
     llvm::ArrayRef<std::string> URISchemes,
-    const llvm::DenseMap<Token, PostingList> &InvertedIndex) {
+    const llvm::DenseMap<Token, PostingList> &InvertedIndex,
+    const Corpus &Corpus) {
   std::vector<std::unique_ptr<Iterator>> BoostingIterators;
   // Deduplicate parent URIs extracted from the ProximityPaths.
   llvm::StringSet<> ParentURIs;
   llvm::StringMap<SourceParams> Sources;
   for (const auto &Path : ProximityPaths) {
     Sources[Path] = SourceParams();
     auto PathURI = URI::create(Path, URISchemes);
     if (!PathURI) {
std::vector<std::unique_ptr<Iterator>> createFileProximityIterators(
   // ProximityPaths. Boosting factor should depend on the distance to the
   // Proximity Path: the closer processed path is, the higher boosting factor.
   for (const auto &ParentURI : ParentURIs.keys()) {
     Token Tok(Token::Kind::ProximityURI, ParentURI);
     const auto It = InvertedIndex.find(Tok);
     if (It != InvertedIndex.end()) {
       // FIXME(kbobyrev): Append LIMIT on top of every BOOST iterator.
       PathProximitySignals.SymbolURI = ParentURI;
-      BoostingIterators.push_back(createBoost(It->second.iterator(&It->first),
-                                              PathProximitySignals.evaluate()));
+      BoostingIterators.push_back(Corpus.boost(
+          It->second.iterator(&It->first), PathProximitySignals.evaluate()));
     }
   }
   return BoostingIterators;
 }
 
 } // namespace
 
 void Dex::buildIndex() {
+  this->Corpus = dex::Corpus(Symbols.size());
   std::vector<std::pair<float, const Symbol *>> ScoredSymbols(Symbols.size());
 
   for (size_t I = 0; I < Symbols.size(); ++I) {
     const Symbol *Sym = Symbols[I];
     LookupTable[Sym->ID] = Sym;
     ScoredSymbols[I] = {quality(*Sym), Sym};
   }
 
bool Dex::fuzzyFind(const FuzzyFindRequest &Req,
   // trigrams.
   std::vector<std::unique_ptr<Iterator>> TrigramIterators;
   for (const auto &Trigram : TrigramTokens) {
     const auto It = InvertedIndex.find(Trigram);
     if (It != InvertedIndex.end())
       TrigramIterators.push_back(It->second.iterator(&It->first));
   }
   if (!TrigramIterators.empty())
-    TopLevelChildren.push_back(createAnd(move(TrigramIterators)));
+    TopLevelChildren.push_back(Corpus.intersect(move(TrigramIterators)));
 
   // Generate scope tokens for search query.
   std::vector<std::unique_ptr<Iterator>> ScopeIterators;
   for (const auto &Scope : Req.Scopes) {
     Token Tok(Token::Kind::Scope, Scope);
     const auto It = InvertedIndex.find(Tok);
     if (It != InvertedIndex.end())
       ScopeIterators.push_back(It->second.iterator(&It->first));
   }
   if (Req.AnyScope)
-    ScopeIterators.push_back(createBoost(createTrue(Symbols.size()),
-                                         ScopeIterators.empty() ? 1.0 : 0.2));
+    ScopeIterators.push_back(
+        Corpus.boost(Corpus.all(), ScopeIterators.empty() ? 1.0 : 0.2));
 
   // Add OR iterator for scopes if there are any Scope Iterators.
   if (!ScopeIterators.empty())
-    TopLevelChildren.push_back(createOr(move(ScopeIterators)));
+    TopLevelChildren.push_back(Corpus.unionOf(move(ScopeIterators)));
 
   // Add proximity paths boosting.
   auto BoostingIterators = createFileProximityIterators(
-      Req.ProximityPaths, URISchemes, InvertedIndex);
+      Req.ProximityPaths, URISchemes, InvertedIndex, Corpus);
   // Boosting iterators do not actually filter symbols. In order to preserve
   // the validity of resulting query, TRUE iterator should be added along
   // BOOSTs.
   if (!BoostingIterators.empty()) {
-    BoostingIterators.push_back(createTrue(Symbols.size()));
-    TopLevelChildren.push_back(createOr(move(BoostingIterators)));
+    BoostingIterators.push_back(Corpus.all());
+    TopLevelChildren.push_back(Corpus.unionOf(move(BoostingIterators)));
   }
 
   if (Req.RestrictForCodeCompletion)
     TopLevelChildren.push_back(
         InvertedIndex.find(RestrictedForCodeCompletion)
             ->second.iterator(&RestrictedForCodeCompletion));
 
   // Use TRUE iterator if both trigrams and scopes from the query are not
   // present in the symbol index.
   auto QueryIterator = TopLevelChildren.empty()
-                           ? createTrue(Symbols.size())
-                           : createAnd(move(TopLevelChildren));
+                           ? Corpus.all()
+                           : Corpus.intersect(move(TopLevelChildren));
   // Retrieve more items than it was requested: some of  the items with high
   // final score might not be retrieved otherwise.
   // FIXME(kbobyrev): Pre-scoring retrieval threshold should be adjusted as
   // using 100x of the requested number might not be good in practice, e.g.
   // when the requested number of items is small.
-  auto Root = Req.Limit ? createLimit(move(QueryIterator), *Req.Limit * 100)
+  auto Root = Req.Limit ? Corpus.limit(move(QueryIterator), *Req.Limit * 100)
                         : move(QueryIterator);
   SPAN_ATTACH(Tracer, "query", llvm::to_string(*Root));
   vlog("Dex query tree: {0}", *Root);
 
   using IDAndScore = std::pair<DocID, float>;
   std::vector<IDAndScore> IDAndScores = consume(*Root);
 
   auto Compare = [](const IDAndScore &LHS, const IDAndScore &RHS) {

clang-tools-extra/trunk/clangd/index/dex/Iterator.h

public:
   /// ChildN is N-th iterator child. Raw iterators over PostingList are
   /// represented as "[... CurID ...]" where CurID is the current PostingList
   /// entry being inspected.
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                        const Iterator &Iterator) {
     return Iterator.dump(OS);
   }
 
-  constexpr static float DEFAULT_BOOST_SCORE = 1;
-
 private:
   virtual llvm::raw_ostream &dump(llvm::raw_ostream &OS) const = 0;
 };
 
 /// Advances the iterator until it is exhausted. Returns pairs of document IDs
 /// with the corresponding boosting score.
 ///
 /// Boosting can be seen as a compromise between retrieving too many items and
 /// calculating finals score for each of them (which might be very expensive)
 /// and not retrieving enough items so that items with very high final score
 /// would not be processed. Boosting score is a computationally efficient way
 /// to acquire preliminary scores of requested items.
 std::vector<std::pair<DocID, float>> consume(Iterator &It);
 
-/// Returns AND Iterator which performs the intersection of the PostingLists of
-/// its children.
+namespace detail {
+// Variadic template machinery.
+inline void populateChildren(std::vector<std::unique_ptr<Iterator>> &) {}
+template <typename... TailT>
+void populateChildren(std::vector<std::unique_ptr<Iterator>> &Children,
+                      std::unique_ptr<Iterator> Head, TailT... Tail) {
+  Children.push_back(move(Head));
+  populateChildren(Children, move(Tail)...);
+}
+} // namespace detail
+
+// A corpus is a set of documents, and a factory for iterators over them.
+class Corpus {
+  DocID Size;
+
+public:
+  explicit Corpus(DocID Size) : Size(Size) {}
+
+  /// Returns AND Iterator which performs the intersection of the PostingLists
+  /// of its children.
   ///
-/// consume(): AND Iterator returns the product of Childrens' boosting scores
-/// when not exhausted and DEFAULT_BOOST_SCORE otherwise.
+  /// consume(): AND Iterator returns the product of Childrens' boosting
+  /// scores.
   std::unique_ptr<Iterator>
-createAnd(std::vector<std::unique_ptr<Iterator>> Children);
+  intersect(std::vector<std::unique_ptr<Iterator>> Children) const;
 
   /// Returns OR Iterator which performs the union of the PostingLists of its
   /// children.
   ///
   /// consume(): OR Iterator returns the highest boost value among children
-/// pointing to requested item when not exhausted and DEFAULT_BOOST_SCORE
-/// otherwise.
+  /// containing the requested item.
   std::unique_ptr<Iterator>
-createOr(std::vector<std::unique_ptr<Iterator>> Children);
+  unionOf(std::vector<std::unique_ptr<Iterator>> Children) const;
 
-/// Returns TRUE Iterator which iterates over "virtual" PostingList containing
-/// all items in range [0, Size) in an efficient manner.
-///
-/// TRUE returns DEFAULT_BOOST_SCORE for each processed item.
-std::unique_ptr<Iterator> createTrue(DocID Size);
+  /// Returns TRUE Iterator which iterates over "virtual" PostingList
+  /// containing all items in range [0, Size) in an efficient manner.
+  std::unique_ptr<Iterator> all() const;
 
   /// Returns BOOST iterator which multiplies the score of each item by given
   /// factor. Boosting can be used as a computationally inexpensive filtering.
-/// Users can return significantly more items using consumeAndBoost() and then
-/// trim Top K using retrieval score.
-std::unique_ptr<Iterator> createBoost(std::unique_ptr<Iterator> Child,
-                                      float Factor);
-
-/// Returns LIMIT iterator, which yields up to N elements of its child iterator.
-/// Elements only count towards the limit if they are part of the final result
-/// set. Therefore the following iterator (AND (2) (LIMIT (1 2) 1)) yields (2),
-/// not ().
-std::unique_ptr<Iterator> createLimit(std::unique_ptr<Iterator> Child,
-                                      size_t Limit);
-
-/// This allows createAnd(create(...), create(...)) syntax.
-template <typename... Args> std::unique_ptr<Iterator> createAnd(Args... args) {
+  /// Users can return significantly more items using consumeAndBoost() and
+  /// then trim Top K using retrieval score.
+  std::unique_ptr<Iterator> boost(std::unique_ptr<Iterator> Child,
+                                  float Factor) const;
+
+  /// Returns LIMIT iterator, which yields up to N elements of its child
+  /// iterator. Elements only count towards the limit if they are part of the
+  /// final result set. Therefore the following iterator (AND (2) (LIMIT (1 2)
+  /// 1)) yields (2), not ().
+  std::unique_ptr<Iterator> limit(std::unique_ptr<Iterator> Child,
+                                  size_t Limit) const;
+
+  /// This allows intersect(create(...), create(...)) syntax.
+  template <typename... Args>
+  std::unique_ptr<Iterator> intersect(Args... args) const {
     std::vector<std::unique_ptr<Iterator>> Children;
-  populateChildren(Children, args...);
-  return createAnd(move(Children));
+    detail::populateChildren(Children, std::forward<Args>(args)...);
+    return intersect(move(Children));
   }
 
-/// This allows createOr(create(...), create(...)) syntax.
-template <typename... Args> std::unique_ptr<Iterator> createOr(Args... args) {
+  /// This allows unionOf(create(...), create(...)) syntax.
+  template <typename... Args>
+  std::unique_ptr<Iterator> unionOf(Args... args) const {
     std::vector<std::unique_ptr<Iterator>> Children;
-  populateChildren(Children, args...);
-  return createOr(move(Children));
-}
-
-template <typename HeadT, typename... TailT>
-void populateChildren(std::vector<std::unique_ptr<Iterator>> &Children,
-                      HeadT &Head, TailT &... Tail) {
-  Children.push_back(move(Head));
-  populateChildren(Children, Tail...);
-}
-
-template <typename HeadT>
-void populateChildren(std::vector<std::unique_ptr<Iterator>> &Children,
-                      HeadT &Head) {
-  Children.push_back(move(Head));
+    detail::populateChildren(Children, std::forward<Args>(args)...);
+    return unionOf(move(Children));
   }
+};
 
 } // namespace dex
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_ITERATOR_H

clang-tools-extra/trunk/clangd/index/dex/Iterator.cpp

void advanceTo(DocID ID) override {
     Children.front()->advanceTo(ID);
     sync();
   }
 
   DocID peek() const override { return Children.front()->peek(); }
 
   float consume() override {
     assert(!reachedEnd() && "AND iterator can't consume() at the end.");
-    float Boost = DEFAULT_BOOST_SCORE;
+    float Boost = 1;
     for (const auto &Child : Children)
       Boost *= Child->consume();
     return Boost;
   }
 
   size_t estimateSize() const override {
     return Children.front()->estimateSize();
   }
DocID peek() const override {
 
     for (const auto &Child : Children)
       if (!Child->reachedEnd())
         Result = std::min(Result, Child->peek());
 
     return Result;
   }
 
-  // Returns the maximum boosting score among all Children when iterator is not
-  // exhausted and points to the given ID, DEFAULT_BOOST_SCORE otherwise.
+  // Returns the maximum boosting score among all Children when iterator
+  // points to the current ID.
   float consume() override {
     assert(!reachedEnd() && "OR iterator can't consume() at the end.");
     const DocID ID = peek();
-    float Boost = DEFAULT_BOOST_SCORE;
+    float Boost = 1;
     for (const auto &Child : Children)
       if (!Child->reachedEnd() && Child->peek() == ID)
         Boost = std::max(Boost, Child->consume());
     return Boost;
   }
 
   size_t estimateSize() const override {
     size_t Size = 0;
public:
 
   DocID peek() const override {
     assert(!reachedEnd() && "TRUE iterator can't peek() at the end.");
     return Index;
   }
 
   float consume() override {
     assert(!reachedEnd() && "TRUE iterator can't consume() at the end.");
-    return DEFAULT_BOOST_SCORE;
+    return 1;
   }
 
   size_t estimateSize() const override { return Size; }
 
 private:
   llvm::raw_ostream &dump(llvm::raw_ostream &OS) const override {
     return OS << "true";
   }

 std::vector<std::pair<DocID, float>> consume(Iterator &It) {
   std::vector<std::pair<DocID, float>> Result;
   for (; !It.reachedEnd(); It.advance())
     Result.emplace_back(It.peek(), It.consume());
   return Result;
 }
 
 std::unique_ptr<Iterator>
-createAnd(std::vector<std::unique_ptr<Iterator>> Children) {
+Corpus::intersect(std::vector<std::unique_ptr<Iterator>> Children) const {
   // If there is exactly one child, pull it one level up: AND(Child) -> Child.
   return Children.size() == 1 ? std::move(Children.front())
                               : llvm::make_unique<AndIterator>(move(Children));
 }
 
 std::unique_ptr<Iterator>
-createOr(std::vector<std::unique_ptr<Iterator>> Children) {
+Corpus::unionOf(std::vector<std::unique_ptr<Iterator>> Children) const {
   // If there is exactly one child, pull it one level up: OR(Child) -> Child.
   return Children.size() == 1 ? std::move(Children.front())
                               : llvm::make_unique<OrIterator>(move(Children));
 }
 
-std::unique_ptr<Iterator> createTrue(DocID Size) {
+std::unique_ptr<Iterator> Corpus::all() const {
   return llvm::make_unique<TrueIterator>(Size);
 }
 
-std::unique_ptr<Iterator> createBoost(std::unique_ptr<Iterator> Child,
-                                      float Factor) {
+std::unique_ptr<Iterator> Corpus::boost(std::unique_ptr<Iterator> Child,
+                                        float Factor) const {
   return llvm::make_unique<BoostIterator>(move(Child), Factor);
 }
 
-std::unique_ptr<Iterator> createLimit(std::unique_ptr<Iterator> Child,
-                                      size_t Limit) {
+std::unique_ptr<Iterator> Corpus::limit(std::unique_ptr<Iterator> Child,
+                                        size_t Limit) const {
   return llvm::make_unique<LimitIterator>(move(Child), Limit);
 }
 
 } // namespace dex
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/clangd/index/dex/PostingList.cpp

public:
   DocID peek() const override {
     assert(!reachedEnd() && "Posting List iterator can't peek() at the end.");
     return *CurrentID;
   }
 
   float consume() override {
     assert(!reachedEnd() &&
            "Posting List iterator can't consume() at the end.");
-    return DEFAULT_BOOST_SCORE;
+    return 1;
   }
 
   size_t estimateSize() const override {
     return Chunks.size() * ApproxEntriesPerChunk;
   }
 
 private:
   llvm::raw_ostream &dump(llvm::raw_ostream &OS) const override {

clang-tools-extra/trunk/unittests/clangd/DexTests.cpp

TEST(DexIterators, DocumentIterator) {
   EXPECT_EQ(DocIterator->peek(), 100U);
   EXPECT_FALSE(DocIterator->reachedEnd());
 
   DocIterator->advanceTo(420);
   EXPECT_TRUE(DocIterator->reachedEnd());
 }
 
 TEST(DexIterators, AndTwoLists) {
+  Corpus C{10000};
   const PostingList L0({0, 5, 7, 10, 42, 320, 9000});
   const PostingList L1({0, 4, 7, 10, 30, 60, 320, 9000});
 
-  auto And = createAnd(L1.iterator(), L0.iterator());
+  auto And = C.intersect(L1.iterator(), L0.iterator());
 
   EXPECT_FALSE(And->reachedEnd());
   EXPECT_THAT(consumeIDs(*And), ElementsAre(0U, 7U, 10U, 320U, 9000U));
 
-  And = createAnd(L0.iterator(), L1.iterator());
+  And = C.intersect(L0.iterator(), L1.iterator());
 
   And->advanceTo(0);
   EXPECT_EQ(And->peek(), 0U);
   And->advanceTo(5);
   EXPECT_EQ(And->peek(), 7U);
   And->advanceTo(10);
   EXPECT_EQ(And->peek(), 10U);
   And->advanceTo(42);
   EXPECT_EQ(And->peek(), 320U);
   And->advanceTo(8999);
   EXPECT_EQ(And->peek(), 9000U);
   And->advanceTo(9001);
 }
 
 TEST(DexIterators, AndThreeLists) {
+  Corpus C{10000};
   const PostingList L0({0, 5, 7, 10, 42, 320, 9000});
   const PostingList L1({0, 4, 7, 10, 30, 60, 320, 9000});
   const PostingList L2({1, 4, 7, 11, 30, 60, 320, 9000});
 
-  auto And = createAnd(L0.iterator(), L1.iterator(), L2.iterator());
+  auto And = C.intersect(L0.iterator(), L1.iterator(), L2.iterator());
   EXPECT_EQ(And->peek(), 7U);
   And->advanceTo(300);
   EXPECT_EQ(And->peek(), 320U);
   And->advanceTo(100000);
 
   EXPECT_TRUE(And->reachedEnd());
 }
 
 TEST(DexIterators, OrTwoLists) {
+  Corpus C{10000};
   const PostingList L0({0, 5, 7, 10, 42, 320, 9000});
   const PostingList L1({0, 4, 7, 10, 30, 60, 320, 9000});
 
-  auto Or = createOr(L0.iterator(), L1.iterator());
+  auto Or = C.unionOf(L0.iterator(), L1.iterator());
 
   EXPECT_FALSE(Or->reachedEnd());
   EXPECT_EQ(Or->peek(), 0U);
   Or->advance();
   EXPECT_EQ(Or->peek(), 4U);
   Or->advance();
   EXPECT_EQ(Or->peek(), 5U);
   Or->advance();
   EXPECT_EQ(Or->peek(), 7U);
   Or->advance();
   EXPECT_EQ(Or->peek(), 10U);
   Or->advance();
   EXPECT_EQ(Or->peek(), 30U);
   Or->advanceTo(42);
   EXPECT_EQ(Or->peek(), 42U);
   Or->advanceTo(300);
   EXPECT_EQ(Or->peek(), 320U);
   Or->advanceTo(9000);
   EXPECT_EQ(Or->peek(), 9000U);
   Or->advanceTo(9001);
   EXPECT_TRUE(Or->reachedEnd());
 
-  Or = createOr(L0.iterator(), L1.iterator());
+  Or = C.unionOf(L0.iterator(), L1.iterator());
 
   EXPECT_THAT(consumeIDs(*Or),
               ElementsAre(0U, 4U, 5U, 7U, 10U, 30U, 42U, 60U, 320U, 9000U));
 }
 
 TEST(DexIterators, OrThreeLists) {
+  Corpus C{10000};
   const PostingList L0({0, 5, 7, 10, 42, 320, 9000});
   const PostingList L1({0, 4, 7, 10, 30, 60, 320, 9000});
   const PostingList L2({1, 4, 7, 11, 30, 60, 320, 9000});
 
-  auto Or = createOr(L0.iterator(), L1.iterator(), L2.iterator());
+  auto Or = C.unionOf(L0.iterator(), L1.iterator(), L2.iterator());
 
   EXPECT_FALSE(Or->reachedEnd());
   EXPECT_EQ(Or->peek(), 0U);
 
   Or->advance();
   EXPECT_EQ(Or->peek(), 1U);
 
   Or->advance();
TEST(DexIterators, QueryTree) {
   //  +-------v-----+ +----+---+                +---v----+ +----v---+
   //  |1, 3, 5, 8, 9| |Boost: 2|                |Boost: 3| |Boost: 4|
   //  +-------------+ +----+---+                +---+----+ +----+---+
   //                       |                        |           |
   //                  +----v-----+                +-v--+    +---v---+
   //                  |1, 5, 7, 9|                |1, 5|    |0, 3, 5|
   //                  +----------+                +----+    +-------+
   //
+  Corpus C{10};
   const PostingList L0({1, 3, 5, 8, 9});
   const PostingList L1({1, 5, 7, 9});
   const PostingList L2({1, 5});
   const PostingList L3({0, 3, 5});
 
   // Root of the query tree: [1, 5]
-  auto Root = createAnd(
+  auto Root = C.intersect(
       // Lower And Iterator: [1, 5, 9]
-      createAnd(L0.iterator(), createBoost(L1.iterator(), 2U)),
+      C.intersect(L0.iterator(), C.boost(L1.iterator(), 2U)),
       // Lower Or Iterator: [0, 1, 5]
-      createOr(createBoost(L2.iterator(), 3U), createBoost(L3.iterator(), 4U)));
+      C.unionOf(C.boost(L2.iterator(), 3U), C.boost(L3.iterator(), 4U)));
 
   EXPECT_FALSE(Root->reachedEnd());
   EXPECT_EQ(Root->peek(), 1U);
   Root->advanceTo(0);
   // Advance multiple times. Shouldn't do anything.
   Root->advanceTo(1);
   Root->advanceTo(0);
   EXPECT_EQ(Root->peek(), 1U);
   auto ElementBoost = Root->consume();
   EXPECT_THAT(ElementBoost, 6);
   Root->advance();
   EXPECT_EQ(Root->peek(), 5U);
   Root->advanceTo(5);
   EXPECT_EQ(Root->peek(), 5U);
   ElementBoost = Root->consume();
   EXPECT_THAT(ElementBoost, 8);
   Root->advanceTo(9000);
   EXPECT_TRUE(Root->reachedEnd());
 }
 
 TEST(DexIterators, StringRepresentation) {
+  Corpus C{10};
   const PostingList L1({1, 3, 5});
   const PostingList L2({1, 7, 9});
 
   // No token given, prints full posting list.
   auto I1 = L1.iterator();
   EXPECT_EQ(llvm::to_string(*I1), "[1 3 5]");
 
   // Token given, uses token's string representation.
   Token Tok(Token::Kind::Trigram, "L2");
   auto I2 = L1.iterator(&Tok);
   EXPECT_EQ(llvm::to_string(*I2), "T=L2");
 
-  auto Tree = createLimit(createAnd(move(I1), move(I2)), 10);
+  auto Tree = C.limit(C.intersect(move(I1), move(I2)), 10);
   EXPECT_EQ(llvm::to_string(*Tree), "(LIMIT 10 (& [1 3 5] T=L2))");
 }
 
 TEST(DexIterators, Limit) {
+  Corpus C{10000};
   const PostingList L0({3, 6, 7, 20, 42, 100});
   const PostingList L1({1, 3, 5, 6, 7, 30, 100});
   const PostingList L2({0, 3, 5, 7, 8, 100});
 
-  auto DocIterator = createLimit(L0.iterator(), 42);
+  auto DocIterator = C.limit(L0.iterator(), 42);
   EXPECT_THAT(consumeIDs(*DocIterator), ElementsAre(3, 6, 7, 20, 42, 100));
 
-  DocIterator = createLimit(L0.iterator(), 3);
+  DocIterator = C.limit(L0.iterator(), 3);
   EXPECT_THAT(consumeIDs(*DocIterator), ElementsAre(3, 6, 7));
 
-  DocIterator = createLimit(L0.iterator(), 0);
+  DocIterator = C.limit(L0.iterator(), 0);
   EXPECT_THAT(consumeIDs(*DocIterator), ElementsAre());
 
-  auto AndIterator = createAnd(
-      createLimit(createTrue(9000), 343), createLimit(L0.iterator(), 2),
-      createLimit(L1.iterator(), 3), createLimit(L2.iterator(), 42));
+  auto AndIterator =
+      C.intersect(C.limit(C.all(), 343), C.limit(L0.iterator(), 2),
+                  C.limit(L1.iterator(), 3), C.limit(L2.iterator(), 42));
   EXPECT_THAT(consumeIDs(*AndIterator), ElementsAre(3, 7));
 }
 
 TEST(DexIterators, True) {
-  auto TrueIterator = createTrue(0U);
+  Corpus C{0};
+  auto TrueIterator = C.all();
   EXPECT_TRUE(TrueIterator->reachedEnd());
   EXPECT_THAT(consumeIDs(*TrueIterator), ElementsAre());
 
+  C = Corpus{7};
   const PostingList L0({1, 2, 5, 7});
-  TrueIterator = createTrue(7U);
+  TrueIterator = C.all();
   EXPECT_THAT(TrueIterator->peek(), 0);
-  auto AndIterator = createAnd(L0.iterator(), move(TrueIterator));
+  auto AndIterator = C.intersect(L0.iterator(), move(TrueIterator));
   EXPECT_FALSE(AndIterator->reachedEnd());
   EXPECT_THAT(consumeIDs(*AndIterator), ElementsAre(1, 2, 5));
 }
 
 TEST(DexIterators, Boost) {
-  auto BoostIterator = createBoost(createTrue(5U), 42U);
+  Corpus C{5};
+  auto BoostIterator = C.boost(C.all(), 42U);
   EXPECT_FALSE(BoostIterator->reachedEnd());
   auto ElementBoost = BoostIterator->consume();
   EXPECT_THAT(ElementBoost, 42U);
 
   const PostingList L0({2, 4});
   const PostingList L1({1, 4});
-  auto Root = createOr(createTrue(5U), createBoost(L0.iterator(), 2U),
-                       createBoost(L1.iterator(), 3U));
+  auto Root = C.unionOf(C.all(), C.boost(L0.iterator(), 2U),
+                        C.boost(L1.iterator(), 3U));
 
   ElementBoost = Root->consume();
-  EXPECT_THAT(ElementBoost, Iterator::DEFAULT_BOOST_SCORE);
+  EXPECT_THAT(ElementBoost, 1);
   Root->advance();
   EXPECT_THAT(Root->peek(), 1U);
   ElementBoost = Root->consume();
   EXPECT_THAT(ElementBoost, 3);
 
   Root->advance();
   EXPECT_THAT(Root->peek(), 2U);
   ElementBoost = Root->consume();