[llvm] r303383 - [ADT] Fix some Clang-tidy modernize-use-using warnings; other minor fixes (NFC).
Adam Nemet via llvm-commits
llvm-commits at lists.llvm.org
Thu May 18 20:12:03 PDT 2017
Hi Eugene,
This is causing the modules-enabled macOS build to break with:
lib/Support/LockFileManager.cpp:86:7: error: declaration of 'gethostuuid' must be imported from module 'Darwin.POSIX.unistd' before it is required
I reverted in r303402 while we investigate.
Adam
> On May 18, 2017, at 2:27 PM, Eugene Zelenko via llvm-commits <llvm-commits at lists.llvm.org> wrote:
>
> Author: eugenezelenko
> Date: Thu May 18 16:27:11 2017
> New Revision: 303383
>
> URL: http://llvm.org/viewvc/llvm-project?rev=303383&view=rev
> Log:
> [ADT] Fix some Clang-tidy modernize-use-using warnings; other minor fixes (NFC).
>
> Modified:
> llvm/trunk/include/llvm/ADT/ImmutableList.h
> llvm/trunk/include/llvm/ADT/ImmutableMap.h
> llvm/trunk/include/llvm/ADT/ImmutableSet.h
> llvm/trunk/include/llvm/ADT/IndexedMap.h
> llvm/trunk/include/llvm/ADT/IntervalMap.h
> llvm/trunk/include/llvm/ADT/IntrusiveRefCntPtr.h
> llvm/trunk/include/llvm/ADT/MapVector.h
> llvm/trunk/include/llvm/ADT/Optional.h
> llvm/trunk/include/llvm/ADT/PackedVector.h
> llvm/trunk/include/llvm/ADT/PointerEmbeddedInt.h
> llvm/trunk/include/llvm/ADT/PointerIntPair.h
> llvm/trunk/include/llvm/ADT/PointerSumType.h
> llvm/trunk/include/llvm/ADT/PointerUnion.h
> llvm/trunk/include/llvm/ADT/simple_ilist.h
>
> Modified: llvm/trunk/include/llvm/ADT/ImmutableList.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/ImmutableList.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/ImmutableList.h (original)
> +++ llvm/trunk/include/llvm/ADT/ImmutableList.h Thu May 18 16:27:11 2017
> @@ -63,8 +63,8 @@ public:
> template <typename T>
> class ImmutableList {
> public:
> - typedef T value_type;
> - typedef ImmutableListFactory<T> Factory;
> + using value_type = T;
> + using Factory = ImmutableListFactory<T>;
>
> private:
> const ImmutableListImpl<T>* X;
> @@ -141,8 +141,8 @@ public:
>
> template <typename T>
> class ImmutableListFactory {
> - typedef ImmutableListImpl<T> ListTy;
> - typedef FoldingSet<ListTy> CacheTy;
> + using ListTy = ImmutableListImpl<T>;
> + using CacheTy = FoldingSet<ListTy>;
>
> CacheTy Cache;
> uintptr_t Allocator;
>
> Modified: llvm/trunk/include/llvm/ADT/ImmutableMap.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/ImmutableMap.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/ImmutableMap.h (original)
> +++ llvm/trunk/include/llvm/ADT/ImmutableMap.h Thu May 18 16:27:11 2017
> @@ -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 {
> - 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;
> + 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&;
>
> 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:
> - 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;
> + 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>;
>
> protected:
> TreeTy* Root;
> @@ -86,6 +86,10 @@ 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(); }
> @@ -95,10 +99,6 @@ public:
> return *this;
> }
>
> - ~ImmutableMap() {
> - if (Root) { Root->release(); }
> - }
> -
> class Factory {
> typename TreeTy::Factory F;
> const bool Canonicalize;
> @@ -166,12 +166,14 @@ 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); }
> @@ -254,14 +256,14 @@ template <typename KeyT, typename ValT,
> typename ValInfo = ImutKeyValueInfo<KeyT,ValT>>
> class ImmutableMapRef {
> public:
> - 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;
> + 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;
>
> protected:
> TreeTy *Root;
> @@ -292,6 +294,11 @@ public:
> }
> }
>
> + ~ImmutableMapRef() {
> + if (Root)
> + Root->release();
> + }
> +
> ImmutableMapRef &operator=(const ImmutableMapRef &X) {
> if (Root != X.Root) {
> if (X.Root)
> @@ -306,11 +313,6 @@ public:
> return *this;
> }
>
> - ~ImmutableMapRef() {
> - if (Root)
> - Root->release();
> - }
> -
> static inline ImmutableMapRef getEmptyMap(FactoryTy *F) {
> return ImmutableMapRef(0, F);
> }
>
> Modified: llvm/trunk/include/llvm/ADT/ImmutableSet.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/ImmutableSet.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/ImmutableSet.h (original)
> +++ llvm/trunk/include/llvm/ADT/ImmutableSet.h Thu May 18 16:27:11 2017
> @@ -41,18 +41,16 @@ template <typename ImutInfo> class ImutA
> template <typename ImutInfo >
> class ImutAVLTree {
> public:
> - 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;
> + 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 ImutAVLFactory<ImutInfo> Factory;
> friend class ImutAVLFactory<ImutInfo>;
> friend class ImutIntervalAVLFactory<ImutInfo>;
> -
> friend class ImutAVLTreeGenericIterator<ImutInfo>;
>
> - typedef ImutAVLTreeInOrderIterator<ImutInfo> iterator;
> -
> //===----------------------------------------------------===//
> // Public Interface.
> //===----------------------------------------------------===//
> @@ -225,17 +223,17 @@ private:
> Factory *factory;
> ImutAVLTree *left;
> ImutAVLTree *right;
> - ImutAVLTree *prev;
> - ImutAVLTree *next;
> + ImutAVLTree *prev = nullptr;
> + ImutAVLTree *next = nullptr;
>
> - unsigned height : 28;
> - unsigned IsMutable : 1;
> - unsigned IsDigestCached : 1;
> - unsigned IsCanonicalized : 1;
> + unsigned height : 28;
> + bool IsMutable : 1;
> + bool IsDigestCached : 1;
> + bool IsCanonicalized : 1;
>
> value_type value;
> - uint32_t digest;
> - uint32_t refCount;
> + uint32_t digest = 0;
> + uint32_t refCount = 0;
>
> //===----------------------------------------------------===//
> // Internal methods (node manipulation; used by Factory).
> @@ -246,9 +244,8 @@ private:
> /// ImutAVLFactory.
> ImutAVLTree(Factory *f, ImutAVLTree* l, ImutAVLTree* r, value_type_ref v,
> unsigned height)
> - : factory(f), left(l), right(r), prev(nullptr), next(nullptr),
> - height(height), IsMutable(true), IsDigestCached(false),
> - IsCanonicalized(0), value(v), digest(0), refCount(0)
> + : factory(f), left(l), right(r), height(height), IsMutable(true),
> + IsDigestCached(false), IsCanonicalized(false), value(v)
> {
> if (left) left->retain();
> if (right) right->retain();
> @@ -369,11 +366,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;
>
> - typedef DenseMap<unsigned, TreeTy*> CacheTy;
> + 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*>;
>
> CacheTy Cache;
> uintptr_t Allocator;
> @@ -659,7 +656,7 @@ public:
> enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3,
> Flags=0x3 };
>
> - typedef ImutAVLTree<ImutInfo> TreeTy;
> + using TreeTy = ImutAVLTree<ImutInfo>;
>
> ImutAVLTreeGenericIterator() = default;
> ImutAVLTreeGenericIterator(const TreeTy *Root) {
> @@ -764,11 +761,12 @@ template <typename ImutInfo>
> class ImutAVLTreeInOrderIterator
> : public std::iterator<std::bidirectional_iterator_tag,
> ImutAVLTree<ImutInfo>> {
> - typedef ImutAVLTreeGenericIterator<ImutInfo> InternalIteratorTy;
> + using InternalIteratorTy = ImutAVLTreeGenericIterator<ImutInfo>;
> +
> InternalIteratorTy InternalItr;
>
> public:
> - typedef ImutAVLTree<ImutInfo> TreeTy;
> + using TreeTy = ImutAVLTree<ImutInfo>;
>
> ImutAVLTreeInOrderIterator(const TreeTy* Root) : InternalItr(Root) {
> if (Root)
> @@ -840,8 +838,8 @@ struct ImutAVLValueIterator
> /// and generic handling of pointers is done below.
> template <typename T>
> struct ImutProfileInfo {
> - typedef const T value_type;
> - typedef const T& value_type_ref;
> + using value_type = const T;
> + using value_type_ref = const T&;
>
> static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
> FoldingSetTrait<T>::Profile(X,ID);
> @@ -851,8 +849,8 @@ struct ImutProfileInfo {
> /// Profile traits for integers.
> template <typename T>
> struct ImutProfileInteger {
> - typedef const T value_type;
> - typedef const T& value_type_ref;
> + using value_type = const T;
> + using value_type_ref = const T&;
>
> static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
> ID.AddInteger(X);
> @@ -878,8 +876,8 @@ PROFILE_INTEGER_INFO(unsigned long long)
> /// Profile traits for booleans.
> template <>
> struct ImutProfileInfo<bool> {
> - typedef const bool value_type;
> - typedef const bool& value_type_ref;
> + using value_type = const bool;
> + using value_type_ref = const bool&;
>
> static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
> ID.AddBoolean(X);
> @@ -890,8 +888,8 @@ struct ImutProfileInfo<bool> {
> /// references to unique objects.
> template <typename T>
> struct ImutProfileInfo<T*> {
> - typedef const T* value_type;
> - typedef value_type value_type_ref;
> + using value_type = const T*;
> + using value_type_ref = value_type;
>
> static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
> ID.AddPointer(X);
> @@ -910,12 +908,12 @@ struct ImutProfileInfo<T*> {
> /// 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;
> - typedef value_type_ref key_type_ref;
> - typedef bool data_type;
> - typedef bool data_type_ref;
> + 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;
>
> static key_type_ref KeyOfValue(value_type_ref D) { return D; }
> static data_type_ref DataOfValue(value_type_ref) { return true; }
> @@ -936,12 +934,12 @@ struct ImutContainerInfo : public ImutPr
> /// their addresses.
> template <typename T>
> struct ImutContainerInfo<T*> : 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;
> - typedef value_type_ref key_type_ref;
> - typedef bool data_type;
> - typedef bool data_type_ref;
> + 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;
>
> static key_type_ref KeyOfValue(value_type_ref D) { return D; }
> static data_type_ref DataOfValue(value_type_ref) { return true; }
> @@ -960,9 +958,9 @@ struct ImutContainerInfo<T*> : public Im
> 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;
> + using value_type = typename ValInfo::value_type;
> + using value_type_ref = typename ValInfo::value_type_ref;
> + using TreeTy = ImutAVLTree<ValInfo>;
>
> private:
> TreeTy *Root;
> @@ -980,6 +978,10 @@ 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(); }
> @@ -989,10 +991,6 @@ public:
> return *this;
> }
>
> - ~ImmutableSet() {
> - if (Root) { Root->release(); }
> - }
> -
> class Factory {
> typename TreeTy::Factory F;
> const bool Canonicalize;
> @@ -1084,7 +1082,7 @@ public:
> // Iterators.
> //===--------------------------------------------------===//
>
> - typedef ImutAVLValueIterator<ImmutableSet> iterator;
> + using iterator = ImutAVLValueIterator<ImmutableSet>;
>
> iterator begin() const { return iterator(Root); }
> iterator end() const { return iterator(); }
> @@ -1112,10 +1110,10 @@ public:
> 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;
> + 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;
>
> private:
> TreeTy *Root;
> @@ -1138,6 +1136,10 @@ 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(); }
> @@ -1147,9 +1149,6 @@ public:
> }
> return *this;
> }
> - ~ImmutableSetRef() {
> - if (Root) { Root->release(); }
> - }
>
> static ImmutableSetRef getEmptySet(FactoryTy *F) {
> return ImmutableSetRef(0, F);
> @@ -1196,7 +1195,7 @@ public:
> // Iterators.
> //===--------------------------------------------------===//
>
> - typedef ImutAVLValueIterator<ImmutableSetRef> iterator;
> + using iterator = ImutAVLValueIterator<ImmutableSetRef>;
>
> iterator begin() const { return iterator(Root); }
> iterator end() const { return iterator(); }
>
> Modified: llvm/trunk/include/llvm/ADT/IndexedMap.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/IndexedMap.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/IndexedMap.h (original)
> +++ llvm/trunk/include/llvm/ADT/IndexedMap.h Thu May 18 16:27:11 2017
> @@ -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 = llvm::identity<unsigned> >
> +template <typename T, typename ToIndexT = identity<unsigned>>
> class IndexedMap {
> - typedef typename ToIndexT::argument_type IndexT;
> + using IndexT = typename ToIndexT::argument_type;
> // 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.
> - typedef SmallVector<T, 0> StorageT;
> + using StorageT = SmallVector<T, 0>;
> +
> 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
> }
> };
>
> -} // End llvm namespace
> +} // end namespace llvm
>
> -#endif
> +#endif // LLVM_ADT_INDEXEDMAP_H
>
> Modified: llvm/trunk/include/llvm/ADT/IntervalMap.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/IntervalMap.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/IntervalMap.h (original)
> +++ llvm/trunk/include/llvm/ADT/IntervalMap.h Thu May 18 16:27:11 2017
> @@ -106,6 +106,7 @@
> #include "llvm/Support/RecyclingAllocator.h"
> #include <algorithm>
> #include <cassert>
> +#include <cstdint>
> #include <iterator>
> #include <new>
> #include <utility>
> @@ -186,7 +187,7 @@ struct IntervalMapHalfOpenInfo {
> /// It should be considered private to the implementation.
> namespace IntervalMapImpl {
>
> -typedef std::pair<unsigned,unsigned> IdxPair;
> +using IdxPair = std::pair<unsigned,unsigned>;
>
> //===----------------------------------------------------------------------===//
> //--- IntervalMapImpl::NodeBase ---//
> @@ -445,7 +446,7 @@ struct NodeSizer {
> LeafSize = DesiredLeafSize > MinLeafSize ? DesiredLeafSize : MinLeafSize
> };
>
> - typedef NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize> LeafBase;
> + using LeafBase = NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize>;
>
> enum {
> // Now that we have the leaf branching factor, compute the actual allocation
> @@ -461,8 +462,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.
> - typedef RecyclingAllocator<BumpPtrAllocator, char,
> - AllocBytes, CacheLineBytes> Allocator;
> + using Allocator =
> + RecyclingAllocator<BumpPtrAllocator, char, AllocBytes, CacheLineBytes>;
> };
>
> //===----------------------------------------------------------------------===//
> @@ -930,12 +931,12 @@ template <typename KeyT, typename ValT,
> unsigned N = IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
> 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;
> + 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;
>
> // The RootLeaf capacity is given as a template parameter. We must compute the
> // corresponding RootBranch capacity.
> @@ -945,8 +946,8 @@ class IntervalMap {
> RootBranchCap = DesiredRootBranchCap ? DesiredRootBranchCap : 1
> };
>
> - typedef IntervalMapImpl::BranchNode<KeyT, ValT, RootBranchCap, Traits>
> - RootBranch;
> + using RootBranch =
> + IntervalMapImpl::BranchNode<KeyT, ValT, RootBranchCap, Traits>;
>
> // When branched, we store a global start key as well as the branch node.
> struct RootBranchData {
> @@ -955,10 +956,10 @@ class IntervalMap {
> };
>
> public:
> - typedef typename Sizer::Allocator Allocator;
> - typedef KeyT KeyType;
> - typedef ValT ValueType;
> - typedef Traits KeyTraits;
> + using Allocator = typename Sizer::Allocator;
> + using KeyType = KeyT;
> + using ValueType = ValT;
> + using KeyTraits = Traits;
>
> private:
> // The root data is either a RootLeaf or a RootBranchData instance.
> @@ -1290,7 +1291,7 @@ protected:
> friend class IntervalMap;
>
> // The map referred to.
> - IntervalMap *map;
> + IntervalMap *map = nullptr;
>
> // We store a full path from the root to the current position.
> // The path may be partially filled, but never between iterator calls.
> @@ -1338,7 +1339,7 @@ protected:
>
> public:
> /// const_iterator - Create an iterator that isn't pointing anywhere.
> - const_iterator() : map(nullptr) {}
> + const_iterator() = default;
>
> /// setMap - Change the map iterated over. This call must be followed by a
> /// call to goToBegin(), goToEnd(), or find()
> @@ -1509,7 +1510,8 @@ 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;
> - typedef IntervalMapImpl::IdxPair IdxPair;
> +
> + using IdxPair = IntervalMapImpl::IdxPair;
>
> explicit iterator(IntervalMap &map) : const_iterator(map) {}
>
> @@ -2003,7 +2005,7 @@ iterator::overflow(unsigned Level) {
> // Elements have been rearranged, now update node sizes and stops.
> bool SplitRoot = false;
> unsigned Pos = 0;
> - for (;;) {
> + while (true) {
> KeyT Stop = Node[Pos]->stop(NewSize[Pos]-1);
> if (NewNode && Pos == NewNode) {
> SplitRoot = insertNode(Level, NodeRef(Node[Pos], NewSize[Pos]), Stop);
> @@ -2045,8 +2047,9 @@ iterator::overflow(unsigned Level) {
> ///
> template <typename MapA, typename MapB>
> class IntervalMapOverlaps {
> - typedef typename MapA::KeyType KeyType;
> - typedef typename MapA::KeyTraits Traits;
> + using KeyType = typename MapA::KeyType;
> + using Traits = typename MapA::KeyTraits;
> +
> typename MapA::const_iterator posA;
> typename MapB::const_iterator posB;
>
> @@ -2071,7 +2074,7 @@ class IntervalMapOverlaps {
> // Already overlapping.
> return;
>
> - for (;;) {
> + while (true) {
> // Make a.end > b.start.
> posA.advanceTo(posB.start());
> if (!posA.valid() || !Traits::stopLess(posB.stop(), posA.start()))
>
> Modified: llvm/trunk/include/llvm/ADT/IntrusiveRefCntPtr.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/IntrusiveRefCntPtr.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/IntrusiveRefCntPtr.h (original)
> +++ llvm/trunk/include/llvm/ADT/IntrusiveRefCntPtr.h Thu May 18 16:27:11 2017
> @@ -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,9 +73,10 @@ template <class Derived> class RefCounte
>
> public:
> RefCountedBase() = default;
> - RefCountedBase(const RefCountedBase &) : RefCount(0) {}
> + RefCountedBase(const RefCountedBase &) {}
>
> void Retain() const { ++RefCount; }
> +
> void Release() const {
> assert(RefCount > 0 && "Reference count is already zero.");
> if (--RefCount == 0)
> @@ -136,7 +137,7 @@ template <typename T> class IntrusiveRef
> T *Obj = nullptr;
>
> public:
> - typedef T element_type;
> + using element_type = T;
>
> explicit IntrusiveRefCntPtr() = default;
> IntrusiveRefCntPtr(T *obj) : Obj(obj) { retain(); }
> @@ -153,13 +154,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; }
> @@ -183,6 +184,7 @@ private:
> if (Obj)
> IntrusiveRefCntPtrInfo<T>::retain(Obj);
> }
> +
> void release() {
> if (Obj)
> IntrusiveRefCntPtrInfo<T>::release(Obj);
> @@ -248,14 +250,16 @@ bool operator!=(const IntrusiveRefCntPtr
> template <typename From> struct simplify_type;
>
> template <class T> struct simplify_type<IntrusiveRefCntPtr<T>> {
> - typedef T *SimpleType;
> + using SimpleType = T *;
> +
> static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T> &Val) {
> return Val.get();
> }
> };
>
> template <class T> struct simplify_type<const IntrusiveRefCntPtr<T>> {
> - typedef /*const*/ T *SimpleType;
> + using SimpleType = /*const*/ T *;
> +
> static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T> &Val) {
> return Val.get();
> }
>
> Modified: llvm/trunk/include/llvm/ADT/MapVector.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/MapVector.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/MapVector.h (original)
> +++ llvm/trunk/include/llvm/ADT/MapVector.h Thu May 18 16:27:11 2017
> @@ -19,6 +19,12 @@
>
> #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 {
> @@ -27,20 +33,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 = llvm::DenseMap<KeyT, unsigned>,
> - typename VectorType = std::vector<std::pair<KeyT, ValueT> > >
> + typename MapType = DenseMap<KeyT, unsigned>,
> + typename VectorType = std::vector<std::pair<KeyT, ValueT>>>
> class MapVector {
> - typedef typename VectorType::value_type value_type;
> - typedef typename VectorType::size_type size_type;
> + using value_type = typename VectorType::value_type;
> + using size_type = typename VectorType::size_type;
>
> MapType Map;
> VectorType Vector;
>
> public:
> - 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;
> + 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;
>
> /// Clear the MapVector and return the underlying vector.
> VectorType takeVector() {
> @@ -220,4 +226,4 @@ struct SmallMapVector
>
> } // end namespace llvm
>
> -#endif
> +#endif // LLVM_ADT_MAPVECTOR_H
>
> Modified: llvm/trunk/include/llvm/ADT/Optional.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/Optional.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/Optional.h (original)
> +++ llvm/trunk/include/llvm/ADT/Optional.h Thu May 18 16:27:11 2017
> @@ -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,6 +19,8 @@
> #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>
> @@ -28,15 +30,18 @@ namespace llvm {
> template<typename T>
> class Optional {
> AlignedCharArrayUnion<T> storage;
> - bool hasVal;
> + bool hasVal = false;
> +
> public:
> - typedef T value_type;
> + using value_type = T;
> +
> + Optional(NoneType) {}
> + explicit Optional() {}
>
> - 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);
> @@ -45,12 +50,18 @@ 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);
> @@ -60,6 +71,7 @@ public:
> }
> return *this;
> }
> +
> Optional &operator=(Optional &&O) {
> if (!O)
> reset();
> @@ -112,10 +124,6 @@ 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(); }
> @@ -144,8 +152,7 @@ public:
> #endif
> };
>
> -template <typename T> struct isPodLike;
> -template <typename T> struct isPodLike<Optional<T> > {
> +template <typename T> struct isPodLike<Optional<T>> {
> // An Optional<T> is pod-like if T is.
> static const bool value = isPodLike<T>::value;
> };
> @@ -284,6 +291,6 @@ template <typename T> bool operator>=(co
> return !(X < Y);
> }
>
> -} // end llvm namespace
> +} // end namespace llvm
>
> -#endif
> +#endif // LLVM_ADT_OPTIONAL_H
>
> Modified: llvm/trunk/include/llvm/ADT/PackedVector.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/PackedVector.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/PackedVector.h (original)
> +++ llvm/trunk/include/llvm/ADT/PackedVector.h Thu May 18 16:27:11 2017
> @@ -76,8 +76,8 @@ template <typename T, unsigned BitNum, t
> class PackedVector : public PackedVectorBase<T, BitNum, BitVectorTy,
> std::numeric_limits<T>::is_signed> {
> BitVectorTy Bits;
> - typedef PackedVectorBase<T, BitNum, BitVectorTy,
> - std::numeric_limits<T>::is_signed> base;
> + using base = PackedVectorBase<T, BitNum, BitVectorTy,
> + std::numeric_limits<T>::is_signed>;
>
> 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(); }
>
>
> Modified: llvm/trunk/include/llvm/ADT/PointerEmbeddedInt.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/PointerEmbeddedInt.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/PointerEmbeddedInt.h (original)
> +++ llvm/trunk/include/llvm/ADT/PointerEmbeddedInt.h Thu May 18 16:27:11 2017
> @@ -13,7 +13,10 @@
> #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 {
>
> @@ -29,7 +32,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;
> + uintptr_t Value = 0;
>
> // Note: This '<' is correct; using '<=' would result in some shifts
> // overflowing their storage types.
> @@ -54,15 +57,12 @@ class PointerEmbeddedInt {
> explicit PointerEmbeddedInt(uintptr_t Value, RawValueTag) : Value(Value) {}
>
> public:
> - PointerEmbeddedInt() : Value(0) {}
> + PointerEmbeddedInt() = default;
>
> - PointerEmbeddedInt(IntT I) {
> - *this = I;
> - }
> + PointerEmbeddedInt(IntT I) { *this = I; }
>
> PointerEmbeddedInt &operator=(IntT I) {
> - assert((std::is_signed<IntT>::value ? llvm::isInt<Bits>(I)
> - : llvm::isUInt<Bits>(I)) &&
> + assert((std::is_signed<IntT>::value ? isInt<Bits>(I) : isUInt<Bits>(I)) &&
> "Integer has bits outside those preserved!");
> Value = static_cast<uintptr_t>(I) << Shift;
> return *this;
> @@ -81,15 +81,17 @@ public:
> // types.
> template <typename IntT, int Bits>
> class PointerLikeTypeTraits<PointerEmbeddedInt<IntT, Bits>> {
> - typedef PointerEmbeddedInt<IntT, Bits> T;
> + using T = PointerEmbeddedInt<IntT, Bits>;
>
> 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());
> }
> @@ -101,17 +103,19 @@ public:
> // itself can be a key.
> template <typename IntT, int Bits>
> struct DenseMapInfo<PointerEmbeddedInt<IntT, Bits>> {
> - typedef PointerEmbeddedInt<IntT, Bits> T;
> -
> - typedef DenseMapInfo<IntT> IntInfo;
> + using T = PointerEmbeddedInt<IntT, Bits>;
> + using IntInfo = DenseMapInfo<IntT>;
>
> 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; }
> };
> -}
>
> -#endif
> +} // end namespace llvm
> +
> +#endif // LLVM_ADT_POINTEREMBEDDEDINT_H
>
> Modified: llvm/trunk/include/llvm/ADT/PointerIntPair.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/PointerIntPair.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/PointerIntPair.h (original)
> +++ llvm/trunk/include/llvm/ADT/PointerIntPair.h Thu May 18 16:27:11 2017
> @@ -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 I
> typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
> typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
> class PointerIntPair {
> - intptr_t Value;
> + intptr_t Value = 0;
>
> public:
> - PointerIntPair() : Value(0) {}
> + PointerIntPair() = default;
> +
> 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,6 +88,7 @@ public:
> }
>
> void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
> +
> void setFromOpaqueValue(void *Val) {
> Value = reinterpret_cast<intptr_t>(Val);
> }
> @@ -108,14 +109,18 @@ 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;
> }
> @@ -180,21 +185,25 @@ struct isPodLike<PointerIntPair<PointerT
> // Provide specialization of DenseMapInfo for PointerIntPair.
> template <typename PointerTy, unsigned IntBits, typename IntType>
> struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {
> - typedef PointerIntPair<PointerTy, IntBits, IntType> Ty;
> + using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
> +
> 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; }
> };
>
> @@ -208,16 +217,20 @@ 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
> +
> +#endif // LLVM_ADT_POINTERINTPAIR_H
>
> Modified: llvm/trunk/include/llvm/ADT/PointerSumType.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/PointerSumType.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/PointerSumType.h (original)
> +++ llvm/trunk/include/llvm/ADT/PointerSumType.h Thu May 18 16:27:11 2017
> @@ -11,8 +11,10 @@
> #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 {
>
> @@ -24,16 +26,15 @@ template <uintptr_t N, typename PointerA
> typename TraitsArgT = PointerLikeTypeTraits<PointerArgT>>
> struct PointerSumTypeMember {
> enum { Tag = N };
> - typedef PointerArgT PointerT;
> - typedef TraitsArgT TraitsT;
> + using PointerT = PointerArgT;
> + using TraitsT = TraitsArgT;
> };
>
> 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.
> ///
> @@ -60,12 +61,12 @@ 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;
> + uintptr_t Value = 0;
>
> - typedef detail::PointerSumTypeHelper<TagT, MemberTs...> HelperT;
> + using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
>
> public:
> - PointerSumType() : Value(0) {}
> + PointerSumType() = default;
>
> /// A typed constructor for a specific tagged member of the sum type.
> template <TagT N>
> @@ -128,14 +129,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.
> - typedef decltype(LookupOverload<N>(
> - static_cast<PointerSumTypeHelper *>(nullptr))) MemberT;
> + using MemberT = decltype(
> + LookupOverload<N>(static_cast<PointerSumTypeHelper *>(nullptr)));
>
> /// The Nth member's pointer type.
> - typedef typename MemberT::PointerT PointerT;
> + using PointerT = typename MemberT::PointerT;
>
> /// The Nth member's traits type.
> - typedef typename MemberT::TraitsT TraitsT;
> + using TraitsT = typename MemberT::TraitsT;
> };
>
> // Next we need to compute the number of bits available for the discriminant
> @@ -171,35 +172,37 @@ 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...>> {
> - typedef PointerSumType<TagT, MemberTs...> SumType;
> + using SumType = PointerSumType<TagT, MemberTs...>;
>
> - typedef detail::PointerSumTypeHelper<TagT, MemberTs...> HelperT;
> + using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
> enum { SomeTag = HelperT::MinTag };
> - typedef typename HelperT::template Lookup<HelperT::MinTag>::PointerT
> - SomePointerT;
> - typedef DenseMapInfo<SomePointerT> SomePointerInfo;
> + using SomePointerT =
> + typename HelperT::template Lookup<HelperT::MinTag>::PointerT;
> + using SomePointerInfo = DenseMapInfo<SomePointerT>;
>
> 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
> +#endif // LLVM_ADT_POINTERSUMTYPE_H
>
> Modified: llvm/trunk/include/llvm/ADT/PointerUnion.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/PointerUnion.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/PointerUnion.h (original)
> +++ llvm/trunk/include/llvm/ADT/PointerUnion.h Thu May 18 16:27:11 2017
> @@ -19,13 +19,13 @@
> #include "llvm/ADT/PointerIntPair.h"
> #include "llvm/Support/PointerLikeTypeTraits.h"
> #include <cassert>
> -#include <cstdint>
> #include <cstddef>
> +#include <cstdint>
>
> namespace llvm {
>
> template <typename T> struct PointerUnionTypeSelectorReturn {
> - typedef T Return;
> + using Return = T;
> };
>
> /// Get a type based on whether two types are the same or not.
> @@ -39,19 +39,19 @@ template <typename T> struct PointerUnio
> /// 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 {
> - typedef typename PointerUnionTypeSelectorReturn<RET_NE>::Return Return;
> + using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
> };
>
> template <typename T, typename RET_EQ, typename RET_NE>
> struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
> - typedef typename PointerUnionTypeSelectorReturn<RET_EQ>::Return Return;
> + using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
> };
>
> template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
> struct PointerUnionTypeSelectorReturn<
> PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
> - typedef
> - typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return Return;
> + using Return =
> + typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::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:
> - typedef PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>
> - ValTy;
> + using ValTy =
> + PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>;
>
> private:
> ValTy Val;
> @@ -121,10 +121,10 @@ public:
>
> /// Test if the Union currently holds the type matching T.
> template <typename T> int is() const {
> - typedef typename ::llvm::PointerUnionTypeSelector<
> - PT1, T, IsPT1, ::llvm::PointerUnionTypeSelector<
> - PT2, T, IsPT2, UNION_DOESNT_CONTAIN_TYPE<T>>>::Return
> - Ty;
> + using Ty = typename ::llvm::PointerUnionTypeSelector<
> + PT1, T, IsPT1,
> + ::llvm::PointerUnionTypeSelector<PT2, T, IsPT2,
> + UNION_DOESNT_CONTAIN_TYPE<T>>>::Return;
> int TyNo = Ty::Num;
> return static_cast<int>(Val.getInt()) == TyNo;
> }
> @@ -228,19 +228,22 @@ public:
> /// for usage.
> template <typename PT1, typename PT2, typename PT3> class PointerUnion3 {
> public:
> - typedef PointerUnion<PT1, PT2> InnerUnion;
> - typedef PointerUnion<InnerUnion, PT3> ValTy;
> + using InnerUnion = PointerUnion<PT1, PT2>;
> + using ValTy = PointerUnion<InnerUnion, PT3>;
>
> 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>();
> }
> @@ -248,14 +251,15 @@ 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; }
> @@ -268,10 +272,9 @@ 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.
> - typedef typename ::llvm::PointerUnionTypeSelector<
> + using Ty = typename ::llvm::PointerUnionTypeSelector<
> PT1, T, IsInnerUnion,
> - ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return
> - Ty;
> + ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
> return Ty(Val).template is<T>();
> }
>
> @@ -281,10 +284,9 @@ public:
> template <typename T> T get() const {
> assert(is<T>() && "Invalid accessor called");
> // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.
> - typedef typename ::llvm::PointerUnionTypeSelector<
> + using Ty = typename ::llvm::PointerUnionTypeSelector<
> PT1, T, IsInnerUnion,
> - ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return
> - Ty;
> + ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
> return Ty(Val).template get<T>();
> }
>
> @@ -350,16 +352,15 @@ public:
> 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;
> + using InnerUnion1 = PointerUnion<PT1, PT2>;
> + using InnerUnion2 = PointerUnion<PT3, PT4>;
> + using ValTy = PointerUnion<InnerUnion1, InnerUnion2>;
>
> private:
> ValTy Val;
>
> public:
> PointerUnion4() = default;
> -
> PointerUnion4(PT1 V) { Val = InnerUnion1(V); }
> PointerUnion4(PT2 V) { Val = InnerUnion1(V); }
> PointerUnion4(PT3 V) { Val = InnerUnion2(V); }
> @@ -373,9 +374,10 @@ 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.
> - typedef typename ::llvm::PointerUnionTypeSelector<
> - PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector<
> - PT2, T, InnerUnion1, InnerUnion2>>::Return Ty;
> + using Ty = typename ::llvm::PointerUnionTypeSelector<
> + PT1, T, InnerUnion1,
> + ::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,
> + InnerUnion2>>::Return;
> return Val.template is<Ty>() && Val.template get<Ty>().template is<T>();
> }
>
> @@ -385,9 +387,10 @@ public:
> template <typename T> T get() const {
> assert(is<T>() && "Invalid accessor called");
> // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.
> - typedef typename ::llvm::PointerUnionTypeSelector<
> - PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector<
> - PT2, T, InnerUnion1, InnerUnion2>>::Return Ty;
> + using Ty = typename ::llvm::PointerUnionTypeSelector<
> + PT1, T, InnerUnion1,
> + ::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,
> + InnerUnion2>>::Return;
> return Val.template get<Ty>().template get<T>();
> }
>
> @@ -455,18 +458,21 @@ public:
>
> // Teach DenseMap how to use PointerUnions as keys.
> template <typename T, typename U> struct DenseMapInfo<PointerUnion<T, U>> {
> - typedef PointerUnion<T, U> Pair;
> - typedef DenseMapInfo<T> FirstInfo;
> - typedef DenseMapInfo<U> SecondInfo;
> + using Pair = PointerUnion<T, U>;
> + using FirstInfo = DenseMapInfo<T>;
> + using SecondInfo = DenseMapInfo<U>;
>
> 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>(),
>
> Modified: llvm/trunk/include/llvm/ADT/simple_ilist.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/simple_ilist.h?rev=303383&r1=303382&r2=303383&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/simple_ilist.h (original)
> +++ llvm/trunk/include/llvm/ADT/simple_ilist.h Thu May 18 16:27:11 2017
> @@ -13,9 +13,14 @@
> #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 {
>
> @@ -77,23 +82,23 @@ class simple_ilist
> typename ilist_detail::compute_node_options<T, Options...>::type> {
> static_assert(ilist_detail::check_options<Options...>::value,
> "Unrecognized node option!");
> - typedef
> - typename ilist_detail::compute_node_options<T, Options...>::type OptionsT;
> - typedef typename OptionsT::list_base_type list_base_type;
> + using OptionsT =
> + typename ilist_detail::compute_node_options<T, Options...>::type;
> + using list_base_type = typename OptionsT::list_base_type;
> ilist_sentinel<OptionsT> Sentinel;
>
> public:
> - 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;
> + 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;
>
> simple_ilist() = default;
> ~simple_ilist() = default;
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list