Replace uses of std::iterator with explicit using

This patch removes all uses of `std::iterator`, which was deprecated in C++17.
While this isn't currently an issue while compiling LLVM, it's useful for those using LLVM as a library.

For some reason there're a few places that were seemingly able to use `std` functions unqualified, which no longer works after this patch. I've updated those places, but I'm not really sure why it worked in the first place.

Reviewed By: MaskRay

Differential Revision: https://reviews.llvm.org/D67586

Author: hamzasood

clang/include/clang/AST/StmtIterator.h

@@ -74,14 +74,17 @@ class StmtIteratorBase {
 };
 
 template <typename DERIVED, typename REFERENCE>
-class StmtIteratorImpl : public StmtIteratorBase,
-                         public std::iterator<std::forward_iterator_tag,
-                                              REFERENCE, ptrdiff_t,
-                                              REFERENCE, REFERENCE> {
+class StmtIteratorImpl : public StmtIteratorBase {
 protected:
   StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {}
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = REFERENCE;
+  using difference_type = std::ptrdiff_t;
+  using pointer = REFERENCE;
+  using reference = REFERENCE;
+
   StmtIteratorImpl() = default;
   StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {}
   StmtIteratorImpl(Decl **dgi, Decl **dge) : StmtIteratorBase(dgi, dge) {}

clang/include/clang/Rewrite/Core/RewriteRope.h

@@ -83,8 +83,7 @@ namespace clang {
   /// over bytes that are in a RopePieceBTree.  This first iterates over bytes
   /// in a RopePiece, then iterates over RopePiece's in a RopePieceBTreeLeaf,
   /// then iterates over RopePieceBTreeLeaf's in a RopePieceBTree.
-  class RopePieceBTreeIterator :
-      public std::iterator<std::forward_iterator_tag, const char, ptrdiff_t> {
+  class RopePieceBTreeIterator {
     /// CurNode - The current B+Tree node that we are inspecting.
     const void /*RopePieceBTreeLeaf*/ *CurNode = nullptr;
 
@@ -96,6 +95,12 @@ namespace clang {
     unsigned CurChar = 0;
 
   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = const char;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     RopePieceBTreeIterator() = default;
     RopePieceBTreeIterator(const void /*RopePieceBTreeNode*/ *N);
 

llvm/include/llvm/ADT/BreadthFirstIterator.h

@@ -44,11 +44,15 @@ template <class GraphT,
           class SetType =
               bf_iterator_default_set<typename GraphTraits<GraphT>::NodeRef>,
           class GT = GraphTraits<GraphT>>
-class bf_iterator
-    : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>,
-      public bf_iterator_storage<SetType> {
-  using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>;
+class bf_iterator : public bf_iterator_storage<SetType> {
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = typename GT::NodeRef;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
 
+private:
   using NodeRef = typename GT::NodeRef;
   using ChildItTy = typename GT::ChildIteratorType;
 
@@ -62,7 +66,6 @@ class bf_iterator
   // Current level.
   unsigned Level;
 
-private:
   inline bf_iterator(NodeRef Node) {
     this->Visited.insert(Node);
     Level = 0;
@@ -107,8 +110,6 @@ class bf_iterator
   }
 
 public:
-  using pointer = typename super::pointer;
-
   // Provide static begin and end methods as our public "constructors"
   static bf_iterator begin(const GraphT &G) {
     return bf_iterator(GT::getEntryNode(G));

llvm/include/llvm/ADT/CoalescingBitVector.h

@@ -231,10 +231,17 @@ template <typename IndexT> class CoalescingBitVector {
 
   bool operator!=(const ThisT &RHS) const { return !operator==(RHS); }
 
-  class const_iterator
-      : public std::iterator<std::forward_iterator_tag, IndexT> {
+  class const_iterator {
     friend class CoalescingBitVector;
 
+  public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = IndexT;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+  private:
     // For performance reasons, make the offset at the end different than the
     // one used in \ref begin, to optimize the common `It == end()` pattern.
     static constexpr unsigned kIteratorAtTheEndOffset = ~0u;

llvm/include/llvm/ADT/DepthFirstIterator.h

@@ -82,10 +82,15 @@ template <class GraphT,
           class SetType =
               df_iterator_default_set<typename GraphTraits<GraphT>::NodeRef>,
           bool ExtStorage = false, class GT = GraphTraits<GraphT>>
-class df_iterator
-    : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>,
-      public df_iterator_storage<SetType, ExtStorage> {
-  using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>;
+class df_iterator : public df_iterator_storage<SetType, ExtStorage> {
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = typename GT::NodeRef;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
+private:
   using NodeRef = typename GT::NodeRef;
   using ChildItTy = typename GT::ChildIteratorType;
 
@@ -97,7 +102,6 @@ class df_iterator
   // VisitStack - Used to maintain the ordering.  Top = current block
   std::vector<StackElement> VisitStack;
 
-private:
   inline df_iterator(NodeRef Node) {
     this->Visited.insert(Node);
     VisitStack.push_back(StackElement(Node, None));
@@ -144,8 +148,6 @@ class df_iterator
   }
 
 public:
-  using pointer = typename super::pointer;
-
   // Provide static begin and end methods as our public "constructors"
   static df_iterator begin(const GraphT &G) {
     return df_iterator(GT::getEntryNode(G));

llvm/include/llvm/ADT/EquivalenceClasses.h

@@ -248,19 +248,18 @@ class EquivalenceClasses {
     return It != member_end() && It == findLeader(V2);
   }
 
-  class member_iterator : public std::iterator<std::forward_iterator_tag,
-                                               const ElemTy, ptrdiff_t> {
+  class member_iterator {
     friend class EquivalenceClasses;
 
-    using super = std::iterator<std::forward_iterator_tag,
-                                const ElemTy, ptrdiff_t>;
-
     const ECValue *Node;
 
   public:
-    using size_type = size_t;
-    using pointer = typename super::pointer;
-    using reference = typename super::reference;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = const ElemTy;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
 
     explicit member_iterator() = default;
     explicit member_iterator(const ECValue *N) : Node(N) {}

llvm/include/llvm/ADT/ImmutableSet.h

@@ -651,13 +651,16 @@ class ImutAVLFactory {
 // Immutable AVL-Tree Iterators.
 //===----------------------------------------------------------------------===//
 
-template <typename ImutInfo>
-class ImutAVLTreeGenericIterator
-    : public std::iterator<std::bidirectional_iterator_tag,
-                           ImutAVLTree<ImutInfo>> {
+template <typename ImutInfo> class ImutAVLTreeGenericIterator {
   SmallVector<uintptr_t,20> stack;
 
 public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type = ImutAVLTree<ImutInfo>;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3,
                    Flags=0x3 };
 
@@ -762,15 +765,18 @@ class ImutAVLTreeGenericIterator
   }
 };
 
-template <typename ImutInfo>
-class ImutAVLTreeInOrderIterator
-    : public std::iterator<std::bidirectional_iterator_tag,
-                           ImutAVLTree<ImutInfo>> {
+template <typename ImutInfo> class ImutAVLTreeInOrderIterator {
   using InternalIteratorTy = ImutAVLTreeGenericIterator<ImutInfo>;
 
   InternalIteratorTy InternalItr;
 
 public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type = ImutAVLTree<ImutInfo>;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   using TreeTy = ImutAVLTree<ImutInfo>;
 
   ImutAVLTreeInOrderIterator(const TreeTy* Root) : InternalItr(Root) {

llvm/include/llvm/ADT/IntervalMap.h

@@ -63,9 +63,14 @@
 // };
 //
 // template <typename KeyT, typename ValT, unsigned N, typename Traits>
-// class IntervalMap::const_iterator :
-//   public std::iterator<std::bidirectional_iterator_tag, ValT> {
+// class IntervalMap::const_iterator {
 // public:
+//   using iterator_category = std::bidirectional_iterator_tag;
+//   using value_type = ValT;
+//   using difference_type = std::ptrdiff_t;
+//   using pointer = value_type *;
+//   using reference = value_type &;
+//
 //   bool operator==(const const_iterator &) const;
 //   bool operator!=(const const_iterator &) const;
 //   bool valid() const;
@@ -1289,12 +1294,17 @@ clear() {
 //===----------------------------------------------------------------------===//
 
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
-class IntervalMap<KeyT, ValT, N, Traits>::const_iterator :
-  public std::iterator<std::bidirectional_iterator_tag, ValT> {
-
-protected:
+class IntervalMap<KeyT, ValT, N, Traits>::const_iterator {
   friend class IntervalMap;
 
+public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type = ValT;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
+protected:
   // The map referred to.
   IntervalMap *map = nullptr;
 

llvm/include/llvm/ADT/PostOrderIterator.h

@@ -90,13 +90,17 @@ class po_iterator_storage<SetType, true> {
 };
 
 template <class GraphT,
-          class SetType =
-              SmallPtrSet<typename GraphTraits<GraphT>::NodeRef, 8>,
+          class SetType = SmallPtrSet<typename GraphTraits<GraphT>::NodeRef, 8>,
           bool ExtStorage = false, class GT = GraphTraits<GraphT>>
-class po_iterator
-    : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>,
-      public po_iterator_storage<SetType, ExtStorage> {
-  using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>;
+class po_iterator : public po_iterator_storage<SetType, ExtStorage> {
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = typename GT::NodeRef;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
+private:
   using NodeRef = typename GT::NodeRef;
   using ChildItTy = typename GT::ChildIteratorType;
 
@@ -135,8 +139,6 @@ class po_iterator
   }
 
 public:
-  using pointer = typename super::pointer;
-
   // Provide static "constructors"...
   static po_iterator begin(GraphT G) {
     return po_iterator(GT::getEntryNode(G));

llvm/include/llvm/ADT/SparseMultiSet.h

@@ -216,11 +216,17 @@ class SparseMultiSet {
 
   /// Our iterators are iterators over the collection of objects that share a
   /// key.
-  template<typename SMSPtrTy>
-  class iterator_base : public std::iterator<std::bidirectional_iterator_tag,
-                                             ValueT> {
+  template <typename SMSPtrTy> class iterator_base {
     friend class SparseMultiSet;
 
+  public:
+    using iterator_category = std::bidirectional_iterator_tag;
+    using value_type = ValueT;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+  private:
     SMSPtrTy SMS;
     unsigned Idx;
     unsigned SparseIdx;
@@ -247,12 +253,6 @@ class SparseMultiSet {
     void setNext(unsigned N) { SMS->Dense[Idx].Next = N; }
 
   public:
-    using super = std::iterator<std::bidirectional_iterator_tag, ValueT>;
-    using value_type = typename super::value_type;
-    using difference_type = typename super::difference_type;
-    using pointer = typename super::pointer;
-    using reference = typename super::reference;
-
     reference operator*() const {
       assert(isKeyed() && SMS->sparseIndex(SMS->Dense[Idx].Data) == SparseIdx &&
              "Dereferencing iterator of invalid key or index");
@@ -411,7 +411,7 @@ class SparseMultiSet {
   RangePair equal_range(const KeyT &K) {
     iterator B = find(K);
     iterator E = iterator(this, SMSNode::INVALID, B.SparseIdx);
-    return make_pair(B, E);
+    return std::make_pair(B, E);
   }
 
   /// Insert a new element at the tail of the subset list. Returns an iterator

llvm/include/llvm/ADT/iterator.h

@@ -64,9 +64,14 @@ namespace llvm {
 template <typename DerivedT, typename IteratorCategoryT, typename T,
           typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *,
           typename ReferenceT = T &>
-class iterator_facade_base
-    : public std::iterator<IteratorCategoryT, T, DifferenceTypeT, PointerT,
-                           ReferenceT> {
+class iterator_facade_base {
+public:
+  using iterator_category = IteratorCategoryT;
+  using value_type = T;
+  using difference_type = DifferenceTypeT;
+  using pointer = PointerT;
+  using reference = ReferenceT;
+
 protected:
   enum {
     IsRandomAccess = std::is_base_of<std::random_access_iterator_tag,

llvm/include/llvm/Analysis/AliasSetTracker.h

@@ -232,11 +232,16 @@ class AliasSet : public ilist_node<AliasSet> {
   void dump() const;
 
   /// Define an iterator for alias sets... this is just a forward iterator.
-  class iterator : public std::iterator<std::forward_iterator_tag,
-                                        PointerRec, ptrdiff_t> {
+  class iterator {
     PointerRec *CurNode;
 
   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = PointerRec;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     explicit iterator(PointerRec *CN = nullptr) : CurNode(CN) {}
 
     bool operator==(const iterator& x) const {

llvm/include/llvm/Analysis/MemorySSA.h

@@ -1100,7 +1100,7 @@ class memoryaccess_def_iterator_base
     return MP->getIncomingBlock(ArgNo);
   }
 
-  typename BaseT::iterator::pointer operator*() const {
+  typename std::iterator_traits<BaseT>::pointer operator*() const {
     assert(Access && "Tried to access past the end of our iterator");
     // Go to the first argument for phis, and the defining access for everything
     // else.
@@ -1196,7 +1196,7 @@ class upward_defs_iterator
     return DefIterator == Other.DefIterator;
   }
 
-  BaseT::iterator::reference operator*() const {
+  typename std::iterator_traits<BaseT>::reference operator*() const {
     assert(DefIterator != OriginalAccess->defs_end() &&
            "Tried to access past the end of our iterator");
     return CurrentPair;