Remove deprecated std::iterator (In Progress)

[mjp41]

Summary

In C++17 std::iterator is deprecated, this removes the use.

[mjp41]

I have realised there are lots of instances of this. Changing all ~50 is mechanical, but a larger change than I was expecting.

[mjp41]

This is more work that I anticipated. I will revisit if I get more time.

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:
+  typedef T value_type;
+  typedef PointerT pointer;
+  typedef ReferenceT reference;
+  typedef DifferenceTypeT difference_type;
+  typedef IteratorCategoryT iterator_category;
+
 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/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 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 {
+  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() &&