From: Adam Nemet <anemet@apple.com>
Date: Fri, 19 May 2017 02:56:37 +0000 (+0000)
Subject: Revert "[ADT] Fix some Clang-tidy modernize-use-using warnings; other minor fixes... 
X-Git-Tag: android-x86-7.1-r4~16066
X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=586584b84ad8020ef52ef232eee02e8fc81e5670;p=android-x86%2Fexternal-llvm.git

Revert "[ADT] Fix some Clang-tidy modernize-use-using warnings; other minor fixes (NFC)."

This reverts commit r303383.

This breaks the modules-enabled macOS build with:

lib/Support/LockFileManager.cpp:86:7: error: declaration of 'gethostuuid' must be imported from module 'Darwin.POSIX.unistd' before it is required

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@303402 91177308-0d34-0410-b5e6-96231b3b80d8
---

diff --git a/include/llvm/ADT/ImmutableList.h b/include/llvm/ADT/ImmutableList.h
index 60d63e09d42..e5f51bafe99 100644
--- a/include/llvm/ADT/ImmutableList.h
+++ b/include/llvm/ADT/ImmutableList.h
@@ -63,8 +63,8 @@ public:
 template <typename T>
 class ImmutableList {
 public:
-  using value_type = T;
-  using Factory = ImmutableListFactory<T>;
+  typedef T value_type;
+  typedef ImmutableListFactory<T> Factory;
 
 private:
   const ImmutableListImpl<T>* X;
@@ -141,8 +141,8 @@ public:
 
 template <typename T>
 class ImmutableListFactory {
-  using ListTy = ImmutableListImpl<T>;
-  using CacheTy = FoldingSet<ListTy>;
+  typedef ImmutableListImpl<T> ListTy;
+  typedef FoldingSet<ListTy>   CacheTy;
 
   CacheTy Cache;
   uintptr_t Allocator;
diff --git a/include/llvm/ADT/ImmutableMap.h b/include/llvm/ADT/ImmutableMap.h
index 10d1e1f0139..f197d407ba3 100644
--- a/include/llvm/ADT/ImmutableMap.h
+++ b/include/llvm/ADT/ImmutableMap.h
@@ -26,12 +26,12 @@ namespace llvm {
 /// only the first element (the key) is used by isEqual and isLess.
 template <typename T, typename S>
 struct ImutKeyValueInfo {
-  using value_type = const std::pair<T,S>;
-  using value_type_ref = const value_type&;
-  using key_type = const T;
-  using key_type_ref = const T&;
-  using data_type = const S;
-  using data_type_ref = const S&;
+  typedef const std::pair<T,S> value_type;
+  typedef const value_type& value_type_ref;
+  typedef const T   key_type;
+  typedef const T&  key_type_ref;
+  typedef const S   data_type;
+  typedef const S&  data_type_ref;
 
   static inline key_type_ref KeyOfValue(value_type_ref V) {
     return V.first;
@@ -62,13 +62,13 @@ template <typename KeyT, typename ValT,
           typename ValInfo = ImutKeyValueInfo<KeyT,ValT>>
 class ImmutableMap {
 public:
-  using value_type = typename ValInfo::value_type;
-  using value_type_ref = typename ValInfo::value_type_ref;
-  using key_type = typename ValInfo::key_type;
-  using key_type_ref = typename ValInfo::key_type_ref;
-  using data_type = typename ValInfo::data_type;
-  using data_type_ref = typename ValInfo::data_type_ref;
-  using TreeTy = ImutAVLTree<ValInfo>;
+  typedef typename ValInfo::value_type      value_type;
+  typedef typename ValInfo::value_type_ref  value_type_ref;
+  typedef typename ValInfo::key_type        key_type;
+  typedef typename ValInfo::key_type_ref    key_type_ref;
+  typedef typename ValInfo::data_type       data_type;
+  typedef typename ValInfo::data_type_ref   data_type_ref;
+  typedef ImutAVLTree<ValInfo>              TreeTy;
 
 protected:
   TreeTy* Root;
@@ -86,10 +86,6 @@ public:
     if (Root) { Root->retain(); }
   }
 
-  ~ImmutableMap() {
-    if (Root) { Root->release(); }
-  }
-
   ImmutableMap &operator=(const ImmutableMap &X) {
     if (Root != X.Root) {
       if (X.Root) { X.Root->retain(); }
@@ -99,6 +95,10 @@ public:
     return *this;
   }
 
+  ~ImmutableMap() {
+    if (Root) { Root->release(); }
+  }
+
   class Factory {
     typename TreeTy::Factory F;
     const bool Canonicalize;
@@ -166,14 +166,12 @@ private:
   template <typename Callback>
   struct CBWrapper {
     Callback C;
-
     void operator()(value_type_ref V) { C(V.first,V.second); }
   };
 
   template <typename Callback>
   struct CBWrapperRef {
     Callback &C;
-
     CBWrapperRef(Callback& c) : C(c) {}
 
     void operator()(value_type_ref V) { C(V.first,V.second); }
@@ -256,14 +254,14 @@ template <typename KeyT, typename ValT,
 typename ValInfo = ImutKeyValueInfo<KeyT,ValT>>
 class ImmutableMapRef {
 public:
-  using value_type = typename ValInfo::value_type;
-  using value_type_ref = typename ValInfo::value_type_ref;
-  using key_type = typename ValInfo::key_type;
-  using key_type_ref = typename ValInfo::key_type_ref;
-  using data_type = typename ValInfo::data_type;
-  using data_type_ref = typename ValInfo::data_type_ref;
-  using TreeTy = ImutAVLTree<ValInfo>;
-  using FactoryTy = typename TreeTy::Factory;
+  typedef typename ValInfo::value_type      value_type;
+  typedef typename ValInfo::value_type_ref  value_type_ref;
+  typedef typename ValInfo::key_type        key_type;
+  typedef typename ValInfo::key_type_ref    key_type_ref;
+  typedef typename ValInfo::data_type       data_type;
+  typedef typename ValInfo::data_type_ref   data_type_ref;
+  typedef ImutAVLTree<ValInfo>              TreeTy;
+  typedef typename TreeTy::Factory          FactoryTy;
 
 protected:
   TreeTy *Root;
@@ -294,11 +292,6 @@ public:
     }
   }
 
-  ~ImmutableMapRef() {
-    if (Root)
-      Root->release();
-  }
-
   ImmutableMapRef &operator=(const ImmutableMapRef &X) {
     if (Root != X.Root) {
       if (X.Root)
@@ -313,6 +306,11 @@ public:
     return *this;
   }
 
+  ~ImmutableMapRef() {
+    if (Root)
+      Root->release();
+  }
+
   static inline ImmutableMapRef getEmptyMap(FactoryTy *F) {
     return ImmutableMapRef(0, F);
   }
diff --git a/include/llvm/ADT/ImmutableSet.h b/include/llvm/ADT/ImmutableSet.h
index e7a9132a25f..0724a28306a 100644
--- a/include/llvm/ADT/ImmutableSet.h
+++ b/include/llvm/ADT/ImmutableSet.h
@@ -41,16 +41,18 @@ template <typename ImutInfo> class ImutAVLTreeGenericIterator;
 template <typename ImutInfo >
 class ImutAVLTree {
 public:
-  using key_type_ref = typename ImutInfo::key_type_ref;
-  using value_type = typename ImutInfo::value_type;
-  using value_type_ref = typename ImutInfo::value_type_ref;
-  using Factory = ImutAVLFactory<ImutInfo>;
-  using iterator = ImutAVLTreeInOrderIterator<ImutInfo>;
+  typedef typename ImutInfo::key_type_ref   key_type_ref;
+  typedef typename ImutInfo::value_type     value_type;
+  typedef typename ImutInfo::value_type_ref value_type_ref;
 
+  typedef ImutAVLFactory<ImutInfo>          Factory;
   friend class ImutAVLFactory<ImutInfo>;
   friend class ImutIntervalAVLFactory<ImutInfo>;
+
   friend class ImutAVLTreeGenericIterator<ImutInfo>;
 
+  typedef ImutAVLTreeInOrderIterator<ImutInfo>  iterator;
+
   //===----------------------------------------------------===//
   // Public Interface.
   //===----------------------------------------------------===//
@@ -223,17 +225,17 @@ private:
   Factory *factory;
   ImutAVLTree *left;
   ImutAVLTree *right;
-  ImutAVLTree *prev = nullptr;
-  ImutAVLTree *next = nullptr;
+  ImutAVLTree *prev;
+  ImutAVLTree *next;
 
-  unsigned height : 28;
-  bool IsMutable : 1;
-  bool IsDigestCached : 1;
-  bool IsCanonicalized : 1;
+  unsigned height         : 28;
+  unsigned IsMutable      : 1;
+  unsigned IsDigestCached : 1;
+  unsigned IsCanonicalized : 1;
 
   value_type value;
-  uint32_t digest = 0;
-  uint32_t refCount = 0;
+  uint32_t digest;
+  uint32_t refCount;
 
   //===----------------------------------------------------===//
   // Internal methods (node manipulation; used by Factory).
@@ -244,8 +246,9 @@ private:
   ///   ImutAVLFactory.
   ImutAVLTree(Factory *f, ImutAVLTree* l, ImutAVLTree* r, value_type_ref v,
               unsigned height)
-    : factory(f), left(l), right(r), height(height), IsMutable(true),
-      IsDigestCached(false), IsCanonicalized(false), value(v)
+    : factory(f), left(l), right(r), prev(nullptr), next(nullptr),
+      height(height), IsMutable(true), IsDigestCached(false),
+      IsCanonicalized(0), value(v), digest(0), refCount(0)
   {
     if (left) left->retain();
     if (right) right->retain();
@@ -366,11 +369,11 @@ public:
 template <typename ImutInfo >
 class ImutAVLFactory {
   friend class ImutAVLTree<ImutInfo>;
+  typedef ImutAVLTree<ImutInfo> TreeTy;
+  typedef typename TreeTy::value_type_ref value_type_ref;
+  typedef typename TreeTy::key_type_ref   key_type_ref;
 
-  using TreeTy = ImutAVLTree<ImutInfo>;
-  using value_type_ref = typename TreeTy::value_type_ref;
-  using key_type_ref = typename TreeTy::key_type_ref;
-  using CacheTy = DenseMap<unsigned, TreeTy*>;
+  typedef DenseMap<unsigned, TreeTy*> CacheTy;
 
   CacheTy Cache;
   uintptr_t Allocator;
@@ -656,7 +659,7 @@ public:
   enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3,
                    Flags=0x3 };
 
-  using TreeTy = ImutAVLTree<ImutInfo>;
+  typedef ImutAVLTree<ImutInfo> TreeTy;
 
   ImutAVLTreeGenericIterator() = default;
   ImutAVLTreeGenericIterator(const TreeTy *Root) {
@@ -761,12 +764,11 @@ template <typename ImutInfo>
 class ImutAVLTreeInOrderIterator
     : public std::iterator<std::bidirectional_iterator_tag,
                            ImutAVLTree<ImutInfo>> {
-  using InternalIteratorTy = ImutAVLTreeGenericIterator<ImutInfo>;
-
+  typedef ImutAVLTreeGenericIterator<ImutInfo> InternalIteratorTy;
   InternalIteratorTy InternalItr;
 
 public:
-  using TreeTy = ImutAVLTree<ImutInfo>;
+  typedef ImutAVLTree<ImutInfo> TreeTy;
 
   ImutAVLTreeInOrderIterator(const TreeTy* Root) : InternalItr(Root) {
     if (Root)
@@ -838,8 +840,8 @@ struct ImutAVLValueIterator
 /// and generic handling of pointers is done below.
 template <typename T>
 struct ImutProfileInfo {
-  using value_type = const T;
-  using value_type_ref = const T&;
+  typedef const T  value_type;
+  typedef const T& value_type_ref;
 
   static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
     FoldingSetTrait<T>::Profile(X,ID);
@@ -849,8 +851,8 @@ struct ImutProfileInfo {
 /// Profile traits for integers.
 template <typename T>
 struct ImutProfileInteger {
-  using value_type = const T;
-  using value_type_ref = const T&;
+  typedef const T  value_type;
+  typedef const T& value_type_ref;
 
   static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
     ID.AddInteger(X);
@@ -876,8 +878,8 @@ PROFILE_INTEGER_INFO(unsigned long long)
 /// Profile traits for booleans.
 template <>
 struct ImutProfileInfo<bool> {
-  using value_type = const bool;
-  using value_type_ref = const bool&;
+  typedef const bool  value_type;
+  typedef const bool& value_type_ref;
 
   static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
     ID.AddBoolean(X);
@@ -888,8 +890,8 @@ struct ImutProfileInfo<bool> {
 /// references to unique objects.
 template <typename T>
 struct ImutProfileInfo<T*> {
-  using value_type = const T*;
-  using value_type_ref = value_type;
+  typedef const T*   value_type;
+  typedef value_type value_type_ref;
 
   static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
     ID.AddPointer(X);
@@ -908,12 +910,12 @@ struct ImutProfileInfo<T*> {
 ///   std::equal_to<> and std::less<> to perform comparison of elements.
 template <typename T>
 struct ImutContainerInfo : public ImutProfileInfo<T> {
-  using value_type = typename ImutProfileInfo<T>::value_type;
-  using value_type_ref = typename ImutProfileInfo<T>::value_type_ref;
-  using key_type = value_type;
-  using key_type_ref = value_type_ref;
-  using data_type = bool;
-  using data_type_ref = bool;
+  typedef typename ImutProfileInfo<T>::value_type      value_type;
+  typedef typename ImutProfileInfo<T>::value_type_ref  value_type_ref;
+  typedef value_type      key_type;
+  typedef value_type_ref  key_type_ref;
+  typedef bool            data_type;
+  typedef bool            data_type_ref;
 
   static key_type_ref KeyOfValue(value_type_ref D) { return D; }
   static data_type_ref DataOfValue(value_type_ref) { return true; }
@@ -934,12 +936,12 @@ struct ImutContainerInfo : public ImutProfileInfo<T> {
 ///  their addresses.
 template <typename T>
 struct ImutContainerInfo<T*> : public ImutProfileInfo<T*> {
-  using value_type = typename ImutProfileInfo<T*>::value_type;
-  using value_type_ref = typename ImutProfileInfo<T*>::value_type_ref;
-  using key_type = value_type;
-  using key_type_ref = value_type_ref;
-  using data_type = bool;
-  using data_type_ref = bool;
+  typedef typename ImutProfileInfo<T*>::value_type      value_type;
+  typedef typename ImutProfileInfo<T*>::value_type_ref  value_type_ref;
+  typedef value_type      key_type;
+  typedef value_type_ref  key_type_ref;
+  typedef bool            data_type;
+  typedef bool            data_type_ref;
 
   static key_type_ref KeyOfValue(value_type_ref D) { return D; }
   static data_type_ref DataOfValue(value_type_ref) { return true; }
@@ -958,9 +960,9 @@ struct ImutContainerInfo<T*> : public ImutProfileInfo<T*> {
 template <typename ValT, typename ValInfo = ImutContainerInfo<ValT>>
 class ImmutableSet {
 public:
-  using value_type = typename ValInfo::value_type;
-  using value_type_ref = typename ValInfo::value_type_ref;
-  using TreeTy = ImutAVLTree<ValInfo>;
+  typedef typename ValInfo::value_type      value_type;
+  typedef typename ValInfo::value_type_ref  value_type_ref;
+  typedef ImutAVLTree<ValInfo> TreeTy;
 
 private:
   TreeTy *Root;
@@ -978,10 +980,6 @@ public:
     if (Root) { Root->retain(); }
   }
 
-  ~ImmutableSet() {
-    if (Root) { Root->release(); }
-  }
-
   ImmutableSet &operator=(const ImmutableSet &X) {
     if (Root != X.Root) {
       if (X.Root) { X.Root->retain(); }
@@ -991,6 +989,10 @@ public:
     return *this;
   }
 
+  ~ImmutableSet() {
+    if (Root) { Root->release(); }
+  }
+
   class Factory {
     typename TreeTy::Factory F;
     const bool Canonicalize;
@@ -1082,7 +1084,7 @@ public:
   // Iterators.
   //===--------------------------------------------------===//
 
-  using iterator = ImutAVLValueIterator<ImmutableSet>;
+  typedef ImutAVLValueIterator<ImmutableSet> iterator;
 
   iterator begin() const { return iterator(Root); }
   iterator end() const { return iterator(); }
@@ -1110,10 +1112,10 @@ public:
 template <typename ValT, typename ValInfo = ImutContainerInfo<ValT>>
 class ImmutableSetRef {
 public:
-  using value_type = typename ValInfo::value_type;
-  using value_type_ref = typename ValInfo::value_type_ref;
-  using TreeTy = ImutAVLTree<ValInfo>;
-  using FactoryTy = typename TreeTy::Factory;
+  typedef typename ValInfo::value_type      value_type;
+  typedef typename ValInfo::value_type_ref  value_type_ref;
+  typedef ImutAVLTree<ValInfo> TreeTy;
+  typedef typename TreeTy::Factory          FactoryTy;
 
 private:
   TreeTy *Root;
@@ -1136,10 +1138,6 @@ public:
     if (Root) { Root->retain(); }
   }
 
-  ~ImmutableSetRef() {
-    if (Root) { Root->release(); }
-  }
-
   ImmutableSetRef &operator=(const ImmutableSetRef &X) {
     if (Root != X.Root) {
       if (X.Root) { X.Root->retain(); }
@@ -1149,6 +1147,9 @@ public:
     }
     return *this;
   }
+  ~ImmutableSetRef() {
+    if (Root) { Root->release(); }
+  }
 
   static ImmutableSetRef getEmptySet(FactoryTy *F) {
     return ImmutableSetRef(0, F);
@@ -1195,7 +1196,7 @@ public:
   // Iterators.
   //===--------------------------------------------------===//
 
-  using iterator = ImutAVLValueIterator<ImmutableSetRef>;
+  typedef ImutAVLValueIterator<ImmutableSetRef> iterator;
 
   iterator begin() const { return iterator(Root); }
   iterator end() const { return iterator(); }
diff --git a/include/llvm/ADT/IndexedMap.h b/include/llvm/ADT/IndexedMap.h
index 04609d9d7bc..5ba85c02792 100644
--- a/include/llvm/ADT/IndexedMap.h
+++ b/include/llvm/ADT/IndexedMap.h
@@ -23,25 +23,25 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include <cassert>
+#include <functional>
 
 namespace llvm {
 
-template <typename T, typename ToIndexT = identity<unsigned>>
+template <typename T, typename ToIndexT = llvm::identity<unsigned> >
   class IndexedMap {
-    using IndexT = typename ToIndexT::argument_type;
+    typedef typename ToIndexT::argument_type IndexT;
     // Prefer SmallVector with zero inline storage over std::vector. IndexedMaps
     // can grow very large and SmallVector grows more efficiently as long as T
     // is trivially copyable.
-    using StorageT = SmallVector<T, 0>;
-
+    typedef SmallVector<T, 0> StorageT;
     StorageT storage_;
     T nullVal_;
     ToIndexT toIndex_;
 
   public:
-    IndexedMap() : nullVal_(T()) {}
+    IndexedMap() : nullVal_(T()) { }
 
-    explicit IndexedMap(const T& val) : nullVal_(val) {}
+    explicit IndexedMap(const T& val) : nullVal_(val) { }
 
     typename StorageT::reference operator[](IndexT n) {
       assert(toIndex_(n) < storage_.size() && "index out of bounds!");
@@ -80,6 +80,6 @@ template <typename T, typename ToIndexT = identity<unsigned>>
     }
   };
 
-} // end namespace llvm
+} // End llvm namespace
 
-#endif // LLVM_ADT_INDEXEDMAP_H
+#endif
diff --git a/include/llvm/ADT/IntervalMap.h b/include/llvm/ADT/IntervalMap.h
index f7136681121..430b9671bd1 100644
--- a/include/llvm/ADT/IntervalMap.h
+++ b/include/llvm/ADT/IntervalMap.h
@@ -106,7 +106,6 @@
 #include "llvm/Support/RecyclingAllocator.h"
 #include <algorithm>
 #include <cassert>
-#include <cstdint>
 #include <iterator>
 #include <new>
 #include <utility>
@@ -187,7 +186,7 @@ struct IntervalMapHalfOpenInfo {
 /// It should be considered private to the implementation.
 namespace IntervalMapImpl {
 
-using IdxPair = std::pair<unsigned,unsigned>;
+typedef std::pair<unsigned,unsigned> IdxPair;
 
 //===----------------------------------------------------------------------===//
 //---                    IntervalMapImpl::NodeBase                         ---//
@@ -446,7 +445,7 @@ struct NodeSizer {
     LeafSize = DesiredLeafSize > MinLeafSize ? DesiredLeafSize : MinLeafSize
   };
 
-  using LeafBase = NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize>;
+  typedef NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize> LeafBase;
 
   enum {
     // Now that we have the leaf branching factor, compute the actual allocation
@@ -462,8 +461,8 @@ struct NodeSizer {
   /// This typedef is very likely to be identical for all IntervalMaps with
   /// reasonably sized entries, so the same allocator can be shared among
   /// different kinds of maps.
-  using Allocator =
-      RecyclingAllocator<BumpPtrAllocator, char, AllocBytes, CacheLineBytes>;
+  typedef RecyclingAllocator<BumpPtrAllocator, char,
+                             AllocBytes, CacheLineBytes> Allocator;
 };
 
 //===----------------------------------------------------------------------===//
@@ -931,12 +930,12 @@ template <typename KeyT, typename ValT,
           unsigned N = IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
           typename Traits = IntervalMapInfo<KeyT>>
 class IntervalMap {
-  using Sizer = IntervalMapImpl::NodeSizer<KeyT, ValT>;
-  using Leaf = IntervalMapImpl::LeafNode<KeyT, ValT, Sizer::LeafSize, Traits>;
-  using Branch =
-      IntervalMapImpl::BranchNode<KeyT, ValT, Sizer::BranchSize, Traits>;
-  using RootLeaf = IntervalMapImpl::LeafNode<KeyT, ValT, N, Traits>;
-  using IdxPair = IntervalMapImpl::IdxPair;
+  typedef IntervalMapImpl::NodeSizer<KeyT, ValT> Sizer;
+  typedef IntervalMapImpl::LeafNode<KeyT, ValT, Sizer::LeafSize, Traits> Leaf;
+  typedef IntervalMapImpl::BranchNode<KeyT, ValT, Sizer::BranchSize, Traits>
+    Branch;
+  typedef IntervalMapImpl::LeafNode<KeyT, ValT, N, Traits> RootLeaf;
+  typedef IntervalMapImpl::IdxPair IdxPair;
 
   // The RootLeaf capacity is given as a template parameter. We must compute the
   // corresponding RootBranch capacity.
@@ -946,8 +945,8 @@ class IntervalMap {
     RootBranchCap = DesiredRootBranchCap ? DesiredRootBranchCap : 1
   };
 
-  using RootBranch =
-      IntervalMapImpl::BranchNode<KeyT, ValT, RootBranchCap, Traits>;
+  typedef IntervalMapImpl::BranchNode<KeyT, ValT, RootBranchCap, Traits>
+    RootBranch;
 
   // When branched, we store a global start key as well as the branch node.
   struct RootBranchData {
@@ -956,10 +955,10 @@ class IntervalMap {
   };
 
 public:
-  using Allocator = typename Sizer::Allocator;
-  using KeyType = KeyT;
-  using ValueType = ValT;
-  using KeyTraits = Traits;
+  typedef typename Sizer::Allocator Allocator;
+  typedef KeyT KeyType;
+  typedef ValT ValueType;
+  typedef Traits KeyTraits;
 
 private:
   // The root data is either a RootLeaf or a RootBranchData instance.
@@ -1291,7 +1290,7 @@ protected:
   friend class IntervalMap;
 
   // The map referred to.
-  IntervalMap *map = nullptr;
+  IntervalMap *map;
 
   // We store a full path from the root to the current position.
   // The path may be partially filled, but never between iterator calls.
@@ -1339,7 +1338,7 @@ protected:
 
 public:
   /// const_iterator - Create an iterator that isn't pointing anywhere.
-  const_iterator() = default;
+  const_iterator() : map(nullptr) {}
 
   /// setMap - Change the map iterated over. This call must be followed by a
   /// call to goToBegin(), goToEnd(), or find()
@@ -1510,8 +1509,7 @@ const_iterator::treeAdvanceTo(KeyT x) {
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
 class IntervalMap<KeyT, ValT, N, Traits>::iterator : public const_iterator {
   friend class IntervalMap;
-
-  using IdxPair = IntervalMapImpl::IdxPair;
+  typedef IntervalMapImpl::IdxPair IdxPair;
 
   explicit iterator(IntervalMap &map) : const_iterator(map) {}
 
@@ -2005,7 +2003,7 @@ iterator::overflow(unsigned Level) {
   // Elements have been rearranged, now update node sizes and stops.
   bool SplitRoot = false;
   unsigned Pos = 0;
-  while (true) {
+  for (;;) {
     KeyT Stop = Node[Pos]->stop(NewSize[Pos]-1);
     if (NewNode && Pos == NewNode) {
       SplitRoot = insertNode(Level, NodeRef(Node[Pos], NewSize[Pos]), Stop);
@@ -2047,9 +2045,8 @@ iterator::overflow(unsigned Level) {
 ///
 template <typename MapA, typename MapB>
 class IntervalMapOverlaps {
-  using KeyType = typename MapA::KeyType;
-  using Traits = typename MapA::KeyTraits;
-
+  typedef typename MapA::KeyType KeyType;
+  typedef typename MapA::KeyTraits Traits;
   typename MapA::const_iterator posA;
   typename MapB::const_iterator posB;
 
@@ -2074,7 +2071,7 @@ class IntervalMapOverlaps {
       // Already overlapping.
       return;
 
-    while (true) {
+    for (;;) {
       // Make a.end > b.start.
       posA.advanceTo(posB.start());
       if (!posA.valid() || !Traits::stopLess(posB.stop(), posA.start()))
diff --git a/include/llvm/ADT/IntrusiveRefCntPtr.h b/include/llvm/ADT/IntrusiveRefCntPtr.h
index 430ef86afbd..a77cf04ea4d 100644
--- a/include/llvm/ADT/IntrusiveRefCntPtr.h
+++ b/include/llvm/ADT/IntrusiveRefCntPtr.h
@@ -1,4 +1,4 @@
-//==- llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer --*- C++ -*-==//
+//== llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer ---*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -73,10 +73,9 @@ template <class Derived> class RefCountedBase {
 
 public:
   RefCountedBase() = default;
-  RefCountedBase(const RefCountedBase &) {}
+  RefCountedBase(const RefCountedBase &) : RefCount(0) {}
 
   void Retain() const { ++RefCount; }
-
   void Release() const {
     assert(RefCount > 0 && "Reference count is already zero.");
     if (--RefCount == 0)
@@ -137,7 +136,7 @@ template <typename T> class IntrusiveRefCntPtr {
   T *Obj = nullptr;
 
 public:
-  using element_type = T;
+  typedef T element_type;
 
   explicit IntrusiveRefCntPtr() = default;
   IntrusiveRefCntPtr(T *obj) : Obj(obj) { retain(); }
@@ -154,13 +153,13 @@ public:
     retain();
   }
 
-  ~IntrusiveRefCntPtr() { release(); }
-
   IntrusiveRefCntPtr &operator=(IntrusiveRefCntPtr S) {
     swap(S);
     return *this;
   }
 
+  ~IntrusiveRefCntPtr() { release(); }
+
   T &operator*() const { return *Obj; }
   T *operator->() const { return Obj; }
   T *get() const { return Obj; }
@@ -184,7 +183,6 @@ private:
     if (Obj)
       IntrusiveRefCntPtrInfo<T>::retain(Obj);
   }
-
   void release() {
     if (Obj)
       IntrusiveRefCntPtrInfo<T>::release(Obj);
@@ -250,16 +248,14 @@ bool operator!=(const IntrusiveRefCntPtr<T> &A, std::nullptr_t B) {
 template <typename From> struct simplify_type;
 
 template <class T> struct simplify_type<IntrusiveRefCntPtr<T>> {
-  using SimpleType = T *;
-
+  typedef T *SimpleType;
   static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T> &Val) {
     return Val.get();
   }
 };
 
 template <class T> struct simplify_type<const IntrusiveRefCntPtr<T>> {
-  using SimpleType = /*const*/ T *;
-
+  typedef /*const*/ T *SimpleType;
   static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T> &Val) {
     return Val.get();
   }
diff --git a/include/llvm/ADT/MapVector.h b/include/llvm/ADT/MapVector.h
index 26a555ee1d3..ac1885758cb 100644
--- a/include/llvm/ADT/MapVector.h
+++ b/include/llvm/ADT/MapVector.h
@@ -19,12 +19,6 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <iterator>
-#include <type_traits>
-#include <utility>
 #include <vector>
 
 namespace llvm {
@@ -33,20 +27,20 @@ namespace llvm {
 /// in a deterministic order. The values are kept in a std::vector and the
 /// mapping is done with DenseMap from Keys to indexes in that vector.
 template<typename KeyT, typename ValueT,
-         typename MapType = DenseMap<KeyT, unsigned>,
-         typename VectorType = std::vector<std::pair<KeyT, ValueT>>>
+         typename MapType = llvm::DenseMap<KeyT, unsigned>,
+         typename VectorType = std::vector<std::pair<KeyT, ValueT> > >
 class MapVector {
-  using value_type = typename VectorType::value_type;
-  using size_type = typename VectorType::size_type;
+  typedef typename VectorType::value_type value_type;
+  typedef typename VectorType::size_type size_type;
 
   MapType Map;
   VectorType Vector;
 
 public:
-  using iterator = typename VectorType::iterator;
-  using const_iterator = typename VectorType::const_iterator;
-  using reverse_iterator = typename VectorType::reverse_iterator;
-  using const_reverse_iterator = typename VectorType::const_reverse_iterator;
+  typedef typename VectorType::iterator iterator;
+  typedef typename VectorType::const_iterator const_iterator;
+  typedef typename VectorType::reverse_iterator reverse_iterator;
+  typedef typename VectorType::const_reverse_iterator const_reverse_iterator;
 
   /// Clear the MapVector and return the underlying vector.
   VectorType takeVector() {
@@ -226,4 +220,4 @@ struct SmallMapVector
 
 } // end namespace llvm
 
-#endif // LLVM_ADT_MAPVECTOR_H
+#endif
diff --git a/include/llvm/ADT/Optional.h b/include/llvm/ADT/Optional.h
index b782d9da17a..701872c9f63 100644
--- a/include/llvm/ADT/Optional.h
+++ b/include/llvm/ADT/Optional.h
@@ -1,4 +1,4 @@
-//===- Optional.h - Simple variant for passing optional values --*- C++ -*-===//
+//===-- Optional.h - Simple variant for passing optional values ---*- C++ -*-=//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -19,8 +19,6 @@
 #include "llvm/ADT/None.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/type_traits.h"
-#include <algorithm>
 #include <cassert>
 #include <new>
 #include <utility>
@@ -30,18 +28,15 @@ namespace llvm {
 template<typename T>
 class Optional {
   AlignedCharArrayUnion<T> storage;
-  bool hasVal = false;
-
+  bool hasVal;
 public:
-  using value_type = T;
-
-  Optional(NoneType) {}
-  explicit Optional() {}
+  typedef T value_type;
 
+  Optional(NoneType) : hasVal(false) {}
+  explicit Optional() : hasVal(false) {}
   Optional(const T &y) : hasVal(true) {
     new (storage.buffer) T(y);
   }
-
   Optional(const Optional &O) : hasVal(O.hasVal) {
     if (hasVal)
       new (storage.buffer) T(*O);
@@ -50,18 +45,12 @@ public:
   Optional(T &&y) : hasVal(true) {
     new (storage.buffer) T(std::forward<T>(y));
   }
-
   Optional(Optional<T> &&O) : hasVal(O) {
     if (O) {
       new (storage.buffer) T(std::move(*O));
       O.reset();
     }
   }
-
-  ~Optional() {
-    reset();
-  }
-
   Optional &operator=(T &&y) {
     if (hasVal)
       **this = std::move(y);
@@ -71,7 +60,6 @@ public:
     }
     return *this;
   }
-
   Optional &operator=(Optional &&O) {
     if (!O)
       reset();
@@ -124,6 +112,10 @@ public:
     }
   }
 
+  ~Optional() {
+    reset();
+  }
+
   const T* getPointer() const { assert(hasVal); return reinterpret_cast<const T*>(storage.buffer); }
   T* getPointer() { assert(hasVal); return reinterpret_cast<T*>(storage.buffer); }
   const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
@@ -152,7 +144,8 @@ public:
 #endif
 };
 
-template <typename T> struct isPodLike<Optional<T>> {
+template <typename T> struct isPodLike;
+template <typename T> struct isPodLike<Optional<T> > {
   // An Optional<T> is pod-like if T is.
   static const bool value = isPodLike<T>::value;
 };
@@ -291,6 +284,6 @@ template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
   return !(X < Y);
 }
 
-} // end namespace llvm
+} // end llvm namespace
 
-#endif // LLVM_ADT_OPTIONAL_H
+#endif
diff --git a/include/llvm/ADT/PackedVector.h b/include/llvm/ADT/PackedVector.h
index 95adc292681..8f925f1ff5c 100644
--- a/include/llvm/ADT/PackedVector.h
+++ b/include/llvm/ADT/PackedVector.h
@@ -76,8 +76,8 @@ template <typename T, unsigned BitNum, typename BitVectorTy = BitVector>
 class PackedVector : public PackedVectorBase<T, BitNum, BitVectorTy,
                                             std::numeric_limits<T>::is_signed> {
   BitVectorTy Bits;
-  using base = PackedVectorBase<T, BitNum, BitVectorTy,
-                                std::numeric_limits<T>::is_signed>;
+  typedef PackedVectorBase<T, BitNum, BitVectorTy,
+                           std::numeric_limits<T>::is_signed> base;
 
 public:
   class reference {
@@ -99,7 +99,7 @@ public:
   };
 
   PackedVector() = default;
-  explicit PackedVector(unsigned size) : Bits(size << (BitNum-1)) {}
+  explicit PackedVector(unsigned size) : Bits(size << (BitNum-1)) { }
 
   bool empty() const { return Bits.empty(); }
 
diff --git a/include/llvm/ADT/PointerEmbeddedInt.h b/include/llvm/ADT/PointerEmbeddedInt.h
index 34323b5b8af..2279d43405f 100644
--- a/include/llvm/ADT/PointerEmbeddedInt.h
+++ b/include/llvm/ADT/PointerEmbeddedInt.h
@@ -13,10 +13,7 @@
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
-#include <cassert>
 #include <climits>
-#include <cstdint>
-#include <type_traits>
 
 namespace llvm {
 
@@ -32,7 +29,7 @@ namespace llvm {
 /// Also, the default constructed value zero initializes the integer.
 template <typename IntT, int Bits = sizeof(IntT) * CHAR_BIT>
 class PointerEmbeddedInt {
-  uintptr_t Value = 0;
+  uintptr_t Value;
 
   // Note: This '<' is correct; using '<=' would result in some shifts
   // overflowing their storage types.
@@ -57,12 +54,15 @@ class PointerEmbeddedInt {
   explicit PointerEmbeddedInt(uintptr_t Value, RawValueTag) : Value(Value) {}
 
 public:
-  PointerEmbeddedInt() = default;
+  PointerEmbeddedInt() : Value(0) {}
 
-  PointerEmbeddedInt(IntT I) { *this = I; }
+  PointerEmbeddedInt(IntT I) {
+    *this = I;
+  }
 
   PointerEmbeddedInt &operator=(IntT I) {
-    assert((std::is_signed<IntT>::value ? isInt<Bits>(I) : isUInt<Bits>(I)) &&
+    assert((std::is_signed<IntT>::value ? llvm::isInt<Bits>(I)
+                                        : llvm::isUInt<Bits>(I)) &&
            "Integer has bits outside those preserved!");
     Value = static_cast<uintptr_t>(I) << Shift;
     return *this;
@@ -81,17 +81,15 @@ public:
 // types.
 template <typename IntT, int Bits>
 class PointerLikeTypeTraits<PointerEmbeddedInt<IntT, Bits>> {
-  using T = PointerEmbeddedInt<IntT, Bits>;
+  typedef PointerEmbeddedInt<IntT, Bits> T;
 
 public:
   static inline void *getAsVoidPointer(const T &P) {
     return reinterpret_cast<void *>(P.Value);
   }
-
   static inline T getFromVoidPointer(void *P) {
     return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
   }
-
   static inline T getFromVoidPointer(const void *P) {
     return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
   }
@@ -103,19 +101,17 @@ public:
 // itself can be a key.
 template <typename IntT, int Bits>
 struct DenseMapInfo<PointerEmbeddedInt<IntT, Bits>> {
-  using T = PointerEmbeddedInt<IntT, Bits>;
-  using IntInfo = DenseMapInfo<IntT>;
+  typedef PointerEmbeddedInt<IntT, Bits> T;
+
+  typedef DenseMapInfo<IntT> IntInfo;
 
   static inline T getEmptyKey() { return IntInfo::getEmptyKey(); }
   static inline T getTombstoneKey() { return IntInfo::getTombstoneKey(); }
-
   static unsigned getHashValue(const T &Arg) {
     return IntInfo::getHashValue(Arg);
   }
-
   static bool isEqual(const T &LHS, const T &RHS) { return LHS == RHS; }
 };
+}
 
-} // end namespace llvm
-
-#endif // LLVM_ADT_POINTEREMBEDDEDINT_H
+#endif
diff --git a/include/llvm/ADT/PointerIntPair.h b/include/llvm/ADT/PointerIntPair.h
index 2d49addb00f..83fbf127e6d 100644
--- a/include/llvm/ADT/PointerIntPair.h
+++ b/include/llvm/ADT/PointerIntPair.h
@@ -14,9 +14,9 @@
 #ifndef LLVM_ADT_POINTERINTPAIR_H
 #define LLVM_ADT_POINTERINTPAIR_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cassert>
-#include <cstdint>
 #include <limits>
 
 namespace llvm {
@@ -44,20 +44,20 @@ template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,
           typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
           typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
 class PointerIntPair {
-  intptr_t Value = 0;
+  intptr_t Value;
 
 public:
-  PointerIntPair() = default;
-
+  PointerIntPair() : Value(0) {}
   PointerIntPair(PointerTy PtrVal, IntType IntVal) {
     setPointerAndInt(PtrVal, IntVal);
   }
-
   explicit PointerIntPair(PointerTy PtrVal) { initWithPointer(PtrVal); }
 
   PointerTy getPointer() const { return Info::getPointer(Value); }
 
-  IntType getInt() const { return (IntType)Info::getInt(Value); }
+  IntType getInt() const {
+    return (IntType)Info::getInt(Value);
+  }
 
   void setPointer(PointerTy PtrVal) {
     Value = Info::updatePointer(Value, PtrVal);
@@ -88,7 +88,6 @@ public:
   }
 
   void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
-
   void setFromOpaqueValue(void *Val) {
     Value = reinterpret_cast<intptr_t>(Val);
   }
@@ -109,18 +108,14 @@ public:
   bool operator==(const PointerIntPair &RHS) const {
     return Value == RHS.Value;
   }
-
   bool operator!=(const PointerIntPair &RHS) const {
     return Value != RHS.Value;
   }
-
   bool operator<(const PointerIntPair &RHS) const { return Value < RHS.Value; }
   bool operator>(const PointerIntPair &RHS) const { return Value > RHS.Value; }
-
   bool operator<=(const PointerIntPair &RHS) const {
     return Value <= RHS.Value;
   }
-
   bool operator>=(const PointerIntPair &RHS) const {
     return Value >= RHS.Value;
   }
@@ -185,25 +180,21 @@ struct isPodLike<PointerIntPair<PointerTy, IntBits, IntType>> {
 // Provide specialization of DenseMapInfo for PointerIntPair.
 template <typename PointerTy, unsigned IntBits, typename IntType>
 struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {
-  using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
-
+  typedef PointerIntPair<PointerTy, IntBits, IntType> Ty;
   static Ty getEmptyKey() {
     uintptr_t Val = static_cast<uintptr_t>(-1);
     Val <<= PointerLikeTypeTraits<Ty>::NumLowBitsAvailable;
     return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
   }
-
   static Ty getTombstoneKey() {
     uintptr_t Val = static_cast<uintptr_t>(-2);
     Val <<= PointerLikeTypeTraits<PointerTy>::NumLowBitsAvailable;
     return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
   }
-
   static unsigned getHashValue(Ty V) {
     uintptr_t IV = reinterpret_cast<uintptr_t>(V.getOpaqueValue());
     return unsigned(IV) ^ unsigned(IV >> 9);
   }
-
   static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; }
 };
 
@@ -217,20 +208,16 @@ public:
   getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
     return P.getOpaqueValue();
   }
-
   static inline PointerIntPair<PointerTy, IntBits, IntType>
   getFromVoidPointer(void *P) {
     return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
   }
-
   static inline PointerIntPair<PointerTy, IntBits, IntType>
   getFromVoidPointer(const void *P) {
     return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
   }
-
   enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };
 };
 
 } // end namespace llvm
-
-#endif // LLVM_ADT_POINTERINTPAIR_H
+#endif
diff --git a/include/llvm/ADT/PointerSumType.h b/include/llvm/ADT/PointerSumType.h
index 825c62b51f6..062544eedf8 100644
--- a/include/llvm/ADT/PointerSumType.h
+++ b/include/llvm/ADT/PointerSumType.h
@@ -11,10 +11,8 @@
 #define LLVM_ADT_POINTERSUMTYPE_H
 
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
-#include <cassert>
-#include <cstdint>
-#include <type_traits>
 
 namespace llvm {
 
@@ -26,15 +24,16 @@ template <uintptr_t N, typename PointerArgT,
           typename TraitsArgT = PointerLikeTypeTraits<PointerArgT>>
 struct PointerSumTypeMember {
   enum { Tag = N };
-  using PointerT = PointerArgT;
-  using TraitsT = TraitsArgT;
+  typedef PointerArgT PointerT;
+  typedef TraitsArgT TraitsT;
 };
 
 namespace detail {
 
-template <typename TagT, typename... MemberTs> struct PointerSumTypeHelper;
+template <typename TagT, typename... MemberTs>
+struct PointerSumTypeHelper;
 
-} // end namespace detail
+}
 
 /// A sum type over pointer-like types.
 ///
@@ -61,12 +60,12 @@ template <typename TagT, typename... MemberTs> struct PointerSumTypeHelper;
 /// There is no support for constructing or accessing with a dynamic tag as
 /// that would fundamentally violate the type safety provided by the sum type.
 template <typename TagT, typename... MemberTs> class PointerSumType {
-  uintptr_t Value = 0;
+  uintptr_t Value;
 
-  using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
+  typedef detail::PointerSumTypeHelper<TagT, MemberTs...> HelperT;
 
 public:
-  PointerSumType() = default;
+  PointerSumType() : Value(0) {}
 
   /// A typed constructor for a specific tagged member of the sum type.
   template <TagT N>
@@ -129,14 +128,14 @@ struct PointerSumTypeHelper : MemberTs... {
   template <TagT N> static void LookupOverload(...);
   template <TagT N> struct Lookup {
     // Compute a particular member type by resolving the lookup helper ovorload.
-    using MemberT = decltype(
-        LookupOverload<N>(static_cast<PointerSumTypeHelper *>(nullptr)));
+    typedef decltype(LookupOverload<N>(
+        static_cast<PointerSumTypeHelper *>(nullptr))) MemberT;
 
     /// The Nth member's pointer type.
-    using PointerT = typename MemberT::PointerT;
+    typedef typename MemberT::PointerT PointerT;
 
     /// The Nth member's traits type.
-    using TraitsT = typename MemberT::TraitsT;
+    typedef typename MemberT::TraitsT TraitsT;
   };
 
   // Next we need to compute the number of bits available for the discriminant
@@ -172,37 +171,35 @@ struct PointerSumTypeHelper : MemberTs... {
                 "Each member must pass the checker.");
 };
 
-} // end namespace detail
+}
 
 // Teach DenseMap how to use PointerSumTypes as keys.
 template <typename TagT, typename... MemberTs>
 struct DenseMapInfo<PointerSumType<TagT, MemberTs...>> {
-  using SumType = PointerSumType<TagT, MemberTs...>;
+  typedef PointerSumType<TagT, MemberTs...> SumType;
 
-  using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
+  typedef detail::PointerSumTypeHelper<TagT, MemberTs...> HelperT;
   enum { SomeTag = HelperT::MinTag };
-  using SomePointerT =
-      typename HelperT::template Lookup<HelperT::MinTag>::PointerT;
-  using SomePointerInfo = DenseMapInfo<SomePointerT>;
+  typedef typename HelperT::template Lookup<HelperT::MinTag>::PointerT
+      SomePointerT;
+  typedef DenseMapInfo<SomePointerT> SomePointerInfo;
 
   static inline SumType getEmptyKey() {
     return SumType::create<SomeTag>(SomePointerInfo::getEmptyKey());
   }
-
   static inline SumType getTombstoneKey() {
-    return SumType::create<SomeTag>(SomePointerInfo::getTombstoneKey());
+    return SumType::create<SomeTag>(
+        SomePointerInfo::getTombstoneKey());
   }
-
   static unsigned getHashValue(const SumType &Arg) {
     uintptr_t OpaqueValue = Arg.getOpaqueValue();
     return DenseMapInfo<uintptr_t>::getHashValue(OpaqueValue);
   }
-
   static bool isEqual(const SumType &LHS, const SumType &RHS) {
     return LHS == RHS;
   }
 };
 
-} // end namespace llvm
+}
 
-#endif // LLVM_ADT_POINTERSUMTYPE_H
+#endif
diff --git a/include/llvm/ADT/PointerUnion.h b/include/llvm/ADT/PointerUnion.h
index d0497dd4029..9eb15524c0f 100644
--- a/include/llvm/ADT/PointerUnion.h
+++ b/include/llvm/ADT/PointerUnion.h
@@ -19,13 +19,13 @@
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cassert>
-#include <cstddef>
 #include <cstdint>
+#include <cstddef>
 
 namespace llvm {
 
 template <typename T> struct PointerUnionTypeSelectorReturn {
-  using Return = T;
+  typedef T Return;
 };
 
 /// Get a type based on whether two types are the same or not.
@@ -39,19 +39,19 @@ template <typename T> struct PointerUnionTypeSelectorReturn {
 /// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
 template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
 struct PointerUnionTypeSelector {
-  using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
+  typedef typename PointerUnionTypeSelectorReturn<RET_NE>::Return Return;
 };
 
 template <typename T, typename RET_EQ, typename RET_NE>
 struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
-  using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
+  typedef typename PointerUnionTypeSelectorReturn<RET_EQ>::Return Return;
 };
 
 template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
 struct PointerUnionTypeSelectorReturn<
     PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
-  using Return =
-      typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
+  typedef
+      typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return Return;
 };
 
 /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
@@ -86,8 +86,8 @@ public:
 ///    X = P.get<int*>();     // runtime assertion failure.
 template <typename PT1, typename PT2> class PointerUnion {
 public:
-  using ValTy =
-      PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>;
+  typedef PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>
+      ValTy;
 
 private:
   ValTy Val;
@@ -121,10 +121,10 @@ public:
 
   /// Test if the Union currently holds the type matching T.
   template <typename T> int is() const {
-    using Ty = typename ::llvm::PointerUnionTypeSelector<
-        PT1, T, IsPT1,
-        ::llvm::PointerUnionTypeSelector<PT2, T, IsPT2,
-                                         UNION_DOESNT_CONTAIN_TYPE<T>>>::Return;
+    typedef typename ::llvm::PointerUnionTypeSelector<
+        PT1, T, IsPT1, ::llvm::PointerUnionTypeSelector<
+                           PT2, T, IsPT2, UNION_DOESNT_CONTAIN_TYPE<T>>>::Return
+        Ty;
     int TyNo = Ty::Num;
     return static_cast<int>(Val.getInt()) == TyNo;
   }
@@ -228,22 +228,19 @@ public:
 /// for usage.
 template <typename PT1, typename PT2, typename PT3> class PointerUnion3 {
 public:
-  using InnerUnion = PointerUnion<PT1, PT2>;
-  using ValTy = PointerUnion<InnerUnion, PT3>;
+  typedef PointerUnion<PT1, PT2> InnerUnion;
+  typedef PointerUnion<InnerUnion, PT3> ValTy;
 
 private:
   ValTy Val;
 
   struct IsInnerUnion {
     ValTy Val;
-
     IsInnerUnion(ValTy val) : Val(val) {}
-
     template <typename T> int is() const {
       return Val.template is<InnerUnion>() &&
              Val.template get<InnerUnion>().template is<T>();
     }
-
     template <typename T> T get() const {
       return Val.template get<InnerUnion>().template get<T>();
     }
@@ -251,15 +248,14 @@ private:
 
   struct IsPT3 {
     ValTy Val;
-
     IsPT3(ValTy val) : Val(val) {}
-
     template <typename T> int is() const { return Val.template is<T>(); }
     template <typename T> T get() const { return Val.template get<T>(); }
   };
 
 public:
   PointerUnion3() = default;
+
   PointerUnion3(PT1 V) { Val = InnerUnion(V); }
   PointerUnion3(PT2 V) { Val = InnerUnion(V); }
   PointerUnion3(PT3 V) { Val = V; }
@@ -272,9 +268,10 @@ public:
   /// Test if the Union currently holds the type matching T.
   template <typename T> int is() const {
     // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.
-    using Ty = typename ::llvm::PointerUnionTypeSelector<
+    typedef typename ::llvm::PointerUnionTypeSelector<
         PT1, T, IsInnerUnion,
-        ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
+        ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return
+        Ty;
     return Ty(Val).template is<T>();
   }
 
@@ -284,9 +281,10 @@ public:
   template <typename T> T get() const {
     assert(is<T>() && "Invalid accessor called");
     // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.
-    using Ty = typename ::llvm::PointerUnionTypeSelector<
+    typedef typename ::llvm::PointerUnionTypeSelector<
         PT1, T, IsInnerUnion,
-        ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
+        ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return
+        Ty;
     return Ty(Val).template get<T>();
   }
 
@@ -352,15 +350,16 @@ public:
 template <typename PT1, typename PT2, typename PT3, typename PT4>
 class PointerUnion4 {
 public:
-  using InnerUnion1 = PointerUnion<PT1, PT2>;
-  using InnerUnion2 = PointerUnion<PT3, PT4>;
-  using ValTy = PointerUnion<InnerUnion1, InnerUnion2>;
+  typedef PointerUnion<PT1, PT2> InnerUnion1;
+  typedef PointerUnion<PT3, PT4> InnerUnion2;
+  typedef PointerUnion<InnerUnion1, InnerUnion2> ValTy;
 
 private:
   ValTy Val;
 
 public:
   PointerUnion4() = default;
+
   PointerUnion4(PT1 V) { Val = InnerUnion1(V); }
   PointerUnion4(PT2 V) { Val = InnerUnion1(V); }
   PointerUnion4(PT3 V) { Val = InnerUnion2(V); }
@@ -374,10 +373,9 @@ public:
   /// Test if the Union currently holds the type matching T.
   template <typename T> int is() const {
     // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.
-    using Ty = typename ::llvm::PointerUnionTypeSelector<
-        PT1, T, InnerUnion1,
-        ::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,
-                                         InnerUnion2>>::Return;
+    typedef typename ::llvm::PointerUnionTypeSelector<
+        PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector<
+                                 PT2, T, InnerUnion1, InnerUnion2>>::Return Ty;
     return Val.template is<Ty>() && Val.template get<Ty>().template is<T>();
   }
 
@@ -387,10 +385,9 @@ public:
   template <typename T> T get() const {
     assert(is<T>() && "Invalid accessor called");
     // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.
-    using Ty = typename ::llvm::PointerUnionTypeSelector<
-        PT1, T, InnerUnion1,
-        ::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,
-                                         InnerUnion2>>::Return;
+    typedef typename ::llvm::PointerUnionTypeSelector<
+        PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector<
+                                 PT2, T, InnerUnion1, InnerUnion2>>::Return Ty;
     return Val.template get<Ty>().template get<T>();
   }
 
@@ -458,21 +455,18 @@ public:
 
 // Teach DenseMap how to use PointerUnions as keys.
 template <typename T, typename U> struct DenseMapInfo<PointerUnion<T, U>> {
-  using Pair = PointerUnion<T, U>;
-  using FirstInfo = DenseMapInfo<T>;
-  using SecondInfo = DenseMapInfo<U>;
+  typedef PointerUnion<T, U> Pair;
+  typedef DenseMapInfo<T> FirstInfo;
+  typedef DenseMapInfo<U> SecondInfo;
 
   static inline Pair getEmptyKey() { return Pair(FirstInfo::getEmptyKey()); }
-
   static inline Pair getTombstoneKey() {
     return Pair(FirstInfo::getTombstoneKey());
   }
-
   static unsigned getHashValue(const Pair &PairVal) {
     intptr_t key = (intptr_t)PairVal.getOpaqueValue();
     return DenseMapInfo<intptr_t>::getHashValue(key);
   }
-
   static bool isEqual(const Pair &LHS, const Pair &RHS) {
     return LHS.template is<T>() == RHS.template is<T>() &&
            (LHS.template is<T>() ? FirstInfo::isEqual(LHS.template get<T>(),
diff --git a/include/llvm/ADT/simple_ilist.h b/include/llvm/ADT/simple_ilist.h
index 4c7598a1acb..a1ab5917084 100644
--- a/include/llvm/ADT/simple_ilist.h
+++ b/include/llvm/ADT/simple_ilist.h
@@ -13,14 +13,9 @@
 #include "llvm/ADT/ilist_base.h"
 #include "llvm/ADT/ilist_iterator.h"
 #include "llvm/ADT/ilist_node.h"
-#include "llvm/ADT/ilist_node_options.h"
-#include "llvm/Support/Compiler.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
-#include <functional>
-#include <iterator>
-#include <utility>
 
 namespace llvm {
 
@@ -82,23 +77,23 @@ class simple_ilist
           typename ilist_detail::compute_node_options<T, Options...>::type> {
   static_assert(ilist_detail::check_options<Options...>::value,
                 "Unrecognized node option!");
-  using OptionsT =
-      typename ilist_detail::compute_node_options<T, Options...>::type;
-  using list_base_type = typename OptionsT::list_base_type;
+  typedef
+      typename ilist_detail::compute_node_options<T, Options...>::type OptionsT;
+  typedef typename OptionsT::list_base_type list_base_type;
   ilist_sentinel<OptionsT> Sentinel;
 
 public:
-  using value_type = typename OptionsT::value_type;
-  using pointer = typename OptionsT::pointer;
-  using reference = typename OptionsT::reference;
-  using const_pointer = typename OptionsT::const_pointer;
-  using const_reference = typename OptionsT::const_reference;
-  using iterator = ilist_iterator<OptionsT, false, false>;
-  using const_iterator = ilist_iterator<OptionsT, false, true>;
-  using reverse_iterator = ilist_iterator<OptionsT, true, false>;
-  using const_reverse_iterator = ilist_iterator<OptionsT, true, true>;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
+  typedef typename OptionsT::value_type value_type;
+  typedef typename OptionsT::pointer pointer;
+  typedef typename OptionsT::reference reference;
+  typedef typename OptionsT::const_pointer const_pointer;
+  typedef typename OptionsT::const_reference const_reference;
+  typedef ilist_iterator<OptionsT, false, false> iterator;
+  typedef ilist_iterator<OptionsT, false, true> const_iterator;
+  typedef ilist_iterator<OptionsT, true, false> reverse_iterator;
+  typedef ilist_iterator<OptionsT, true, true> const_reverse_iterator;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
 
   simple_ilist() = default;
   ~simple_ilist() = default;