[llvm] Remove uses of deprecated `std::iterator`

[zero9178]

Summary

std::iterator has been deprecated in C++17 and some standard library implementations such as MS STL or libc++ emit deperecation messages when using the class.
Since LLVM has now switched to C++17 these will emit warnings on these implementations, or worse, errors in build configurations using -Werror.

This patch fixes these issues by replacing them with LLVMs own llvm::iterator_facade_base which offers a superset of functionality of std::iterator.

[thieta]

Thanks for fixing this!

[zero9178]

Fix typo; Rerun CI

llvm/include/llvm/Transforms/IPO/SampleContextTracker.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
 #define LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/ProfileData/SampleProf.h"
 #include <map>
 #include <queue>
 #include <vector>
 
 namespace llvm {
 class CallBase;
 class DILocation;
getContextNodeForProfile(const FunctionSamples *FSamples) const {
     if (I == ProfileToNodeMap.end())
       return nullptr;
     return I->second;
   }
   StringMap<ContextSamplesTy> &getFuncToCtxtProfiles() {
     return FuncToCtxtProfiles;
   }
 
-  class Iterator : public std::iterator<std::forward_iterator_tag,
-                                        const ContextTrieNode *> {
+  class Iterator : public llvm::iterator_facade_base<
+                       Iterator, std::forward_iterator_tag, ContextTrieNode *,
+                       std::ptrdiff_t, ContextTrieNode **, ContextTrieNode *> {
     std::queue<ContextTrieNode *> NodeQueue;
 
   public:
     explicit Iterator() = default;
     explicit Iterator(ContextTrieNode *Node) { NodeQueue.push(Node); }
     Iterator &operator++() {
       assert(!NodeQueue.empty() && "Iterator already at the end");
       ContextTrieNode *Node = NodeQueue.front();
       NodeQueue.pop();
       for (auto &It : Node->getAllChildContext())
         NodeQueue.push(&It.second);
       return *this;
     }
 
-    Iterator operator++(int) {
-      assert(!NodeQueue.empty() && "Iterator already at the end");
-      Iterator Ret = *this;
-      ++(*this);
-      return Ret;
-    }
     bool operator==(const Iterator &Other) const {
       if (NodeQueue.empty() && Other.NodeQueue.empty())
         return true;
       if (NodeQueue.empty() || Other.NodeQueue.empty())
         return false;
       return NodeQueue.front() == Other.NodeQueue.front();
     }
-    bool operator!=(const Iterator &Other) const { return !(*this == Other); }
+
     ContextTrieNode *operator*() const {
       assert(!NodeQueue.empty() && "Invalid access to end iterator");
       return NodeQueue.front();
     }
   };
 
   Iterator begin() { return Iterator(&RootContext); }
   Iterator end() { return Iterator(); }

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCInstrInfo.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCINSTRINFO_H
 #define LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCINSTRINFO_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstddef>
 #include <cstdint>
 
 namespace llvm {
 
public:
   unsigned packetIndexI, packetIndexJ, iClass;
 
   DuplexCandidate(unsigned i, unsigned j, unsigned iClass)
       : packetIndexI(i), packetIndexJ(j), iClass(iClass) {}
 };
 
 namespace Hexagon {
 
-class PacketIterator : public std::iterator<std::forward_iterator_tag,
-    PacketIterator> {
+class PacketIterator
+    : public llvm::iterator_facade_base<
+          PacketIterator, std::forward_iterator_tag, const MCInst> {
   MCInstrInfo const &MCII;
   MCInst::const_iterator BundleCurrent;
   MCInst::const_iterator BundleEnd;
   MCInst::const_iterator DuplexCurrent;
   MCInst::const_iterator DuplexEnd;
 
 public:
   PacketIterator(MCInstrInfo const &MCII, MCInst const &Inst);
   PacketIterator(MCInstrInfo const &MCII, MCInst const &Inst, std::nullptr_t);
 
   PacketIterator &operator++();
   MCInst const &operator*() const;
   bool operator==(PacketIterator const &Other) const;
-  bool operator!=(PacketIterator const &Other) const {
-    return !(*this == Other);
-  }
 };
 
 } // end namespace Hexagon
 
 namespace HexagonMCInstrInfo {
 
 constexpr size_t innerLoopOffset = 0;
 constexpr int64_t innerLoopMask = 1 << innerLoopOffset;

llvm/unittests/ADT/IteratorTest.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 template <int> struct Shadow;
 
-struct WeirdIter : std::iterator<std::input_iterator_tag, Shadow<0>, Shadow<1>,
-                                 Shadow<2>, Shadow<3>> {};
+struct WeirdIter
+    : llvm::iterator_facade_base<WeirdIter, std::input_iterator_tag, Shadow<0>,
+                                 Shadow<1>, Shadow<2>, Shadow<3>> {};
 
 struct AdaptedIter : iterator_adaptor_base<AdaptedIter, WeirdIter> {};
 
 // Test that iterator_adaptor_base forwards typedefs, if value_type is
 // unchanged.
 static_assert(std::is_same<typename AdaptedIter::value_type, Shadow<0>>::value,
               "");
 static_assert(