[LLVM] [ADT] Fix some Clang-tidy modernize-use-default and Include What You Use warnings; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

I think review in Phabricator will be better because ADT is fundamental part of LLVM and changes there cause long rebuilds.

[mehdi_amini]

I didn't quite get why you put it up for review? Why does the "ADT takes a long time to build" matter?

include/llvm/ADT/StringMap.h

20

There are no assert in this file, why is this needed?

[Eugene.Zelenko]

I put on review, some build bots could be slow.

include/llvm/ADT/StringMap.h

20

Asserts are used twice. May be file was not expanded when you look onto it?

[mehdi_amini]

include/llvm/ADT/StringMap.h

20

Likely!

include/llvm/ADT/DAGDeltaAlgorithm.h

 //===--- DAGDeltaAlgorithm.h - A DAG Minimization Algorithm ----*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_DAGDELTAALGORITHM_H
 #define LLVM_ADT_DAGDELTAALGORITHM_H
 
 #include <set>
+#include <utility>
 #include <vector>
 
 namespace llvm {
 
 /// DAGDeltaAlgorithm - Implements a "delta debugging" algorithm for minimizing
 /// directed acyclic graphs using a predicate function.
 ///
 /// The result of the algorithm is a subset of the input change set which is

 /// The minization algorithm uses this dependency information to attempt to
 /// eagerly prune large subsets of changes. As with \see DeltaAlgorithm, the DAG
 /// is not required to satisfy this property, but the algorithm will run
 /// substantially fewer tests with appropriate dependencies. \see DeltaAlgorithm
 /// for more information on the properties which the predicate function itself
 /// should satisfy.
 class DAGDeltaAlgorithm {
   virtual void anchor();
+
 public:
   typedef unsigned change_ty;
   typedef std::pair<change_ty, change_ty> edge_ty;
 
   // FIXME: Use a decent data structure.
   typedef std::set<change_ty> changeset_ty;
   typedef std::vector<changeset_ty> changesetlist_ty;
 
 public:
-  virtual ~DAGDeltaAlgorithm() {}
+  virtual ~DAGDeltaAlgorithm() = default;
 
   /// Run - Minimize the DAG formed by the \p Changes vertices and the
   /// \p Dependencies edges by executing \see ExecuteOneTest() on subsets of
   /// changes and returning the smallest set which still satisfies the test
   /// predicate and the input \p Dependencies.
   ///
   /// \param Changes The list of changes.
   ///
virtual void UpdatedSearchState(const changeset_ty &Changes,
                                   const changeset_ty &Required) {}
 
   /// ExecuteOneTest - Execute a single test predicate on the change set \p S.
   virtual bool ExecuteOneTest(const changeset_ty &S) = 0;
 };
 
 } // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_DAGDELTAALGORITHM_H

include/llvm/ADT/DepthFirstIterator.h

 //     other purposes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_DEPTHFIRSTITERATOR_H
 #define LLVM_ADT_DEPTHFIRSTITERATOR_H
 
 #include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/iterator_range.h"
+#include <iterator>
 #include <set>
+#include <utility>
 #include <vector>
 
 namespace llvm {
 
 // df_iterator_storage - A private class which is used to figure out where to
 // store the visited set.
 template<class SetType, bool External>   // Non-external set
 class df_iterator_storage {
 public:
   SetType Visited;
 };
 
 template<class SetType>
 class df_iterator_storage<SetType, true> {
 public:
   df_iterator_storage(SetType &VSet) : Visited(VSet) {}
   df_iterator_storage(const df_iterator_storage &S) : Visited(S.Visited) {}
+
   SetType &Visited;
 };
 
 // The visited stated for the iteration is a simple set augmented with
 // one more method, completed, which is invoked when all children of a
 // node have been processed. It is intended to distinguish of back and
 // cross edges in the spanning tree but is not used in the common case.
 template <typename NodeRef, unsigned SmallSize=8>
-struct df_iterator_default_set : public llvm::SmallPtrSet<NodeRef, SmallSize> {
-  typedef llvm::SmallPtrSet<NodeRef, SmallSize>  BaseSet;
+struct df_iterator_default_set : public SmallPtrSet<NodeRef, SmallSize> {
+  typedef SmallPtrSet<NodeRef, SmallSize>  BaseSet;
   typedef typename BaseSet::iterator iterator;
   std::pair<iterator,bool> insert(NodeRef N) { return BaseSet::insert(N) ; }
   template <typename IterT>
   void insert(IterT Begin, IterT End) { BaseSet::insert(Begin,End); }
 
   void completed(NodeRef) { }
 };
 
class df_iterator
   // 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() {
-    // End is when stack is empty
-  }
+  inline df_iterator() = default; // End is when stack is empty
   inline df_iterator(NodeRef Node, SetType &S)
       : df_iterator_storage<SetType, ExtStorage>(S) {
     if (this->Visited.insert(Node).second)
       VisitStack.push_back(StackElement(Node, None));
   }
   inline df_iterator(SetType &S)
     : df_iterator_storage<SetType, ExtStorage>(S) {
     // End is when stack is empty

 }
 
 template <class T, class SetTy>
 iterator_range<idf_ext_iterator<T, SetTy>> inverse_depth_first_ext(const T& G,
                                                                    SetTy &S) {
   return make_range(idf_ext_begin(G, S), idf_ext_end(G, S));
 }
 
-} // End llvm namespace
+} // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_DEPTHFIRSTITERATOR_H

include/llvm/ADT/EquivalenceClasses.h

 // Generic implementation of equivalence classes through the use Tarjan's
 // efficient union-find algorithm.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_EQUIVALENCECLASSES_H
 #define LLVM_ADT_EQUIVALENCECLASSES_H
 
-#include "llvm/Support/DataTypes.h"
 #include <cassert>
 #include <cstddef>
+#include <cstdint>
+#include <iterator>
 #include <set>
 
 namespace llvm {
 
 /// EquivalenceClasses - This represents a collection of equivalence classes and
 /// supports three efficient operations: insert an element into a class of its
 /// own, union two classes, and find the class for a given element.  In
 /// addition to these modification methods, it is possible to iterate over all
class EquivalenceClasses {
   /// "leader pointer" points to the node that is the leader for this element,
   /// if the node is not a leader.  A "end of list pointer" points to the last
   /// node in the list of members of this list.  Whether or not a node is a
   /// leader is determined by a bit stolen from one of the pointers.
   class ECValue {
     friend class EquivalenceClasses;
     mutable const ECValue *Leader, *Next;
     ElemTy Data;
+
     // ECValue ctor - Start out with EndOfList pointing to this node, Next is
     // Null, isLeader = true.
     ECValue(const ElemTy &Elt)
       : Leader(this), Next((ECValue*)(intptr_t)1), Data(Elt) {}
 
     const ECValue *getLeader() const {
       if (isLeader()) return this;
       if (Leader->isLeader()) return Leader;
       // Path compression.
       return Leader = Leader->getLeader();
     }
+
     const ECValue *getEndOfList() const {
       assert(isLeader() && "Cannot get the end of a list for a non-leader!");
       return Leader;
     }
 
     void setNext(const ECValue *NewNext) const {
       assert(getNext() == nullptr && "Already has a next pointer!");
       Next = (const ECValue*)((intptr_t)NewNext | (intptr_t)isLeader());
     }
+
   public:
     ECValue(const ECValue &RHS) : Leader(this), Next((ECValue*)(intptr_t)1),
                                   Data(RHS.Data) {
       // Only support copying of singleton nodes.
       assert(RHS.isLeader() && RHS.getNext() == nullptr && "Not a singleton!");
     }
 
     bool operator<(const ECValue &UFN) const { return Data < UFN.Data; }
public:
     bool operator<(const T &Val) const { return Data < Val; }
   };
 
   /// TheMapping - This implicitly provides a mapping from ElemTy values to the
   /// ECValues, it just keeps the key as part of the value.
   std::set<ECValue> TheMapping;
 
 public:
-  EquivalenceClasses() {}
+  EquivalenceClasses() = default;
   EquivalenceClasses(const EquivalenceClasses &RHS) {
     operator=(RHS);
   }
 
   const EquivalenceClasses &operator=(const EquivalenceClasses &RHS) {
     TheMapping.clear();
     for (iterator I = RHS.begin(), E = RHS.end(); I != E; ++I)
       if (I->isLeader()) {
public:
   /// Note that this is a linear time operation.
   unsigned getNumClasses() const {
     unsigned NC = 0;
     for (iterator I = begin(), E = end(); I != E; ++I)
       if (I->isLeader()) ++NC;
     return NC;
   }
 
-
   //===--------------------------------------------------------------------===//
   // Mutation methods
 
   /// insert - Insert a new value into the union/find set, ignoring the request
   /// if the value already exists.
   iterator insert(const ElemTy &Data) {
     return TheMapping.insert(ECValue(Data)).first;
   }
 
   /// findLeader - Given a value in the set, return a member iterator for the
   /// equivalence class it is in.  This does the path-compression part that
   /// makes union-find "union findy".  This returns an end iterator if the value
   /// is not in the equivalence class.
   ///
   member_iterator findLeader(iterator I) const {
     if (I == TheMapping.end()) return member_end();
     return member_iterator(I->getLeader());
   }
   member_iterator findLeader(const ElemTy &V) const {
     return findLeader(TheMapping.find(V));
   }
 
-
   /// union - Merge the two equivalence sets for the specified values, inserting
   /// them if they do not already exist in the equivalence set.
   member_iterator unionSets(const ElemTy &V1, const ElemTy &V2) {
     iterator V1I = insert(V1), V2I = insert(V2);
     return unionSets(findLeader(V1I), findLeader(V2I));
   }
   member_iterator unionSets(member_iterator L1, member_iterator L2) {
     assert(L1 != member_end() && L2 != member_end() && "Illegal inputs!");
public:
   }
 
   class member_iterator : public std::iterator<std::forward_iterator_tag,
                                                const ElemTy, ptrdiff_t> {
     typedef std::iterator<std::forward_iterator_tag,
                           const ElemTy, ptrdiff_t> super;
     const ECValue *Node;
     friend class EquivalenceClasses;
+
   public:
     typedef size_t size_type;
     typedef typename super::pointer pointer;
     typedef typename super::reference reference;
 
-    explicit member_iterator() {}
+    explicit member_iterator() = default;
     explicit member_iterator(const ECValue *N) : Node(N) {}
 
     reference operator*() const {
       assert(Node != nullptr && "Dereferencing end()!");
       return Node->getData();
     }
     pointer operator->() const { return &operator*(); }
 
bool operator==(const member_iterator &RHS) const {
       return Node == RHS.Node;
     }
     bool operator!=(const member_iterator &RHS) const {
       return Node != RHS.Node;
     }
   };
 };
 
-} // End llvm namespace
+} // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_EQUIVALENCECLASSES_H

include/llvm/ADT/FoldingSet.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_FOLDINGSET_H
 #define LLVM_ADT_FOLDINGSET_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/Allocator.h"
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
 
 namespace llvm {
+
 /// This folding set used for two purposes:
 ///   1. Given information about a node we want to create, look up the unique
 ///      instance of the node in the set.  If the node already exists, return
 ///      it, otherwise return the bucket it should be inserted into.
 ///   2. Given a node that has already been created, remove it from the set.
 ///
 /// This class is implemented as a single-link chained hash table, where the
 /// "buckets" are actually the nodes themselves (the next pointer is in the
public:
 
   /// empty - Returns true if there are no nodes in the folding set.
   bool empty() const { return NumNodes == 0; }
 
   /// reserve - Increase the number of buckets such that adding the
   /// EltCount-th node won't cause a rebucket operation. reserve is permitted
   /// to allocate more space than requested by EltCount.
   void reserve(unsigned EltCount);
+
   /// capacity - Returns the number of nodes permitted in the folding set
   /// before a rebucket operation is performed.
   unsigned capacity() {
     // We allow a load factor of up to 2.0,
     // so that means our capacity is NumBuckets * 2
     return NumBuckets * 2;
   }
 
 private:
   /// GrowHashTable - Double the size of the hash table and rehash everything.
   void GrowHashTable();
 
   /// GrowBucketCount - resize the hash table and rehash everything.
   /// NewBucketCount must be a power of two, and must be greater than the old
   /// bucket count.
   void GrowBucketCount(unsigned NewBucketCount);
+
 protected:
   /// GetNodeProfile - Instantiations of the FoldingSet template implement
   /// this function to gather data bits for the given node.
   virtual void GetNodeProfile(Node *N, FoldingSetNodeID &ID) const = 0;
+
   /// NodeEquals - Instantiations of the FoldingSet template implement
   /// this function to compare the given node with the given ID.
   virtual bool NodeEquals(Node *N, const FoldingSetNodeID &ID, unsigned IDHash,
                           FoldingSetNodeID &TempID) const=0;
+
   /// ComputeNodeHash - Instantiations of the FoldingSet template implement
   /// this function to compute a hash value for the given node.
   virtual unsigned ComputeNodeHash(Node *N, FoldingSetNodeID &TempID) const = 0;
 };
 
 //===----------------------------------------------------------------------===//
 
-template<typename T> struct FoldingSetTrait;
-
 /// DefaultFoldingSetTrait - This class provides default implementations
 /// for FoldingSetTrait implementations.
 ///
 template<typename T> struct DefaultFoldingSetTrait {
   static void Profile(const T &X, FoldingSetNodeID &ID) {
     X.Profile(ID);
   }
   static void Profile(T &X, FoldingSetNodeID &ID) {

 /// to "profile" (in the FoldingSet parlance) an object of a given type.
 /// The default behavior is to invoke a 'Profile' method on an object, but
 /// through template specialization the behavior can be tailored for specific
 /// types.  Combined with the FoldingSetNodeWrapper class, one can add objects
 /// to FoldingSets that were not originally designed to have that behavior.
 template<typename T> struct FoldingSetTrait
   : public DefaultFoldingSetTrait<T> {};
 
-template<typename T, typename Ctx> struct ContextualFoldingSetTrait;
-
 /// DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but
 /// for ContextualFoldingSets.
 template<typename T, typename Ctx>
 struct DefaultContextualFoldingSetTrait {
   static void Profile(T &X, FoldingSetNodeID &ID, Ctx Context) {
     X.Profile(ID, Context);
   }
+
   static inline bool Equals(T &X, const FoldingSetNodeID &ID, unsigned IDHash,
                             FoldingSetNodeID &TempID, Ctx Context);
   static inline unsigned ComputeHash(T &X, FoldingSetNodeID &TempID,
                                      Ctx Context);
 };
 
 /// ContextualFoldingSetTrait - Like FoldingSetTrait, but for
 /// ContextualFoldingSets.
 template<typename T, typename Ctx> struct ContextualFoldingSetTrait
   : public DefaultContextualFoldingSetTrait<T, Ctx> {};
 
 //===--------------------------------------------------------------------===//
 /// FoldingSetNodeIDRef - This class describes a reference to an interned
 /// FoldingSetNodeID, which can be a useful to store node id data rather
 /// than using plain FoldingSetNodeIDs, since the 32-element SmallVector
 /// is often much larger than necessary, and the possibility of heap
 /// allocation means it requires a non-trivial destructor call.
 class FoldingSetNodeIDRef {
-  const unsigned *Data;
-  size_t Size;
+  const unsigned *Data = nullptr;
+  size_t Size = 0;
 
 public:
-  FoldingSetNodeIDRef() : Data(nullptr), Size(0) {}
+  FoldingSetNodeIDRef() = default;
   FoldingSetNodeIDRef(const unsigned *D, size_t S) : Data(D), Size(S) {}
 
   /// ComputeHash - Compute a strong hash value for this FoldingSetNodeIDRef,
   /// used to lookup the node in the FoldingSetImpl.
   unsigned ComputeHash() const;
 
   bool operator==(FoldingSetNodeIDRef) const;
 

 /// hash value for the node.
 ///
 class FoldingSetNodeID {
   /// Bits - Vector of all the data bits that make the node unique.
   /// Use a SmallVector to avoid a heap allocation in the common case.
   SmallVector<unsigned, 32> Bits;
 
 public:
-  FoldingSetNodeID() {}
+  FoldingSetNodeID() = default;
 
   FoldingSetNodeID(FoldingSetNodeIDRef Ref)
     : Bits(Ref.getData(), Ref.getData() + Ref.getSize()) {}
 
   /// Add* - Add various data types to Bit data.
   ///
   void AddPointer(const void *Ptr);
   void AddInteger(signed I);

 template <class T> class FoldingSet final : public FoldingSetImpl {
 private:
   /// GetNodeProfile - Each instantiatation of the FoldingSet needs to provide a
   /// way to convert nodes into a unique specifier.
   void GetNodeProfile(Node *N, FoldingSetNodeID &ID) const override {
     T *TN = static_cast<T *>(N);
     FoldingSetTrait<T>::Profile(*TN, ID);
   }
+
   /// NodeEquals - Instantiations may optionally provide a way to compare a
   /// node with a specified ID.
   bool NodeEquals(Node *N, const FoldingSetNodeID &ID, unsigned IDHash,
                   FoldingSetNodeID &TempID) const override {
     T *TN = static_cast<T *>(N);
     return FoldingSetTrait<T>::Equals(*TN, ID, IDHash, TempID);
   }
+
   /// ComputeNodeHash - Instantiations may optionally provide a way to compute a
   /// hash value directly from a node.
   unsigned ComputeNodeHash(Node *N, FoldingSetNodeID &TempID) const override {
     T *TN = static_cast<T *>(N);
     return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
   }
 
 public:

 //===----------------------------------------------------------------------===//
 /// ContextualFoldingSet - This template class is a further refinement
 /// of FoldingSet which provides a context argument when calling
 /// Profile on its nodes.  Currently, that argument is fixed at
 /// initialization time.
 ///
 /// T must be a subclass of FoldingSetNode and implement a Profile
 /// function with signature
-///   void Profile(llvm::FoldingSetNodeID &, Ctx);
+///   void Profile(FoldingSetNodeID &, Ctx);
 template <class T, class Ctx>
 class ContextualFoldingSet final : public FoldingSetImpl {
   // Unfortunately, this can't derive from FoldingSet<T> because the
   // construction vtable for FoldingSet<T> requires
   // FoldingSet<T>::GetNodeProfile to be instantiated, which in turn
   // requires a single-argument T::Profile().
 
 private:
   Ctx Context;
 
   /// GetNodeProfile - Each instantiatation of the FoldingSet needs to provide a
   /// way to convert nodes into a unique specifier.
   void GetNodeProfile(FoldingSetImpl::Node *N,
                       FoldingSetNodeID &ID) const override {
     T *TN = static_cast<T *>(N);
     ContextualFoldingSetTrait<T, Ctx>::Profile(*TN, ID, Context);
   }
+
   bool NodeEquals(FoldingSetImpl::Node *N, const FoldingSetNodeID &ID,
                   unsigned IDHash, FoldingSetNodeID &TempID) const override {
     T *TN = static_cast<T *>(N);
     return ContextualFoldingSetTrait<T, Ctx>::Equals(*TN, ID, IDHash, TempID,
                                                      Context);
   }
+
   unsigned ComputeNodeHash(FoldingSetImpl::Node *N,
                            FoldingSetNodeID &TempID) const override {
     T *TN = static_cast<T *>(N);
     return ContextualFoldingSetTrait<T, Ctx>::ComputeHash(*TN, TempID, Context);
   }
 
 public:
   explicit ContextualFoldingSet(Ctx Context, unsigned Log2InitSize = 6)
public:
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetVector - This template class combines a FoldingSet and a vector
 /// to provide the interface of FoldingSet but with deterministic iteration
 /// order based on the insertion order. T must be a subclass of FoldingSetNode
 /// and implement a Profile function.
-template <class T, class VectorT = SmallVector<T*, 8> >
+template <class T, class VectorT = SmallVector<T*, 8>>
 class FoldingSetVector {
   FoldingSet<T> Set;
   VectorT Vector;
 
 public:
   explicit FoldingSetVector(unsigned Log2InitSize = 6)
       : Set(Log2InitSize) {
   }

 };
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetIteratorImpl - This is the common iterator support shared by all
 /// folding sets, which knows how to walk the folding set hash table.
 class FoldingSetIteratorImpl {
 protected:
   FoldingSetNode *NodePtr;
+
   FoldingSetIteratorImpl(void **Bucket);
+
   void advance();
 
 public:
   bool operator==(const FoldingSetIteratorImpl &RHS) const {
     return NodePtr == RHS.NodePtr;
   }
   bool operator!=(const FoldingSetIteratorImpl &RHS) const {
     return NodePtr != RHS.NodePtr;

 template<typename T> struct FoldingSetTrait<T*> {
   static inline void Profile(T *X, FoldingSetNodeID &ID) {
     ID.AddPointer(X);
   }
 };
 template <typename T1, typename T2>
 struct FoldingSetTrait<std::pair<T1, T2>> {
   static inline void Profile(const std::pair<T1, T2> &P,
-                             llvm::FoldingSetNodeID &ID) {
+                             FoldingSetNodeID &ID) {
     ID.Add(P.first);
     ID.Add(P.second);
   }
 };
-} // End of namespace llvm.
 
-#endif
+} // end namespace llvm
+
+#endif // LLVM_ADT_FOLDINGSET_H

include/llvm/ADT/ImmutableSet.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_IMMUTABLESET_H
 #define LLVM_ADT_IMMUTABLESET_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Allocator.h"
-#include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <functional>
 #include <vector>
+#include <cstdint>
+#include <iterator>
+#include <new>
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 // Immutable AVL-Tree Definition.
 //===----------------------------------------------------------------------===//
 
 template <typename ImutInfo> class ImutAVLFactory;
private:
   }
 
   //===----------------------------------------------------===//
   // Reference count operations.
   //===----------------------------------------------------===//
 
 public:
   void retain() { ++refCount; }
+
   void release() {
     assert(refCount > 0);
     if (--refCount == 0)
       destroy();
   }
+
   void destroy() {
     if (left)
       left->release();
     if (right)
       right->release();
     if (IsCanonicalized) {
       if (next)
         next->prev = prev;
class ImutAVLFactory {
   typedef DenseMap<unsigned, TreeTy*> CacheTy;
 
   CacheTy Cache;
   uintptr_t Allocator;
   std::vector<TreeTy*> createdNodes;
   std::vector<TreeTy*> freeNodes;
 
   bool ownsAllocator() const {
-    return Allocator & 0x1 ? false : true;
+    return (Allocator & 0x1) == 0;
   }
 
   BumpPtrAllocator& getAllocator() const {
     return *reinterpret_cast<BumpPtrAllocator*>(Allocator & ~0x1);
   }
 
   //===--------------------------------------------------===//
   // Public interface.
TreeTy* remove(TreeTy* T, key_type_ref V) {
     markImmutable(T);
     recoverNodes();
     return T;
   }
 
   TreeTy* getEmptyTree() const { return nullptr; }
 
 protected:
-
   //===--------------------------------------------------===//
   // A bunch of quick helper functions used for reasoning
   // about the properties of trees and their children.
   // These have succinct names so that the balancing code
   // is as terse (and readable) as possible.
   //===--------------------------------------------------===//
 
   bool            isEmpty(TreeTy* T) const { return !T; }

 // Immutable AVL-Tree Iterators.
 //===----------------------------------------------------------------------===//
 
 template <typename ImutInfo>
 class ImutAVLTreeGenericIterator
     : public std::iterator<std::bidirectional_iterator_tag,
                            ImutAVLTree<ImutInfo>> {
   SmallVector<uintptr_t,20> stack;
+
 public:
   enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3,
                    Flags=0x3 };
 
   typedef ImutAVLTree<ImutInfo> TreeTy;
 
-  ImutAVLTreeGenericIterator() {}
+  ImutAVLTreeGenericIterator() = default;
   ImutAVLTreeGenericIterator(const TreeTy *Root) {
     if (Root) stack.push_back(reinterpret_cast<uintptr_t>(Root));
   }
 
   TreeTy &operator*() const {
     assert(!stack.empty());
     return *reinterpret_cast<TreeTy *>(stack.back() & ~Flags);
   }
   TreeTy *operator->() const { return &*this; }
 
   uintptr_t getVisitState() const {
     assert(!stack.empty());
     return stack.back() & Flags;
   }
 
-
   bool atEnd() const { return stack.empty(); }
 
   bool atBeginning() const {
     return stack.size() == 1 && getVisitState() == VisitedNone;
   }
 
   void skipToParent() {
     assert(!stack.empty());
struct ImutProfileInfo<bool> {
   typedef const bool  value_type;
   typedef const bool& value_type_ref;
 
   static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
     ID.AddBoolean(X);
   }
 };
 
-
 /// Generic profile trait for pointer types.  We treat pointers as
 /// references to unique objects.
 template <typename T>
 struct ImutProfileInfo<T*> {
   typedef const T*   value_type;
   typedef value_type value_type_ref;
 
   static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
     ID.AddPointer(X);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Trait classes that contain element comparison operators and type
 //  definitions used by ImutAVLTree, ImmutableSet, and ImmutableMap.  These
 //  inherit from the profile traits (ImutProfileInfo) to include operations
 //  for element profiling.
 //===----------------------------------------------------------------------===//
 
-
 /// ImutContainerInfo - Generic definition of comparison operations for
 ///   elements of immutable containers that defaults to using
 ///   std::equal_to<> and std::less<> to perform comparison of elements.
 template <typename T>
 struct ImutContainerInfo : public ImutProfileInfo<T> {
   typedef typename ImutProfileInfo<T>::value_type      value_type;
   typedef typename ImutProfileInfo<T>::value_type_ref  value_type_ref;
   typedef value_type      key_type;
struct ImutContainerInfo<T*> : public ImutProfileInfo<T*> {
 
   static bool isDataEqual(data_type_ref, data_type_ref) { return true; }
 };
 
 //===----------------------------------------------------------------------===//
 // Immutable Set
 //===----------------------------------------------------------------------===//
 
-template <typename ValT, typename ValInfo = ImutContainerInfo<ValT> >
+template <typename ValT, typename ValInfo = ImutContainerInfo<ValT>>
 class ImmutableSet {
 public:
   typedef typename ValInfo::value_type      value_type;
   typedef typename ValInfo::value_type_ref  value_type_ref;
   typedef ImutAVLTree<ValInfo> TreeTy;
 
 private:
   TreeTy *Root;
 
 public:
   /// Constructs a set from a pointer to a tree root.  In general one
   /// should use a Factory object to create sets instead of directly
   /// invoking the constructor, but there are cases where make this
   /// constructor public is useful.
   explicit ImmutableSet(TreeTy* R) : Root(R) {
     if (Root) { Root->retain(); }
   }
+
   ImmutableSet(const ImmutableSet &X) : Root(X.Root) {
     if (Root) { Root->retain(); }
   }
+
   ImmutableSet &operator=(const ImmutableSet &X) {
     if (Root != X.Root) {
       if (X.Root) { X.Root->retain(); }
       if (Root) { Root->release(); }
       Root = X.Root;
     }
     return *this;
   }
+
   ~ImmutableSet() {
     if (Root) { Root->release(); }
   }
 
   class Factory {
     typename TreeTy::Factory F;
     const bool Canonicalize;
 
   public:
     Factory(bool canonicalize = true)
       : Canonicalize(canonicalize) {}
 
     Factory(BumpPtrAllocator& Alloc, bool canonicalize = true)
       : F(Alloc), Canonicalize(canonicalize) {}
 
+    Factory(const Factory& RHS) = delete;
+    void operator=(const Factory& RHS) = delete;
+
     /// getEmptySet - Returns an immutable set that contains no elements.
     ImmutableSet getEmptySet() {
       return ImmutableSet(F.getEmptyTree());
     }
 
     /// add - Creates a new immutable set that contains all of the values
     ///  of the original set with the addition of the specified value.  If
     ///  the original set already included the value, then the original set is
ImmutableSet remove(ImmutableSet Old, value_type_ref V) {
       return ImmutableSet(Canonicalize ? F.getCanonicalTree(NewT) : NewT);
     }
 
     BumpPtrAllocator& getAllocator() { return F.getAllocator(); }
 
     typename TreeTy::Factory *getTreeFactory() const {
       return const_cast<typename TreeTy::Factory *>(&F);
     }
-
-  private:
-    Factory(const Factory& RHS) = delete;
-    void operator=(const Factory& RHS) = delete;
   };
 
   friend class Factory;
 
   /// Returns true if the set contains the specified value.
   bool contains(value_type_ref V) const {
     return Root ? Root->contains(V) : false;
   }
public:
   //===--------------------------------------------------===//
   // For testing.
   //===--------------------------------------------------===//
 
   void validateTree() const { if (Root) Root->validateTree(); }
 };
 
 // NOTE: This may some day replace the current ImmutableSet.
-template <typename ValT, typename ValInfo = ImutContainerInfo<ValT> >
+template <typename ValT, typename ValInfo = ImutContainerInfo<ValT>>
 class ImmutableSetRef {
 public:
   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;
   FactoryTy *Factory;
 
 public:
   /// Constructs a set from a pointer to a tree root.  In general one
   /// should use a Factory object to create sets instead of directly
   /// invoking the constructor, but there are cases where make this
   /// constructor public is useful.
   explicit ImmutableSetRef(TreeTy* R, FactoryTy *F)
     : Root(R),
       Factory(F) {
     if (Root) { Root->retain(); }
   }
+
   ImmutableSetRef(const ImmutableSetRef &X)
     : Root(X.Root),
       Factory(X.Factory) {
     if (Root) { Root->retain(); }
   }
+
   ImmutableSetRef &operator=(const ImmutableSetRef &X) {
     if (Root != X.Root) {
       if (X.Root) { X.Root->retain(); }
       if (Root) { Root->release(); }
       Root = X.Root;
       Factory = X.Factory;
     }
     return *this;
public:
   // For testing.
   //===--------------------------------------------------===//
 
   void validateTree() const { if (Root) Root->validateTree(); }
 };
 
 } // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_IMMUTABLESET_H

include/llvm/ADT/IntervalMap.h

 #ifndef LLVM_ADT_INTERVALMAP_H
 #define LLVM_ADT_INTERVALMAP_H
 
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/RecyclingAllocator.h"
+#include <algorithm>
+#include <cassert>
 #include <iterator>
+#include <new>
+#include <utility>
 
 namespace llvm {
 
-
 //===----------------------------------------------------------------------===//
 //---                              Key traits                              ---//
 //===----------------------------------------------------------------------===//
 //
 // The IntervalMap works with closed or half-open intervals.
 // Adjacent intervals that map to the same value are coalesced.
 //
 // The IntervalMapInfo traits class is used to determine if a key is contained
 // in an interval, and if two intervals are adjacent so they can be coalesced.
 // The provided implementation works for closed integer intervals, other keys
 // probably need a specialized version.
 //
 // The point x is contained in [a;b] when !startLess(x, a) && !stopLess(b, x).
 //
 // It is assumed that (a;b] half-open intervals are not used, only [a;b) is
 // allowed. This is so that stopLess(a, b) can be used to determine if two
 // intervals overlap.
 //
 //===----------------------------------------------------------------------===//
 
 template <typename T>
 struct IntervalMapInfo {
-
   /// startLess - Return true if x is not in [a;b].
   /// This is x < a both for closed intervals and for [a;b) half-open intervals.
   static inline bool startLess(const T &x, const T &a) {
     return x < a;
   }
 
   /// stopLess - Return true if x is not in [a;b].
   /// This is b < x for a closed interval, b <= x for [a;b) half-open intervals.
   static inline bool stopLess(const T &b, const T &x) {
     return b < x;
   }
 
   /// adjacent - Return true when the intervals [x;a] and [b;y] can coalesce.
   /// This is a+1 == b for closed intervals, a == b for half-open intervals.
   static inline bool adjacent(const T &a, const T &b) {
     return a+1 == b;
   }
 
   /// nonEmpty - Return true if [a;b] is non-empty.
   /// This is a <= b for a closed interval, a < b for [a;b) half-open intervals.
   static inline bool nonEmpty(const T &a, const T &b) {
     return a <= b;
   }
-
 };
 
 template <typename T>
 struct IntervalMapHalfOpenInfo {
-
   /// startLess - Return true if x is not in [a;b).
   static inline bool startLess(const T &x, const T &a) {
     return x < a;
   }
 
   /// stopLess - Return true if x is not in [a;b).
   static inline bool stopLess(const T &b, const T &x) {
     return b <= x;
   }
 
   /// adjacent - Return true when the intervals [x;a) and [b;y) can coalesce.
   static inline bool adjacent(const T &a, const T &b) {
     return a == b;
   }
 
   /// nonEmpty - Return true if [a;b) is non-empty.
   static inline bool nonEmpty(const T &a, const T &b) {
     return a < b;
   }
-
 };
 
 /// IntervalMapImpl - Namespace used for IntervalMap implementation details.
 /// It should be considered private to the implementation.
 namespace IntervalMapImpl {
 
-// Forward declarations.
-template <typename, typename, unsigned, typename> class LeafNode;
-template <typename, typename, unsigned, typename> class BranchNode;
-
 typedef std::pair<unsigned,unsigned> IdxPair;
 
-
 //===----------------------------------------------------------------------===//
 //---                    IntervalMapImpl::NodeBase                         ---//
 //===----------------------------------------------------------------------===//
 //
 // Both leaf and branch nodes store vectors of pairs.
 // Leaves store ((KeyT, KeyT), ValT) pairs, branches use (NodeRef, KeyT).
 //
 // Keys and values are stored in separate arrays to avoid padding caused by

 /// @param NewSize  Array[Nodes] to receive the new node sizes.
 /// @param Position Insert position.
 /// @param Grow     Reserve space for a new element at Position.
 /// @return         (node, offset) for Position.
 IdxPair distribute(unsigned Nodes, unsigned Elements, unsigned Capacity,
                    const unsigned *CurSize, unsigned NewSize[],
                    unsigned Position, bool Grow);
 
-
 //===----------------------------------------------------------------------===//
 //---                   IntervalMapImpl::NodeSizer                         ---//
 //===----------------------------------------------------------------------===//
 //
 // Compute node sizes from key and value types.
 //
 // The branching factors are chosen to make nodes fit in three cache lines.
 // This may not be possible if keys or values are very large. Such large objects
struct NodeSizer {
   };
 
   /// Allocator - The recycling allocator used for both branch and leaf nodes.
   /// 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.
   typedef RecyclingAllocator<BumpPtrAllocator, char,
                              AllocBytes, CacheLineBytes> Allocator;
-
 };
 
-
 //===----------------------------------------------------------------------===//
 //---                     IntervalMapImpl::NodeRef                         ---//
 //===----------------------------------------------------------------------===//
 //
 // B+-tree nodes can be leaves or branches, so we need a polymorphic node
 // pointer that can point to both kinds.
 //
 // All nodes are cache line aligned and the low 6 bits of a node pointer are
struct CacheAlignedPointerTraits {
     static inline void *getAsVoidPointer(void *P) { return P; }
     static inline void *getFromVoidPointer(void *P) { return P; }
     enum { NumLowBitsAvailable = Log2CacheLine };
   };
   PointerIntPair<void*, Log2CacheLine, unsigned, CacheAlignedPointerTraits> pip;
 
 public:
   /// NodeRef - Create a null ref.
-  NodeRef() {}
+  NodeRef() = default;
 
   /// operator bool - Detect a null ref.
   explicit operator bool() const { return pip.getOpaqueValue(); }
 
   /// NodeRef - Create a reference to the node p with n elements.
   template <typename NodeT>
   NodeRef(NodeT *p, unsigned n) : pip(p, n - 1) {
     assert(n <= NodeT::Capacity && "Size too big for node");
insertFrom(unsigned &Pos, unsigned Size, KeyT a, KeyT b, ValT y) {
   // Insert before i.
   this->shift(i, Size);
   start(i) = a;
   stop(i) = b;
   value(i) = y;
   return Size + 1;
 }
 
-
 //===----------------------------------------------------------------------===//
 //---                   IntervalMapImpl::BranchNode                        ---//
 //===----------------------------------------------------------------------===//
 //
 // A branch node stores references to 1--N subtrees all of the same height.
 //
 // The key array in a branch node holds the rightmost stop key of each subtree.
 // It is redundant to store the last stop key since it can be found in the
public:
   void legalizeForInsert(unsigned Level) {
     if (valid())
       return;
     moveLeft(Level);
     ++path[Level].offset;
   }
 };
 
-} // namespace IntervalMapImpl
-
+} // end namespace IntervalMapImpl
 
 //===----------------------------------------------------------------------===//
 //---                          IntervalMap                                ----//
 //===----------------------------------------------------------------------===//
 
 template <typename KeyT, typename ValT,
           unsigned N = IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
-          typename Traits = IntervalMapInfo<KeyT> >
+          typename Traits = IntervalMapInfo<KeyT>>
 class IntervalMap {
   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;
 
private:
   const RootLeaf &rootLeaf() const {
     assert(!branched() && "Cannot acces leaf data in branched root");
     return dataAs<RootLeaf>();
   }
   RootLeaf &rootLeaf() {
     assert(!branched() && "Cannot acces leaf data in branched root");
     return dataAs<RootLeaf>();
   }
+
   RootBranchData &rootBranchData() const {
     assert(branched() && "Cannot access branch data in non-branched root");
     return dataAs<RootBranchData>();
   }
   RootBranchData &rootBranchData() {
     assert(branched() && "Cannot access branch data in non-branched root");
     return dataAs<RootBranchData>();
   }
+
   const RootBranch &rootBranch() const { return rootBranchData().node; }
   RootBranch &rootBranch()             { return rootBranchData().node; }
   KeyT rootBranchStart() const { return rootBranchData().start; }
   KeyT &rootBranchStart()      { return rootBranchData().start; }
 
   template <typename NodeT> NodeT *newNode() {
     return new(allocator.template Allocate<NodeT>()) NodeT();
   }
treeSafeLookup(KeyT x, ValT NotFound) const {
   assert(branched() && "treeLookup assumes a branched root");
 
   IntervalMapImpl::NodeRef NR = rootBranch().safeLookup(x);
   for (unsigned h = height-1; h; --h)
     NR = NR.get<Branch>().safeLookup(x);
   return NR.get<Leaf>().safeLookup(x, NotFound);
 }
 
-
 // branchRoot - Switch from a leaf root to a branched root.
 // Return the new (root offset, node offset) corresponding to Position.
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
 IntervalMapImpl::IdxPair IntervalMap<KeyT, ValT, N, Traits>::
 branchRoot(unsigned Position) {
   using namespace IntervalMapImpl;
   // How many external leaf nodes to hold RootLeaf+1?
   const unsigned Nodes = RootLeaf::Capacity / Leaf::Capacity + 1;

 
 //===----------------------------------------------------------------------===//
 //---                   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:
   friend class IntervalMap;
 
   // The map referred to.
   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.
void advanceTo(KeyT x) {
     if (!valid())
       return;
     if (branched())
       treeAdvanceTo(x);
     else
       path.leafOffset() =
         map->rootLeaf().findFrom(path.leafOffset(), map->rootSize, x);
   }
-
 };
 
 /// pathFillFind - Complete path by searching for x.
 /// @param x Key to search for.
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
 void IntervalMap<KeyT, ValT, N, Traits>::
 const_iterator::pathFillFind(KeyT x) {
   IntervalMapImpl::NodeRef NR = path.subtree(path.height());
class IntervalMap<KeyT, ValT, N, Traits>::iterator : public const_iterator {
   void treeInsert(KeyT a, KeyT b, ValT y);
   void eraseNode(unsigned Level);
   void treeErase(bool UpdateRoot = true);
   bool canCoalesceLeft(KeyT Start, ValT x);
   bool canCoalesceRight(KeyT Stop, ValT x);
 
 public:
   /// iterator - Create null iterator.
-  iterator() {}
+  iterator() = default;
 
   /// setStart - Move the start of the current interval.
   /// This may cause coalescing with the previous interval.
   /// @param a New start key, must not overlap the previous interval.
   void setStart(KeyT a);
 
   /// setStop - Move the end of the current interval.
   /// This may cause coalescing with the following interval.
iterator &operator--() {
     return *this;
   }
 
   iterator operator--(int) {
     iterator tmp = *this;
     operator--();
     return tmp;
   }
-
 };
 
 /// canCoalesceLeft - Can the current interval coalesce to the left after
 /// changing start or value?
 /// @param Start New start of current interval.
 /// @param Value New value for current interval.
 /// @return True when updating the current interval would enable coalescing.
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
iterator::insert(KeyT a, KeyT b, ValT y) {
   // Root leaf node is full, we must branch.
   IdxPair Offset = IM.branchRoot(P.leafOffset());
   P.replaceRoot(&IM.rootBranch(), IM.rootSize, Offset);
 
   // Now it fits in the new leaf.
   treeInsert(a, b, y);
 }
 
-
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
 void IntervalMap<KeyT, ValT, N, Traits>::
 iterator::treeInsert(KeyT a, KeyT b, ValT y) {
   using namespace IntervalMapImpl;
   Path &P = this->path;
 
   if (!P.valid())
     P.legalizeForInsert(this->map->height);
void advanceTo(KeyType x) {
     if (Traits::stopLess(posA.stop(), x))
       posA.advanceTo(x);
     if (Traits::stopLess(posB.stop(), x))
       posB.advanceTo(x);
     advance();
   }
 };
 
-} // namespace llvm
+} // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_INTERVALMAP_H

include/llvm/ADT/IntrusiveRefCntPtr.h

 #define LLVM_ADT_INTRUSIVEREFCNTPTR_H
 
 #include <atomic>
 #include <cassert>
 #include <cstddef>
 
 namespace llvm {
 
-  template <class T>
-  class IntrusiveRefCntPtr;
-
 //===----------------------------------------------------------------------===//
 /// RefCountedBase - A generic base class for objects that wish to
 ///  have their lifetimes managed using reference counts. Classes
 ///  subclass RefCountedBase to obtain such functionality, and are
 ///  typically handled with IntrusiveRefCntPtr "smart pointers" (see below)
 ///  which automatically handle the management of reference counts.
 ///  Objects that subclass RefCountedBase should not be allocated on
 ///  the stack, as invoking "delete" (which is called when the
 ///  reference count hits 0) on such objects is an error.
 //===----------------------------------------------------------------------===//
   template <class Derived>
   class RefCountedBase {
-    mutable unsigned ref_cnt;
+    mutable unsigned ref_cnt = 0;
 
   public:
-    RefCountedBase() : ref_cnt(0) {}
+    RefCountedBase() = default;
     RefCountedBase(const RefCountedBase &) : ref_cnt(0) {}
 
     void Retain() const { ++ref_cnt; }
     void Release() const {
       assert (ref_cnt > 0 && "Reference count is already zero.");
       if (--ref_cnt == 0) delete static_cast<const Derived*>(this);
     }
   };
 
 //===----------------------------------------------------------------------===//
 /// RefCountedBaseVPTR - A class that has the same function as
 ///  RefCountedBase, but with a virtual destructor. Should be used
 ///  instead of RefCountedBase for classes that already have virtual
 ///  methods to enforce dynamic allocation via 'new'. Classes that
 ///  inherit from RefCountedBaseVPTR can't be allocated on stack -
 ///  attempting to do this will produce a compile error.
 //===----------------------------------------------------------------------===//
   class RefCountedBaseVPTR {
-    mutable unsigned ref_cnt;
+    mutable unsigned ref_cnt = 0;
+
     virtual void anchor();
 
   protected:
-    RefCountedBaseVPTR() : ref_cnt(0) {}
+    RefCountedBaseVPTR() = default;
     RefCountedBaseVPTR(const RefCountedBaseVPTR &) : ref_cnt(0) {}
 
-    virtual ~RefCountedBaseVPTR() {}
+    virtual ~RefCountedBaseVPTR() = default;
 
     void Retain() const { ++ref_cnt; }
     void Release() const {
       assert (ref_cnt > 0 && "Reference count is already zero.");
       if (--ref_cnt == 0) delete this;
     }
 
     template <typename T>

 /// Reference counting is implemented via calls to
 ///  Obj->Retain()/Obj->Release(). Release() is required to destroy
 ///  the object when the reference count reaches zero. Inheriting from
 ///  RefCountedBase/RefCountedBaseVPTR takes care of this
 ///  automatically.
 //===----------------------------------------------------------------------===//
   template <typename T>
   class IntrusiveRefCntPtr {
-    T* Obj;
+    T* Obj = nullptr;
 
   public:
     typedef T element_type;
 
-    explicit IntrusiveRefCntPtr() : Obj(nullptr) {}
+    explicit IntrusiveRefCntPtr() = default;
 
     IntrusiveRefCntPtr(T* obj) : Obj(obj) {
       retain();
     }
 
     IntrusiveRefCntPtr(const IntrusiveRefCntPtr& S) : Obj(S.Obj) {
       retain();
     }
//===----------------------------------------------------------------------===//
   }
 
 //===----------------------------------------------------------------------===//
 // LLVM-style downcasting support for IntrusiveRefCntPtr objects
 //===----------------------------------------------------------------------===//
 
   template <typename From> struct simplify_type;
 
-  template<class T> struct simplify_type<IntrusiveRefCntPtr<T> > {
+  template<class T> struct simplify_type<IntrusiveRefCntPtr<T>> {
     typedef T* SimpleType;
     static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T>& Val) {
       return Val.get();
     }
   };
 
-  template<class T> struct simplify_type<const IntrusiveRefCntPtr<T> > {
+  template<class T> struct simplify_type<const IntrusiveRefCntPtr<T>> {
     typedef /*const*/ T* SimpleType;
     static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T>& Val) {
       return Val.get();
     }
   };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_INTRUSIVEREFCNTPTR_H

include/llvm/ADT/PointerUnion.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_POINTERUNION_H
 #define LLVM_ADT_POINTERUNION_H
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/PointerIntPair.h"
-#include "llvm/Support/Compiler.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
+#include <cassert>
+#include <cstdint>
+#include <cstddef>
 
 namespace llvm {
 
 template <typename T> struct PointerUnionTypeSelectorReturn {
   typedef T Return;
 };
 
 /// Get a type based on whether two types are the same or not.

 };
 
 /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
 /// for the two template arguments.
 template <typename PT1, typename PT2> class PointerUnionUIntTraits {
 public:
   static inline void *getAsVoidPointer(void *P) { return P; }
   static inline void *getFromVoidPointer(void *P) { return P; }
+
   enum {
     PT1BitsAv = (int)(PointerLikeTypeTraits<PT1>::NumLowBitsAvailable),
     PT2BitsAv = (int)(PointerLikeTypeTraits<PT2>::NumLowBitsAvailable),
     NumLowBitsAvailable = PT1BitsAv < PT2BitsAv ? PT1BitsAv : PT2BitsAv
   };
 };
 
 /// A discriminated union of two pointer types, with the discriminator in the
struct IsPT1 {
     static const int Num = 0;
   };
   struct IsPT2 {
     static const int Num = 1;
   };
   template <typename T> struct UNION_DOESNT_CONTAIN_TYPE {};
 
 public:
-  PointerUnion() {}
+  PointerUnion() = default;
 
   PointerUnion(PT1 V)
       : Val(const_cast<void *>(
             PointerLikeTypeTraits<PT1>::getAsVoidPointer(V))) {}
   PointerUnion(PT2 V)
       : Val(const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(V)),
             1) {}
 

 // Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
 // # low bits available = min(PT1bits,PT2bits)-1.
 template <typename PT1, typename PT2>
 class PointerLikeTypeTraits<PointerUnion<PT1, PT2>> {
 public:
   static inline void *getAsVoidPointer(const PointerUnion<PT1, PT2> &P) {
     return P.getOpaqueValue();
   }
+
   static inline PointerUnion<PT1, PT2> getFromVoidPointer(void *P) {
     return PointerUnion<PT1, PT2>::getFromOpaqueValue(P);
   }
 
   // The number of bits available are the min of the two pointer types.
   enum {
     NumLowBitsAvailable = PointerLikeTypeTraits<
         typename PointerUnion<PT1, PT2>::ValTy>::NumLowBitsAvailable
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() {}
+  PointerUnion3() = default;
 
   PointerUnion3(PT1 V) { Val = InnerUnion(V); }
   PointerUnion3(PT2 V) { Val = InnerUnion(V); }
   PointerUnion3(PT3 V) { Val = V; }
 
   /// Test if the pointer held in the union is null, regardless of
   /// which type it is.
   bool isNull() const { return Val.isNull(); }

 // Teach SmallPtrSet that PointerUnion3 is "basically a pointer", that has
 // # low bits available = min(PT1bits,PT2bits,PT2bits)-2.
 template <typename PT1, typename PT2, typename PT3>
 class PointerLikeTypeTraits<PointerUnion3<PT1, PT2, PT3>> {
 public:
   static inline void *getAsVoidPointer(const PointerUnion3<PT1, PT2, PT3> &P) {
     return P.getOpaqueValue();
   }
+
   static inline PointerUnion3<PT1, PT2, PT3> getFromVoidPointer(void *P) {
     return PointerUnion3<PT1, PT2, PT3>::getFromOpaqueValue(P);
   }
 
   // The number of bits available are the min of the two pointer types.
   enum {
     NumLowBitsAvailable = PointerLikeTypeTraits<
         typename PointerUnion3<PT1, PT2, PT3>::ValTy>::NumLowBitsAvailable
   };
 };
 
 /// A pointer union of four pointer types. See documentation for PointerUnion
 /// for usage.
 template <typename PT1, typename PT2, typename PT3, typename PT4>
 class PointerUnion4 {
 public:
   typedef PointerUnion<PT1, PT2> InnerUnion1;
   typedef PointerUnion<PT3, PT4> InnerUnion2;
   typedef PointerUnion<InnerUnion1, InnerUnion2> ValTy;
 
 private:
   ValTy Val;
 
 public:
-  PointerUnion4() {}
+  PointerUnion4() = default;
 
   PointerUnion4(PT1 V) { Val = InnerUnion1(V); }
   PointerUnion4(PT2 V) { Val = InnerUnion1(V); }
   PointerUnion4(PT3 V) { Val = InnerUnion2(V); }
   PointerUnion4(PT4 V) { Val = InnerUnion2(V); }
 
   /// Test if the pointer held in the union is null, regardless of
   /// which type it is.

 // # low bits available = min(PT1bits,PT2bits,PT2bits)-2.
 template <typename PT1, typename PT2, typename PT3, typename PT4>
 class PointerLikeTypeTraits<PointerUnion4<PT1, PT2, PT3, PT4>> {
 public:
   static inline void *
   getAsVoidPointer(const PointerUnion4<PT1, PT2, PT3, PT4> &P) {
     return P.getOpaqueValue();
   }
+
   static inline PointerUnion4<PT1, PT2, PT3, PT4> getFromVoidPointer(void *P) {
     return PointerUnion4<PT1, PT2, PT3, PT4>::getFromOpaqueValue(P);
   }
 
   // The number of bits available are the min of the two pointer types.
   enum {
     NumLowBitsAvailable = PointerLikeTypeTraits<
         typename PointerUnion4<PT1, PT2, PT3, PT4>::ValTy>::NumLowBitsAvailable
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>(),
                                                       RHS.template get<T>())
                                  : SecondInfo::isEqual(LHS.template get<U>(),
                                                        RHS.template get<U>()));
   }
 };
 
-}
+} // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_POINTERUNION_H

include/llvm/ADT/SmallString.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_SMALLSTRING_H
 #define LLVM_ADT_SMALLSTRING_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include <cstddef>
 
 namespace llvm {
 
 /// SmallString - A SmallString is just a SmallVector with methods and accessors
 /// that make it work better as a string (e.g. operator+ etc).
 template<unsigned InternalLen>
 class SmallString : public SmallVector<char, InternalLen> {
 public:
   /// Default ctor - Initialize to empty.
-  SmallString() {}
+  SmallString() = default;
 
   /// Initialize from a StringRef.
   SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
 
   /// Initialize with a range.
   template<typename ItTy>
   SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}
 
public:
   void append(in_iter S, in_iter E) {
     SmallVectorImpl<char>::append(S, E);
   }
 
   void append(size_t NumInputs, char Elt) {
     SmallVectorImpl<char>::append(NumInputs, Elt);
   }
 
-
   /// Append from a StringRef.
   void append(StringRef RHS) {
     SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
   }
 
   /// Append from a SmallVector.
   void append(const SmallVectorImpl<char> &RHS) {
     SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
SmallString &operator+=(StringRef RHS) {
     return *this;
   }
   SmallString &operator+=(char C) {
     this->push_back(C);
     return *this;
   }
 };
 
-}
+} // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_SMALLSTRING_H

include/llvm/ADT/StringMap.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STRINGMAP_H
 #define LLVM_ADT_STRINGMAP_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
+#include <cassert>
+#include <cstdint>
+#include <cstdlib>
 #include <cstring>
 #include <utility>
+#include <initializer_list>
+#include <new>
+#include <utility>
 
 namespace llvm {
+
   template<typename ValueT>
   class StringMapConstIterator;
   template<typename ValueT>
   class StringMapIterator;
   template<typename ValueTy>
   class StringMapEntry;
 
 /// StringMapEntryBase - Shared base class of StringMapEntry instances.
public:
   }
 };
 
 /// StringMapEntry - This is used to represent one value that is inserted into
 /// a StringMap.  It contains the Value itself and the key: the string length
 /// and data.
 template<typename ValueTy>
 class StringMapEntry : public StringMapEntryBase {
-  StringMapEntry(StringMapEntry &E) = delete;
-
 public:
   ValueTy second;
 
   explicit StringMapEntry(unsigned strLen)
     : StringMapEntryBase(strLen), second() {}
   template <typename... InitTy>
   StringMapEntry(unsigned strLen, InitTy &&... InitVals)
       : StringMapEntryBase(strLen), second(std::forward<InitTy>(InitVals)...) {}
+  StringMapEntry(StringMapEntry &E) = delete;
 
   StringRef getKey() const {
     return StringRef(getKeyData(), getKeyLength());
   }
 
   const ValueTy &getValue() const { return second; }
   ValueTy &getValue() { return second; }
 
if (!empty()) {
       }
     }
     free(TheTable);
   }
 };
 
 template <typename ValueTy> class StringMapConstIterator {
 protected:
-  StringMapEntryBase **Ptr;
+  StringMapEntryBase **Ptr = nullptr;
 
 public:
   typedef StringMapEntry<ValueTy> value_type;
 
-  StringMapConstIterator() : Ptr(nullptr) { }
+  StringMapConstIterator() = default;
 
   explicit StringMapConstIterator(StringMapEntryBase **Bucket,
                                   bool NoAdvance = false)
   : Ptr(Bucket) {
     if (!NoAdvance) AdvancePastEmptyBuckets();
   }
 
   const value_type &operator*() const {
void AdvancePastEmptyBuckets() {
     while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal())
       ++Ptr;
   }
 };
 
 template<typename ValueTy>
 class StringMapIterator : public StringMapConstIterator<ValueTy> {
 public:
-  StringMapIterator() {}
+  StringMapIterator() = default;
+
   explicit StringMapIterator(StringMapEntryBase **Bucket,
                              bool NoAdvance = false)
     : StringMapConstIterator<ValueTy>(Bucket, NoAdvance) {
   }
+
   StringMapEntry<ValueTy> &operator*() const {
     return *static_cast<StringMapEntry<ValueTy>*>(*this->Ptr);
   }
   StringMapEntry<ValueTy> *operator->() const {
     return static_cast<StringMapEntry<ValueTy>*>(*this->Ptr);
   }
 };
-}
 
-#endif
+} // end namespace llvm
+
+#endif // LLVM_ADT_STRINGMAP_H

include/llvm/ADT/iterator.h

 //===- iterator.h - Utilities for using and defining iterators --*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_ITERATOR_H
 #define LLVM_ADT_ITERATOR_H
 
 #include <cstddef>
 #include <iterator>
+#include <type_traits>
 
 namespace llvm {
 
 /// \brief CRTP base class which implements the entire standard iterator facade
 /// in terms of a minimal subset of the interface.
 ///
 /// Use this when it is reasonable to implement most of the iterator
 /// functionality in terms of a core subset. If you need special behavior or

 template <typename WrappedIteratorT,
           typename T = decltype(&*std::declval<WrappedIteratorT>())>
 class pointer_iterator
     : public iterator_adaptor_base<pointer_iterator<WrappedIteratorT>,
                                    WrappedIteratorT, T> {
   mutable T Ptr;
 
 public:
-  pointer_iterator() {}
+  pointer_iterator() = default;
 
   explicit pointer_iterator(WrappedIteratorT u)
       : pointer_iterator::iterator_adaptor_base(std::move(u)) {}
 
   T &operator*() { return Ptr = &*this->I; }
   const T &operator*() const { return Ptr = &*this->I; }
 };
 
-} // namespace llvm
+} // end namespace llvm
 
-#endif
+#endif // LLVM_ADT_ITERATOR_H