[ADT] Fix DepthFirstIterator's std::iterator base to have normal typedefs

[timshen]

Summary

This is similiar to r278752, where I found that the std::iterator<...> base can be normal.

include/llvm/ADT/DepthFirstIterator.h

 };
 
 // Generic Depth First Iterator
 template <class GraphT,
           class SetType =
               llvm::SmallPtrSet<typename GraphTraits<GraphT>::NodeRef, 8>,
           bool ExtStorage = false, class GT = GraphTraits<GraphT>>
 class df_iterator
-    : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef,
-                           ptrdiff_t, typename GT::NodeRef,
-                           typename GT::NodeRef>,
+    : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>,
       public df_iterator_storage<SetType, ExtStorage> {
-  typedef std::iterator<std::forward_iterator_tag, typename GT::NodeRef,
-                        ptrdiff_t, typename GT::NodeRef, typename GT::NodeRef>
-      super;
+  typedef std::iterator<std::forward_iterator_tag, typename GT::NodeRef> super;
 
   typedef typename GT::NodeRef NodeRef;
   typedef typename GT::ChildIteratorType ChildItTy;
 
   // 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.
   typedef std::pair<NodeRef, Optional<ChildItTy>> StackElement;
public:
   }
   static df_iterator end(const GraphT &G, SetType &S) { return df_iterator(S); }
 
   bool operator==(const df_iterator &x) const {
     return VisitStack == x.VisitStack;
   }
   bool operator!=(const df_iterator &x) const { return !(*this == x); }
 
-  NodeRef operator*() const { return VisitStack.back().first; }
+  const NodeRef &operator*() const { return VisitStack.back().first; }
 
   // This is a nonstandard operator-> that dereferences the pointer an extra
   // time... so that you can actually call methods ON the Node, because
   // the contained type is a pointer.  This allows BBIt->getTerminator() f.e.
   //
   NodeRef operator->() const { return **this; }
 
   df_iterator &operator++() { // Preincrement

include/llvm/Analysis/RegionInfo.h

#endif
   class block_iterator_wrapper
       : public df_iterator<
             typename std::conditional<IsConst, const BlockT, BlockT>::type *> {
     typedef df_iterator<
         typename std::conditional<IsConst, const BlockT, BlockT>::type *> super;
 
   public:
     typedef block_iterator_wrapper<IsConst> Self;
-    typedef typename super::pointer pointer;
+    typedef typename super::value_type value_type;
 
     // Construct the begin iterator.
-    block_iterator_wrapper(pointer Entry, pointer Exit)
+    block_iterator_wrapper(value_type Entry, value_type Exit)
         : super(df_begin(Entry)) {
       // Mark the exit of the region as visited, so that the children of the
       // exit and the exit itself, i.e. the block outside the region will never
       // be visited.
       super::Visited.insert(Exit);
     }
 
     // Construct the end iterator.
-    block_iterator_wrapper() : super(df_end<pointer>((BlockT *)nullptr)) {}
+    block_iterator_wrapper() : super(df_end<value_type>((BlockT *)nullptr)) {}
 
     /*implicit*/ block_iterator_wrapper(super I) : super(I) {}
 
     // FIXME: Even a const_iterator returns a non-const BasicBlock pointer.
     //        This was introduced for backwards compatibility, but should
     //        be removed as soon as all users are fixed.
     BlockT *operator*() const {
       return const_cast<BlockT *>(super::operator*());