[clangd] NFC: mark single-parameter constructors explicit

[kbobyrev]

Summary

Code health: prevent implicit conversions to user-defined types.

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

 
 namespace {
 
 /// Implements Iterator over a PostingList. DocumentIterator is the most basic
 /// iterator: it doesn't have any children (hence it is the leaf of iterator
 /// tree) and is simply a wrapper around PostingList::const_iterator.
 class DocumentIterator : public Iterator {
 public:
-  DocumentIterator(PostingListRef Documents)
+  explicit DocumentIterator(PostingListRef Documents)
       : Documents(Documents), Index(std::begin(Documents)) {}
 
   bool reachedEnd() const override { return Index == std::end(Documents); }
 
   /// Advances cursor to the next item.
   void advance() override {
     assert(!reachedEnd() && "DOCUMENT iterator can't advance() at the end.");
     ++Index;

 
 /// Implements Iterator over the intersection of other iterators.
 ///
 /// AndIterator iterates through common items among all children. It becomes
 /// exhausted as soon as any child becomes exhausted. After each mutation, the
 /// iterator restores the invariant: all children must point to the same item.
 class AndIterator : public Iterator {
 public:
-  AndIterator(std::vector<std::unique_ptr<Iterator>> AllChildren)
+  explicit AndIterator(std::vector<std::unique_ptr<Iterator>> AllChildren)
       : Children(std::move(AllChildren)) {
     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
     // effective. Each sync() starts with the first child and makes sure all
     // children point to the same element. If any child is "above" the previous
     // ones, the algorithm resets and and advances the children to the next

 /// Implements Iterator over the union of other iterators.
 ///
 /// OrIterator iterates through all items which can be pointed to by at least
 /// one child. To preserve the sorted order, this iterator always advances the
 /// child with smallest Child->peek() value. OrIterator becomes exhausted as
 /// soon as all of its children are exhausted.
 class OrIterator : public Iterator {
 public:
-  OrIterator(std::vector<std::unique_ptr<Iterator>> AllChildren)
+  explicit OrIterator(std::vector<std::unique_ptr<Iterator>> AllChildren)
       : Children(std::move(AllChildren)) {
     assert(Children.size() > 0 && "OR iterator must have at least one child.");
   }
 
   /// Returns true if all children are exhausted.
   bool reachedEnd() const override {
     return std::all_of(begin(Children), end(Children),
                        [](const std::unique_ptr<Iterator> &Child) {
private:
   std::vector<std::unique_ptr<Iterator>> Children;
 };
 
 /// TrueIterator handles PostingLists which contain all items of the index. It
 /// stores size of the virtual posting list, and all operations are performed
 /// in O(1).
 class TrueIterator : public Iterator {
 public:
-  TrueIterator(DocID Size) : Size(Size) {}
+  explicit TrueIterator(DocID Size) : Size(Size) {}
 
   bool reachedEnd() const override { return Index >= Size; }
 
   void advance() override {
     assert(!reachedEnd() && "TRUE iterator can't advance() at the end.");
     ++Index;
   }