Replace uses of std::iterator with explicit using

[hamzasood]

Summary

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.

[hamzasood]

I just realised that the unqualified calls worked because a base class of type std::iterator means that functions in namespace std will be found by ADL. So you can ignore the last paragraph in the patch summary.

[MaskRay]

Looks good!

// P0174
Update from Jacksonville, 2016:

Poll: Deprecate iterator for C++17??

SF	F	N	A	SA
6	10	1	0	0

In D67586#1670541, @hamzasood wrote:

I just realised that the unqualified calls worked because a base class of type std::iterator means that functions in namespace std will be found by ADL. So you can ignore the last paragraph in the patch summary.

You can edit the summary to mention that due to the loss of ADL you have to prepend std:: in a few places.

Have you done a check-all (llvm,clang,lldb,lld,etc) to ensure nothing else breaks?

[1whatleytay]

Hey, anything that needs to be done before this PR can be merged (rebase, etc.)? I'd be willing to give it a shot if so 🙂

Otherwise, it'd be nice to be merged...

[1whatleytay]

This comment was removed by 1whatleytay.

[jhenderson]

In D67586#2603763, @1whatleytay wrote:

Hey, anything that needs to be done before this PR can be merged (rebase, etc.)? I'd be willing to give it a shot if so 🙂

Otherwise, it'd be nice to be merged...

Hi @1whatleytay,

The process is usually for the patch author to commit it themselves, once they have commit access. If you don't have commit access, you need to ask one of the people who reviewed your patch (or indeed any other person with commit access), to submit it on your behalf. In order for them to be able to, you'll need to provide them with your email and name for the git log. Once you've contributed a few patches, you can request access for yourself. For full details, see https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

As this patch is quite old, it would likely also be helpful to the person who eventually pushes if you rebase this on the latest main branch.

[hamzasood]

I had no idea that this was left incomplete. I've rebased the patch and applied the same process to some new classes that were added in the meantime.

I don't have commit access anymore after the move to Git, so I'd appreciate it if someone could commit this on my behalf.

[MaskRay]

In D67586#2681723, @hamzasood wrote:

I had no idea that this was left incomplete. I've rebased the patch and applied the same process to some new classes that were added in the meantime.

I don't have commit access anymore after the move to Git, so I'd appreciate it if someone could commit this on my behalf.

I made clang-format fixes. I am testing and will push it on your behalf. Thanks!

clang/include/clang/AST/StmtIterator.h

protected:
   void NextDecl(bool ImmediateAdvance = true);
   bool HandleDecl(Decl* D);
   void NextVA();
 
   Stmt*& GetDeclExpr() const;
 };
 
 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) {}
   StmtIteratorImpl(const VariableArrayType *t) : StmtIteratorBase(t) {}
 
   DERIVED& operator++() {
     if (inStmt())
       ++stmt;

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

namespace clang {
   //===--------------------------------------------------------------------===//
   // RopePieceBTreeIterator Class
   //===--------------------------------------------------------------------===//
 
   /// RopePieceBTreeIterator - This class provides read-only forward iteration
   /// 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;
 
     /// CurPiece - The current RopePiece in the B+Tree node that we're
     /// inspecting.
     const RopePiece *CurPiece = nullptr;
 
     /// CurChar - The current byte in the RopePiece we are pointing to.
     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);
 
     char operator*() const {
       return (*CurPiece)[CurChar];
     }
 
     bool operator==(const RopePieceBTreeIterator &RHS) const {

llvm/include/llvm/ADT/BreadthFirstIterator.h

 template <typename NodeRef, unsigned SmallSize = 8>
 using bf_iterator_default_set = SmallPtrSet<NodeRef, SmallSize>;
 
 // Generic Breadth first search iterator.
 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;
 
   // First element is the node reference, second is the next child to visit.
   using QueueElement = std::pair<NodeRef, Optional<ChildItTy>>;
 
   // Visit queue - used to maintain BFS ordering.
   // Optional<> because we need markers for levels.
   std::queue<Optional<QueueElement>> VisitQueue;
 
   // Current level.
   unsigned Level;
 
-private:
   inline bf_iterator(NodeRef Node) {
     this->Visited.insert(Node);
     Level = 0;
 
     // Also, insert a dummy node as marker.
     VisitQueue.push(QueueElement(Node, None));
     VisitQueue.push(None);
   }
if (!VisitQueue.empty()) {
       // Don't push another marker if this is the last
       // element.
       if (!VisitQueue.empty())
         VisitQueue.push(None);
     }
   }
 
 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));
   }
 
   static bf_iterator end(const GraphT &G) { return bf_iterator(); }
 
   bool operator==(const bf_iterator &RHS) const {

llvm/include/llvm/ADT/CoalescingBitVector.h

while (ItL != Intervals.end() && ItR != RHS.Intervals.end() &&
       ++ItL;
       ++ItR;
     }
     return ItL == Intervals.end() && ItR == RHS.Intervals.end();
   }
 
   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;
 
     UnderlyingIterator MapIterator;
     unsigned OffsetIntoMapIterator = 0;
 
     // Querying the start/stop of an IntervalMap iterator can be very expensive.

llvm/include/llvm/ADT/DepthFirstIterator.h

struct df_iterator_default_set : public SmallPtrSet<NodeRef, SmallSize> {
   void completed(NodeRef) {}
 };
 
 // Generic Depth First Iterator
 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;
 
   // First element is node reference, second is the 'next child' to visit.
   // The second child is initialized lazily to pick up graph changes during the
   // DFS.
   using StackElement = std::pair<NodeRef, Optional<ChildItTy>>;
 
   // 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));
   }
 
   inline df_iterator() = default; // End is when stack is empty
 
   inline df_iterator(NodeRef Node, SetType &S)
do {
       this->Visited.completed(Node);
 
       // Oops, ran out of successors... go up a level on the stack.
       VisitStack.pop_back();
     } while (!VisitStack.empty());
   }
 
 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));
   }
   static df_iterator end(const GraphT &G) { return df_iterator(); }
 
   // Static begin and end methods as our public ctors for external iterators
   static df_iterator begin(const GraphT &G, SetType &S) {

llvm/include/llvm/ADT/EquivalenceClasses.h

public:
   bool isEquivalent(const ElemTy &V1, const ElemTy &V2) const {
     // Fast path: any element is equivalent to itself.
     if (V1 == V2)
       return true;
     auto It = findLeader(V1);
     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) {}
 
     reference operator*() const {
       assert(Node != nullptr && "Dereferencing end()!");
       return Node->getData();
     }

llvm/include/llvm/ADT/ImmutableSet.h

TreeTy *getCanonicalTree(TreeTy *TNew) {
     return TNew;
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Immutable AVL-Tree Iterators.
 //===----------------------------------------------------------------------===//
 
 template <typename ImutInfo>
-class ImutAVLTreeGenericIterator
-    : public std::iterator<std::bidirectional_iterator_tag,
-                           ImutAVLTree<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 };
 
   using TreeTy = ImutAVLTree<ImutInfo>;
 
   ImutAVLTreeGenericIterator() = default;
   ImutAVLTreeGenericIterator(const TreeTy *Root) {
     if (Root) stack.push_back(reinterpret_cast<uintptr_t>(Root));
switch (getVisitState()) {
         break;
       default:
         llvm_unreachable("Unreachable.");
     }
     return *this;
   }
 };
 
 template <typename ImutInfo>
-class ImutAVLTreeInOrderIterator
-    : public std::iterator<std::bidirectional_iterator_tag,
-                           ImutAVLTree<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) {
     if (Root)
       ++*this; // Advance to first element.
   }
 
   ImutAVLTreeInOrderIterator() : InternalItr() {}

llvm/include/llvm/ADT/IntervalMap.h

 //   const_iterator find(KeyT x) const;
 //   iterator find(KeyT x);
 //
 //   void insert(KeyT a, KeyT b, ValT y);
 //   void clear();
 // };
 //
 // 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;
 //
 //   const KeyT &start() const;
 //   const KeyT &stop() const;
 //   const ValT &value() const;
 //   const ValT &operator*() const;
clear() {
   rootSize = 0;
 }
 
 //===----------------------------------------------------------------------===//
 //---                   IntervalMap::const_iterator                       ----//
 //===----------------------------------------------------------------------===//
 
 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;
 
   // We store a full path from the root to the current position.
   // The path may be partially filled, but never between iterator calls.
   IntervalMapImpl::Path path;
 
   explicit const_iterator(const IntervalMap &map) :

llvm/include/llvm/ADT/PostOrderIterator.h

template <class NodeRef> bool insertEdge(Optional<NodeRef> From, NodeRef To) {
     return Visited.insert(To).second;
   }
 
   // Called after all children of BB have been visited.
   template <class NodeRef> void finishPostorder(NodeRef BB) {}
 };
 
 template <class GraphT,
           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;
 
   // VisitStack - Used to maintain the ordering.  Top = current block
   // First element is basic block pointer, second is the 'next child' to visit
   SmallVector<std::pair<NodeRef, ChildItTy>, 8> VisitStack;
 
   po_iterator(NodeRef BB) {
while (VisitStack.back().second != GT::child_end(VisitStack.back().first)) {
       if (this->insertEdge(Optional<NodeRef>(VisitStack.back().first), BB)) {
         // If the block is not visited...
         VisitStack.push_back(std::make_pair(BB, GT::child_begin(BB)));
       }
     }
   }
 
 public:
-  using pointer = typename super::pointer;
-
   // Provide static "constructors"...
   static po_iterator begin(GraphT G) {
     return po_iterator(GT::getEntryNode(G));
   }
   static po_iterator end(GraphT G) { return po_iterator(); }
 
   static po_iterator begin(GraphT G, SetType &S) {
     return po_iterator(GT::getEntryNode(G), S);

llvm/include/llvm/ADT/SparseMultiSet.h

void setUniverse(unsigned U) {
     // would be enough here, but that will cause tools like valgrind to
     // complain about branching on uninitialized data.
     Sparse = static_cast<SparseT*>(safe_calloc(U, sizeof(SparseT)));
     Universe = U;
   }
 
   /// 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> {
+  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;
 
     iterator_base(SMSPtrTy P, unsigned I, unsigned SI)
       : SMS(P), Idx(I), SparseIdx(SI) {}
 
     /// Whether our iterator has fallen outside our dense vector.
private:
 
     unsigned Prev() const { return SMS->Dense[Idx].Prev; }
     unsigned Next() const { return SMS->Dense[Idx].Next; }
 
     void setPrev(unsigned P) { SMS->Dense[Idx].Prev = P; }
     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");
 
       return SMS->Dense[Idx].Data;
     }
     pointer operator->() const { return &operator*(); }
 
public:
   }
 
   /// The bounds of the range of items sharing Key K. First member is the head
   /// of the list, and the second member is a decrementable end iterator for
   /// that key.
   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
   /// to the newly added entry.
   iterator insert(const ValueT &Val) {
     unsigned Idx = sparseIndex(Val);
     iterator I = findIndex(Idx);
 

llvm/include/llvm/ADT/iterator.h

 ///   - bool operator<(const DerivedT &RHS) const;
 ///   - DifferenceTypeT operator-(const DerivedT &R) const;
 ///   - DerivedT &operator+=(DifferenceTypeT N);
 ///   - DerivedT &operator-=(DifferenceTypeT N);
 ///
 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,
                                      IteratorCategoryT>::value,
     IsBidirectional = std::is_base_of<std::bidirectional_iterator_tag,
                                       IteratorCategoryT>::value,
   };
 

llvm/include/llvm/Analysis/AliasSetTracker.h

public:
   /// If this alias set is known to contain a single instruction and *only* a
   /// single unique instruction, return it.  Otherwise, return nullptr.
   Instruction* getUniqueInstruction();
 
   void print(raw_ostream &OS) const;
   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 {
       return CurNode == x.CurNode;
     }
     bool operator!=(const iterator& x) const { return !operator==(x); }
 
     value_type &operator*() const {

llvm/include/llvm/Analysis/MemorySSA.h

public:
   // If the operation becomes constant time on MemoryPHI's, this bit of
   // abstraction breaking should be removed.
   BasicBlock *getPhiArgBlock() const {
     MemoryPhi *MP = dyn_cast<MemoryPhi>(Access);
     assert(MP && "Tried to get phi arg block when not iterating over a PHI");
     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.
     if (const MemoryPhi *MP = dyn_cast<MemoryPhi>(Access))
       return MP->getIncomingValue(ArgNo);
     return cast<MemoryUseOrDef>(Access)->getDefiningAccess();
   }
 
public:
   }
 
   upward_defs_iterator() { CurrentPair.first = nullptr; }
 
   bool operator==(const upward_defs_iterator &Other) const {
     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;
   }
 
   using BaseT::operator++;
   upward_defs_iterator &operator++() {
     assert(DefIterator != OriginalAccess->defs_end() &&

llvm/include/llvm/Analysis/RegionIterator.h

 /// This iterator iterates over all successors of a RegionNode.
 ///
 /// For a BasicBlock RegionNode it skips all BasicBlocks that are not part of
 /// the parent Region.  Furthermore for BasicBlocks that start a subregion, a
 /// RegionNode representing the subregion is returned.
 ///
 /// For a subregion RegionNode there is just one successor. The RegionNode
 /// representing the exit of the subregion.
 template <class NodeRef, class BlockT, class RegionT>
-class RNSuccIterator
-    : public std::iterator<std::forward_iterator_tag, NodeRef> {
-  using super = std::iterator<std::forward_iterator_tag, NodeRef>;
+class RNSuccIterator {
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = NodeRef;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
+private:
   using BlockTraits = GraphTraits<BlockT *>;
   using SuccIterTy = typename BlockTraits::ChildIteratorType;
 
   // The iterator works in two modes, bb mode or region mode.
   enum ItMode {
     // In BB mode it returns all successors of this BasicBlock as its
     // successors.
     ItBB,
private:
 
   // isExit - Is this the exit BB of the Region?
   inline bool isExit(BlockT* BB) const {
     return getNode()->getParent()->getExit() == BB;
   }
 
 public:
   using Self = RNSuccIterator<NodeRef, BlockT, RegionT>;
-  using value_type = typename super::value_type;
 
   /// Create begin iterator of a RegionNode.
   inline RNSuccIterator(NodeRef node)
       : Node(node, node->isSubRegion() ? ItRgBegin : ItBB),
         BItor(BlockTraits::child_begin(node->getEntry())) {
     // Skip the exit block
     if (!isRegionMode())
       while (BlockTraits::child_end(node->getEntry()) != BItor && isExit(*BItor))

 
 //===----------------------------------------------------------------------===//
 /// Flat RegionNode iterator.
 ///
 /// The Flat Region iterator will iterate over all BasicBlock RegionNodes that
 /// are contained in the Region and its subregions. This is close to a virtual
 /// control flow graph of the Region.
 template <class NodeRef, class BlockT, class RegionT>
-class RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>
-    : public std::iterator<std::forward_iterator_tag, NodeRef> {
-  using super = std::iterator<std::forward_iterator_tag, NodeRef>;
+class RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT> {
   using BlockTraits = GraphTraits<BlockT *>;
   using SuccIterTy = typename BlockTraits::ChildIteratorType;
 
   NodeRef Node;
   SuccIterTy Itor;
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = NodeRef;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   using Self = RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>;
-  using value_type = typename super::value_type;
 
   /// Create the iterator from a RegionNode.
   ///
   /// Note that the incoming node must be a bb node, otherwise it will trigger
   /// an assertion when we try to get a BasicBlock.
   inline RNSuccIterator(NodeRef node)
       : Node(node), Itor(BlockTraits::child_begin(node->getEntry())) {
     assert(!Node->isSubRegion() &&

llvm/include/llvm/CodeGen/MachineRegisterInfo.h

public:
   /// defusechain_iterator - This class provides iterator support for machine
   /// operands in the function that use or define a specific register.  If
   /// ReturnUses is true it returns uses of registers, if ReturnDefs is true it
   /// returns defs.  If neither are true then you are silly and it always
   /// returns end().  If SkipDebug is true it skips uses marked Debug
   /// when incrementing.
   template <bool ReturnUses, bool ReturnDefs, bool SkipDebug, bool ByOperand,
             bool ByInstr, bool ByBundle>
-  class defusechain_iterator : public std::iterator<std::forward_iterator_tag,
-                                                    MachineOperand, ptrdiff_t> {
+  class defusechain_iterator {
     friend class MachineRegisterInfo;
 
+  public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = MachineOperand;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+  private:
     MachineOperand *Op = nullptr;
 
     explicit defusechain_iterator(MachineOperand *op) : Op(op) {
       // If the first node isn't one we're interested in, advance to one that
       // we are interested in.
       if (op) {
         if ((!ReturnUses && op->isUse()) ||
             (!ReturnDefs && op->isDef()) ||
void advance() {
         // If this is an operand we don't care about, skip it.
         while (Op && ((!ReturnDefs && Op->isDef()) ||
                       (SkipDebug && Op->isDebug())))
           Op = getNextOperandForReg(Op);
       }
     }
 
   public:
-    using reference = std::iterator<std::forward_iterator_tag, MachineOperand,
-                                    ptrdiff_t>::reference;
-    using pointer = std::iterator<std::forward_iterator_tag, MachineOperand,
-                                  ptrdiff_t>::pointer;
-
     defusechain_iterator() = default;
 
     bool operator==(const defusechain_iterator &x) const {
       return Op == x.Op;
     }
     bool operator!=(const defusechain_iterator &x) const {
       return !operator==(x);
     }
public:
   };
 
   /// defusechain_iterator - This class provides iterator support for machine
   /// operands in the function that use or define a specific register.  If
   /// ReturnUses is true it returns uses of registers, if ReturnDefs is true it
   /// returns defs.  If neither are true then you are silly and it always
   /// returns end().  If SkipDebug is true it skips uses marked Debug
   /// when incrementing.
   template<bool ReturnUses, bool ReturnDefs, bool SkipDebug,
            bool ByOperand, bool ByInstr, bool ByBundle>
-  class defusechain_instr_iterator
-    : public std::iterator<std::forward_iterator_tag, MachineInstr, ptrdiff_t> {
+  class defusechain_instr_iterator {
     friend class MachineRegisterInfo;
 
+  public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = MachineInstr;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+  private:
     MachineOperand *Op = nullptr;
 
     explicit defusechain_instr_iterator(MachineOperand *op) : Op(op) {
       // If the first node isn't one we're interested in, advance to one that
       // we are interested in.
       if (op) {
         if ((!ReturnUses && op->isUse()) ||
             (!ReturnDefs && op->isDef()) ||
void advance() {
         // If this is an operand we don't care about, skip it.
         while (Op && ((!ReturnDefs && Op->isDef()) ||
                       (SkipDebug && Op->isDebug())))
           Op = getNextOperandForReg(Op);
       }
     }
 
   public:
-    using reference = std::iterator<std::forward_iterator_tag,
-                                    MachineInstr, ptrdiff_t>::reference;
-    using pointer = std::iterator<std::forward_iterator_tag,
-                                  MachineInstr, ptrdiff_t>::pointer;
-
     defusechain_instr_iterator() = default;
 
     bool operator==(const defusechain_instr_iterator &x) const {
       return Op == x.Op;
     }
     bool operator!=(const defusechain_instr_iterator &x) const {
       return !operator==(x);
     }

llvm/include/llvm/CodeGen/ScheduleDAG.h

#endif
   protected:
     void dumpNodeAll(const SUnit &SU) const;
 
   private:
     /// Returns the MCInstrDesc of this SDNode or NULL.
     const MCInstrDesc *getNodeDesc(const SDNode *Node) const;
   };
 
-  class SUnitIterator : public std::iterator<std::forward_iterator_tag,
-                                             SUnit, ptrdiff_t> {
+  class SUnitIterator {
     SUnit *Node;
     unsigned Operand;
 
     SUnitIterator(SUnit *N, unsigned Op) : Node(N), Operand(Op) {}
 
   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = SUnit;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     bool operator==(const SUnitIterator& x) const {
       return Operand == x.Operand;
     }
     bool operator!=(const SUnitIterator& x) const { return !operator==(x); }
 
     pointer operator*() const {
       return Node->Preds[Operand].getSUnit();
     }

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

#include "llvm/IR/ConstrainedOps.def"
   const DebugLoc &getDebugLoc() const { return debugLoc; }
 
   /// Set source location info.  Try to avoid this, putting
   /// it in the constructor is preferable.
   void setDebugLoc(DebugLoc dl) { debugLoc = std::move(dl); }
 
   /// This class provides iterator support for SDUse
   /// operands that use a specific SDNode.
-  class use_iterator
-    : public std::iterator<std::forward_iterator_tag, SDUse, ptrdiff_t> {
+  class use_iterator {
     friend class SDNode;
 
     SDUse *Op = nullptr;
 
     explicit use_iterator(SDUse *op) : Op(op) {}
 
   public:
-    using reference = std::iterator<std::forward_iterator_tag,
-                                    SDUse, ptrdiff_t>::reference;
-    using pointer = std::iterator<std::forward_iterator_tag,
-                                  SDUse, ptrdiff_t>::pointer;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = SDUse;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
 
     use_iterator() = default;
     use_iterator(const use_iterator &I) : Op(I.Op) {}
 
     bool operator==(const use_iterator &x) const {
       return Op == x.Op;
     }
     bool operator!=(const use_iterator &x) const {
public:
 
   Align getAlign() const { return Alignment; }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::AssertAlign;
   }
 };
 
-class SDNodeIterator : public std::iterator<std::forward_iterator_tag,
-                                            SDNode, ptrdiff_t> {
+class SDNodeIterator {
   const SDNode *Node;
   unsigned Operand;
 
   SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = SDNode;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   bool operator==(const SDNodeIterator& x) const {
     return Operand == x.Operand;
   }
   bool operator!=(const SDNodeIterator& x) const { return !operator==(x); }
 
   pointer operator*() const {
     return Node->getOperand(Operand).getNode();
   }

llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

public:
     /// Returns the value of the Atom in this Accelerator Entry, if the Entry
     /// contains such Atom.
     Optional<DWARFFormValue> lookup(HeaderData::AtomType Atom) const;
 
     friend class AppleAcceleratorTable;
     friend class ValueIterator;
   };
 
-  class ValueIterator : public std::iterator<std::input_iterator_tag, Entry> {
+  class ValueIterator {
     const AppleAcceleratorTable *AccelTable = nullptr;
     Entry Current;           ///< The current entry.
     uint64_t DataOffset = 0; ///< Offset into the section.
     unsigned Data = 0; ///< Current data entry.
     unsigned NumData = 0; ///< Number of data entries.
 
     /// Advance the iterator.
     void Next();
+
   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = Entry;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     /// Construct a new iterator for the entries at \p DataOffset.
     ValueIterator(const AppleAcceleratorTable &AccelTable, uint64_t DataOffset);
     /// End marker.
     ValueIterator() = default;
 
     const Entry &operator*() const { return Current; }
     ValueIterator &operator++() { Next(); return *this; }
     ValueIterator operator++(int) {
uint64_t getNextUnitOffset() const {
       return Base + dwarf::getUnitLengthFieldByteSize(Hdr.Format) +
              Hdr.UnitLength;
     }
     void dump(ScopedPrinter &W) const;
 
     friend class DWARFDebugNames;
   };
 
-  class ValueIterator : public std::iterator<std::input_iterator_tag, Entry> {
+  class ValueIterator {
+  public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = Entry;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
 
+  private:
     /// The Name Index we are currently iterating through. The implementation
     /// relies on the fact that this can also be used as an iterator into the
     /// "NameIndices" vector in the Accelerator section.
     const NameIndex *CurrentIndex = nullptr;
 
     /// Whether this is a local iterator (searches in CurrentIndex only) or not
     /// (searches all name indices).
     bool IsLocal;

llvm/include/llvm/IR/CFG.h

 class Instruction;
 class Use;
 
 //===----------------------------------------------------------------------===//
 // BasicBlock pred_iterator definition
 //===----------------------------------------------------------------------===//
 
 template <class Ptr, class USE_iterator> // Predecessor Iterator
-class PredIterator : public std::iterator<std::forward_iterator_tag,
-                                          Ptr, ptrdiff_t, Ptr*, Ptr*> {
-  using super =
-      std::iterator<std::forward_iterator_tag, Ptr, ptrdiff_t, Ptr*, Ptr*>;
+class PredIterator {
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = Ptr;
+  using difference_type = std::ptrdiff_t;
+  using pointer = Ptr *;
+  using reference = Ptr *;
+
+private:
   using Self = PredIterator<Ptr, USE_iterator>;
   USE_iterator It;
 
   inline void advancePastNonTerminators() {
     // Loop to ignore non-terminator uses (for example BlockAddresses).
     while (!It.atEnd()) {
       if (auto *Inst = dyn_cast<Instruction>(*It))
         if (Inst->isTerminator())
           break;
 
       ++It;
     }
   }
 
 public:
-  using pointer = typename super::pointer;
-  using reference = typename super::reference;
-
   PredIterator() = default;
   explicit inline PredIterator(Ptr *bb) : It(bb->user_begin()) {
     advancePastNonTerminators();
   }
   inline PredIterator(Ptr *bb, bool) : It(bb->user_end()) {}
 
   inline bool operator==(const Self& x) const { return It == x.It; }
   inline bool operator!=(const Self& x) const { return !operator==(x); }

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   MDTuple &operator*() const { return *get(); }
 
   // FIXME: Fix callers and remove condition on N.
   unsigned size() const { return N ? N->getNumOperands() : 0u; }
   DIType *operator[](unsigned I) const {
     return cast_or_null<DIType>(N->getOperand(I));
   }
 
-  class iterator : std::iterator<std::input_iterator_tag, DIType *,
-                                 std::ptrdiff_t, void, DIType *> {
+  class iterator {
     MDNode::op_iterator I = nullptr;
 
   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DIType *;
+    using difference_type = std::ptrdiff_t;
+    using pointer = void;
+    using reference = DIType *;
+
     iterator() = default;
     explicit iterator(MDNode::op_iterator I) : I(I) {}
 
     DIType *operator*() const { return cast_or_null<DIType>(*I); }
 
     iterator &operator++() {
       ++I;
       return *this;
public:
 
     /// Append the elements of this operand to \p V.
     void appendToVector(SmallVectorImpl<uint64_t> &V) const {
       V.append(get(), get() + getSize());
     }
   };
 
   /// An iterator for expression operands.
-  class expr_op_iterator
-      : public std::iterator<std::input_iterator_tag, ExprOperand> {
+  class expr_op_iterator {
     ExprOperand Op;
 
   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = ExprOperand;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     expr_op_iterator() = default;
     explicit expr_op_iterator(element_iterator I) : Op(I) {}
 
     element_iterator getBase() const { return Op.get(); }
     const ExprOperand &operator*() const { return Op; }
     const ExprOperand *operator->() const { return &Op; }
 
     expr_op_iterator &operator++() {

llvm/include/llvm/IR/GetElementPtrTypeIterator.h

 #include "llvm/Support/Casting.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 
 namespace llvm {
 
   template<typename ItTy = User::const_op_iterator>
-  class generic_gep_type_iterator
-    : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> {
-    using super = std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t>;
+  class generic_gep_type_iterator {
 
     ItTy OpIt;
     PointerUnion<StructType *, Type *> CurTy;
     enum : uint64_t { Unbounded = -1ull };
     uint64_t NumElements = Unbounded;
 
     generic_gep_type_iterator() = default;
 
   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = Type *;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
       generic_gep_type_iterator I;
       I.CurTy = Ty;
       I.OpIt = It;
       return I;
     }
 
     static generic_gep_type_iterator end(ItTy It) {

llvm/include/llvm/IR/Metadata.h

StringRef getName() const {
     return StringRef();
   }
 };
 
 /// Typed iterator through MDNode operands.
 ///
 /// An iterator that transforms an \a MDNode::iterator into an iterator over a
 /// particular Metadata subclass.
 template <class T>
-class TypedMDOperandIterator
-    : public std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void,
-                           T *> {
+class TypedMDOperandIterator {
   MDNode::op_iterator I = nullptr;
 
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = T *;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = T *;
+
   TypedMDOperandIterator() = default;
   explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}
 
   T *operator*() const { return cast_or_null<T>(*I); }
 
   TypedMDOperandIterator &operator++() {
     ++I;
     return *this;
class NamedMDNode : public ilist_node<NamedMDNode> {
   std::string Name;
   Module *Parent = nullptr;
   void *Operands; // SmallVector<TrackingMDRef, 4>
 
   void setParent(Module *M) { Parent = M; }
 
   explicit NamedMDNode(const Twine &N);
 
   template<class T1, class T2>
-  class op_iterator_impl :
-      public std::iterator<std::bidirectional_iterator_tag, T2> {
+  class op_iterator_impl {
     friend class NamedMDNode;
 
     const NamedMDNode *Node = nullptr;
     unsigned Idx = 0;
 
     op_iterator_impl(const NamedMDNode *N, unsigned i) : Node(N), Idx(i) {}
 
   public:
+    using iterator_category = std::bidirectional_iterator_tag;
+    using value_type = T2;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     op_iterator_impl() = default;
 
     bool operator==(const op_iterator_impl &o) const { return Idx == o.Idx; }
     bool operator!=(const op_iterator_impl &o) const { return Idx != o.Idx; }
 
     op_iterator_impl &operator++() {
       ++Idx;
       return *this;

llvm/include/llvm/IR/Module.h

/// @{
   iterator_range<named_metadata_iterator> named_metadata() {
     return make_range(named_metadata_begin(), named_metadata_end());
   }
   iterator_range<const_named_metadata_iterator> named_metadata() const {
     return make_range(named_metadata_begin(), named_metadata_end());
   }
 
   /// An iterator for DICompileUnits that skips those marked NoDebug.
-  class debug_compile_units_iterator
-      : public std::iterator<std::input_iterator_tag, DICompileUnit *> {
+  class debug_compile_units_iterator {
     NamedMDNode *CUs;
     unsigned Idx;
 
     void SkipNoDebugCUs();
 
   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DICompileUnit *;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     explicit debug_compile_units_iterator(NamedMDNode *CUs, unsigned Idx)
         : CUs(CUs), Idx(Idx) {
       SkipNoDebugCUs();
     }
 
     debug_compile_units_iterator &operator++() {
       ++Idx;
       SkipNoDebugCUs();

llvm/include/llvm/IR/Value.h

protected:
   unsigned IsUsedByMD : 1;
   unsigned HasName : 1;
   unsigned HasMetadata : 1; // Has metadata attached to this?
   unsigned HasHungOffUses : 1;
   unsigned HasDescriptor : 1;
 
 private:
   template <typename UseT> // UseT == 'Use' or 'const Use'
-  class use_iterator_impl
-      : public std::iterator<std::forward_iterator_tag, UseT *> {
+  class use_iterator_impl {
     friend class Value;
 
     UseT *U;
 
     explicit use_iterator_impl(UseT *u) : U(u) {}
 
   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = UseT *;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     use_iterator_impl() : U() {}
 
     bool operator==(const use_iterator_impl &x) const { return U == x.U; }
     bool operator!=(const use_iterator_impl &x) const { return !operator==(x); }
 
     use_iterator_impl &operator++() { // Preincrement
       assert(U && "Cannot increment end iterator!");
       U = U->getNext();
public:
     UseT *operator->() const { return &operator*(); }
 
     operator use_iterator_impl<const UseT>() const {
       return use_iterator_impl<const UseT>(U);
     }
   };
 
   template <typename UserTy> // UserTy == 'User' or 'const User'
-  class user_iterator_impl
-      : public std::iterator<std::forward_iterator_tag, UserTy *> {
+  class user_iterator_impl {
     use_iterator_impl<Use> UI;
     explicit user_iterator_impl(Use *U) : UI(U) {}
     friend class Value;
 
   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = UserTy *;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     user_iterator_impl() = default;
 
     bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
     bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }
 
     /// Returns true if this iterator is equal to user_end() on the value.
     bool atEnd() const { return *this == user_iterator_impl(); }
 

llvm/include/llvm/IR/ValueMap.h

static bool isEqual(const VH &LHS, const VH &RHS) {
     return LHS == RHS;
   }
 
   static bool isEqual(const KeyT &LHS, const VH &RHS) {
     return LHS == RHS.getValPtr();
   }
 };
 
 template<typename DenseMapT, typename KeyT>
-class ValueMapIterator :
-    public std::iterator<std::forward_iterator_tag,
-                         std::pair<KeyT, typename DenseMapT::mapped_type>,
-                         ptrdiff_t> {
+class ValueMapIterator {
   using BaseT = typename DenseMapT::iterator;
   using ValueT = typename DenseMapT::mapped_type;
 
   BaseT I;
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = std::pair<KeyT, typename DenseMapT::mapped_type>;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   ValueMapIterator() : I() {}
   ValueMapIterator(BaseT I) : I(I) {}
 
   BaseT base() const { return I; }
 
   struct ValueTypeProxy {
     const KeyT first;
     ValueT& second;
inline ValueMapIterator& operator++() {  // Preincrement
     ++I;
     return *this;
   }
   ValueMapIterator operator++(int) {  // Postincrement
     ValueMapIterator tmp = *this; ++*this; return tmp;
   }
 };
 
 template<typename DenseMapT, typename KeyT>
-class ValueMapConstIterator :
-    public std::iterator<std::forward_iterator_tag,
-                         std::pair<KeyT, typename DenseMapT::mapped_type>,
-                         ptrdiff_t> {
+class ValueMapConstIterator {
   using BaseT = typename DenseMapT::const_iterator;
   using ValueT = typename DenseMapT::mapped_type;
 
   BaseT I;
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = std::pair<KeyT, typename DenseMapT::mapped_type>;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   ValueMapConstIterator() : I() {}
   ValueMapConstIterator(BaseT I) : I(I) {}
   ValueMapConstIterator(ValueMapIterator<DenseMapT, KeyT> Other)
     : I(Other.base()) {}
 
   BaseT base() const { return I; }
 
   struct ValueTypeProxy {

llvm/include/llvm/Object/ELFTypes.h

StringRef getDescAsStringRef() const {
     ArrayRef<uint8_t> Desc = getDesc();
     return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
   }
 
   /// Get the note's type.
   Elf_Word getType() const { return Nhdr.n_type; }
 };
 
 template <class ELFT>
-class Elf_Note_Iterator_Impl
-    : std::iterator<std::forward_iterator_tag, Elf_Note_Impl<ELFT>> {
+class Elf_Note_Iterator_Impl {
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = Elf_Note_Impl<ELFT>;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
+private:
   // Nhdr being a nullptr marks the end of iteration.
   const Elf_Nhdr_Impl<ELFT> *Nhdr = nullptr;
   size_t RemainingSize = 0u;
   Error *Err = nullptr;
 
   template <class ELFFileELFT> friend class ELFFile;
 
   // Stop iteration and indicate an overflow.

llvm/include/llvm/Object/SymbolicFile.h

 }
 
 inline bool operator<(const DataRefImpl &a, const DataRefImpl &b) {
   // Check bitwise identical. This is the only legal way to compare a union w/o
   // knowing which member is in use.
   return std::memcmp(&a, &b, sizeof(DataRefImpl)) < 0;
 }
 
 template <class content_type>
-class content_iterator
-    : public std::iterator<std::forward_iterator_tag, content_type> {
+class content_iterator {
   content_type Current;
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = content_type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   content_iterator(content_type symb) : Current(std::move(symb)) {}
 
   const content_type *operator->() const { return &Current; }
 
   const content_type &operator*() const { return Current; }
 
   bool operator==(const content_iterator &other) const {
     return Current == other.Current;

llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h

struct CoverageMappingRecord {
   StringRef FunctionName;
   uint64_t FunctionHash;
   ArrayRef<StringRef> Filenames;
   ArrayRef<CounterExpression> Expressions;
   ArrayRef<CounterMappingRegion> MappingRegions;
 };
 
 /// A file format agnostic iterator over coverage mapping data.
-class CoverageMappingIterator
-    : public std::iterator<std::input_iterator_tag, CoverageMappingRecord> {
+class CoverageMappingIterator {
   CoverageMappingReader *Reader;
   CoverageMappingRecord Record;
   coveragemap_error ReadErr;
 
   void increment();
 
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = CoverageMappingRecord;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   CoverageMappingIterator()
       : Reader(nullptr), Record(), ReadErr(coveragemap_error::success) {}
 
   CoverageMappingIterator(CoverageMappingReader *Reader)
       : Reader(Reader), Record(), ReadErr(coveragemap_error::success) {
     increment();
   }
 

llvm/include/llvm/ProfileData/InstrProfReader.h

 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 class InstrProfReader;
 
 /// A file format agnostic iterator over profiling data.
-class InstrProfIterator : public std::iterator<std::input_iterator_tag,
-                                               NamedInstrProfRecord> {
+class InstrProfIterator {
+public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = NamedInstrProfRecord;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
+private:
   InstrProfReader *Reader = nullptr;
   value_type Record;
 
   void Increment();
 
 public:
   InstrProfIterator() = default;
   InstrProfIterator(InstrProfReader *Reader) : Reader(Reader) { Increment(); }

llvm/include/llvm/Support/LineIterator.h

 /// a time from a buffer. When default constructed the iterator will be the
 /// "end" iterator.
 ///
 /// The iterator is aware of what line number it is currently processing. It
 /// strips blank lines by default, and comment lines given a comment-starting
 /// character.
 ///
 /// Note that this iterator requires the buffer to be nul terminated.
-class line_iterator
-    : public std::iterator<std::forward_iterator_tag, StringRef> {
+class line_iterator {
   Optional<MemoryBufferRef> Buffer;
   char CommentMarker = '\0';
   bool SkipBlanks = true;
 
   unsigned LineNumber = 1;
   StringRef CurrentLine;
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = StringRef;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   /// Default construct an "end" iterator.
   line_iterator() = default;
 
   /// Construct a new iterator around an unowned memory buffer.
   explicit line_iterator(const MemoryBufferRef &Buffer, bool SkipBlanks = true,
                          char CommentMarker = '\0');
 
   /// Construct a new iterator around some memory buffer.

llvm/include/llvm/Support/TargetRegistry.h

 /// TargetRegistry - Generic interface to target specific features.
 struct TargetRegistry {
   // FIXME: Make this a namespace, probably just move all the Register*
   // functions into Target (currently they all just set members on the Target
   // anyway, and Target friends this class so those functions can...
   // function).
   TargetRegistry() = delete;
 
-  class iterator
-      : public std::iterator<std::forward_iterator_tag, Target, ptrdiff_t> {
+  class iterator {
     friend struct TargetRegistry;
 
     const Target *Current = nullptr;
 
     explicit iterator(Target *T) : Current(T) {}
 
   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = Target;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     iterator() = default;
 
     bool operator==(const iterator &x) const { return Current == x.Current; }
     bool operator!=(const iterator &x) const { return !operator==(x); }
 
     // Iterator traversal: forward iteration only
     iterator &operator++() { // Preincrement
       assert(Current && "Cannot increment end iterator!");

llvm/include/llvm/Support/YAMLParser.h

private:
   Node *Value = nullptr;
 };
 
 /// This is an iterator abstraction over YAML collections shared by both
 ///        sequences and maps.
 ///
 /// BaseT must have a ValueT* member named CurrentEntry and a member function
 /// increment() which must set CurrentEntry to 0 to create an end iterator.
 template <class BaseT, class ValueT>
-class basic_collection_iterator
-    : public std::iterator<std::input_iterator_tag, ValueT> {
+class basic_collection_iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = ValueT;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   basic_collection_iterator() = default;
   basic_collection_iterator(BaseT *B) : Base(B) {}
 
   ValueT *operator->() const {
     assert(Base && Base->CurrentEntry && "Attempted to access end iterator!");
     return Base->CurrentEntry;
   }
 

llvm/include/llvm/TextAPI/ArchitectureSet.h

public:
   bool empty() const { return ArchSet == 0; }
 
   ArchSetType rawValue() const { return ArchSet; }
 
   bool hasX86() const {
     return has(AK_i386) || has(AK_x86_64) || has(AK_x86_64h);
   }
 
   template <typename Ty>
-  class arch_iterator
-      : public std::iterator<std::forward_iterator_tag, Architecture, size_t> {
+  class arch_iterator {
+  public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = Architecture;
+    using difference_type = std::size_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
   private:
     ArchSetType Index;
     Ty *ArchSet;
 
     void findNextSetBit() {
       if (Index == EndIndexVal)
         return;
       while (++Index < sizeof(Ty) * 8) {

llvm/include/llvm/Transforms/Scalar/GVNExpression.h

for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
       OS << "[" << i << "] = ";
       Operands[i]->printAsOperand(OS);
       OS << "  ";
     }
     OS << "} ";
   }
 };
 
-class op_inserter
-    : public std::iterator<std::output_iterator_tag, void, void, void, void> {
+class op_inserter {
 private:
   using Container = BasicExpression;
 
   Container *BE;
 
 public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = void;
+  using difference_type = void;
+  using pointer = void;
+  using reference = void;
+
   explicit op_inserter(BasicExpression &E) : BE(&E) {}
   explicit op_inserter(BasicExpression *E) : BE(E) {}
 
   op_inserter &operator=(Value *val) {
     BE->op_push_back(val);
     return *this;
   }
   op_inserter &operator*() { return *this; }
void printInternal(raw_ostream &OS, bool PrintEType) const override {
     OS << ", intoperands = {";
     for (unsigned i = 0, e = int_op_size(); i != e; ++i) {
       OS << "[" << i << "] = " << IntOperands[i] << "  ";
     }
     OS << "}";
   }
 };
 
-class int_op_inserter
-    : public std::iterator<std::output_iterator_tag, void, void, void, void> {
+class int_op_inserter {
 private:
   using Container = AggregateValueExpression;
 
   Container *AVE;
 
 public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = void;
+  using difference_type = void;
+  using pointer = void;
+  using reference = void;
+
   explicit int_op_inserter(AggregateValueExpression &E) : AVE(&E) {}
   explicit int_op_inserter(AggregateValueExpression *E) : AVE(E) {}
 
   int_op_inserter &operator=(unsigned int val) {
     AVE->int_op_push_back(val);
     return *this;
   }
   int_op_inserter &operator*() { return *this; }

llvm/lib/Analysis/CFGPrinter.cpp

auto evaluateBB = [&](const BasicBlock *Node) {
     }
     isHiddenBasicBlock[Node] =
         llvm::all_of(successors(Node), [this](const BasicBlock *BB) {
           return isHiddenBasicBlock[BB];
         });
   };
   /// The post order traversal iteration is done to know the status of
   /// isHiddenBasicBlock for all the successors on the current BB.
-  for_each(po_begin(&F->getEntryBlock()), po_end(&F->getEntryBlock()),
-           evaluateBB);
+  llvm::for_each(post_order(&F->getEntryBlock()), evaluateBB);
 }
 
 bool DOTGraphTraits<DOTFuncInfo *>::isNodeHidden(const BasicBlock *Node,
                                                  const DOTFuncInfo *CFGInfo) {
   // If both restricting flags are false, all nodes are displayed.
   if (!HideUnreachablePaths && !HideDeoptimizePaths)
     return false;
   if (isHiddenBasicBlock.find(Node) == isHiddenBasicBlock.end())
     computeHiddenNodes(Node->getParent());
   return isHiddenBasicBlock[Node];
 }

llvm/tools/llvm-objdump/MachODump.cpp

static void printRelocationTargetName(const MachOObjectFile *O,
   if (O->getAnyRelocationType(RE) == MachO::ARM64_RELOC_ADDEND &&
       (O->getArch() == Triple::aarch64 || O->getArch() == Triple::aarch64_be)) {
     Fmt << format("0x%0" PRIx64, Val);
     return;
   }
 
   if (isExtern) {
     symbol_iterator SI = O->symbol_begin();
-    advance(SI, Val);
+    std::advance(SI, Val);
     S = unwrapOrError(SI->getName(), FileName);
   } else {
     section_iterator SI = O->section_begin();
     // Adjust for the fact that sections are 1-indexed.
     if (Val == 0) {
       Fmt << "0 (?,?)";
       return;
     }
     uint32_t I = Val - 1;
     while (I != 0 && SI != O->section_end()) {
       --I;
-      advance(SI, 1);
+      std::advance(SI, 1);
     }
     if (SI == O->section_end()) {
       Fmt << Val << " (?,?)";
     } else {
       if (Expected<StringRef> NameOrErr = SI->getName())
         S = *NameOrErr;
       else
         consumeError(NameOrErr.takeError());

polly/include/polly/Support/VirtualInstruction.h

public:
   void print(raw_ostream &OS, bool Reproducible = true) const;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const;
 #endif
 };
 
 /// An iterator for virtual operands.
-class VirtualOperandIterator
-    : public std::iterator<std::forward_iterator_tag, VirtualUse> {
+class VirtualOperandIterator {
   friend class VirtualInstruction;
   friend class VirtualUse;
 
-  using super = std::iterator<std::forward_iterator_tag, VirtualUse>;
   using Self = VirtualOperandIterator;
 
   ScopStmt *User;
   User::op_iterator U;
 
   VirtualOperandIterator(ScopStmt *User, User::op_iterator U)
       : User(User), U(U) {}
 
 public:
-  using pointer = typename super::pointer;
-  using reference = typename super::reference;
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = VirtualUse;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
 
   inline bool operator==(const Self &that) const {
     assert(this->User == that.User);
     return this->U == that.U;
   }
 
   inline bool operator!=(const Self &that) const {
     assert(this->User == that.User);