mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-26 12:36:07 +00:00
Code Issues Projects Releases Wiki Activity

[llvm][NFC] Use c++17 style variable type traits

Browse Source 
This was done as a test for D137302 and it makes sense to push these changes

Reviewed By: dblaikie

Differential Revision: https://reviews.llvm.org/D137493
This commit is contained in:
Nathan James 2022-11-08 12:22:50 +00:00
parent 94738a5ac3
commit 1834a310d0
No known key found for this signature in database
GPG Key ID: CC007AFCDA90AA5F
43 changed files with 185 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
llvm/include/llvm/Support/YAMLTraits.h
View File

@ -2019,9 +2019,8 @@ template <typename T> struct StdMapStringCustomMappingTraitsImpl {
namespace llvm { \
namespace yaml { \
static_assert( \
!std::is_fundamental<TYPE>::value && \
!std::is_same<TYPE, std::string>::value && \
!std::is_same<TYPE, llvm::StringRef>::value, \
!std::is_fundamental_v<TYPE> && !std::is_same_v<TYPE, std::string> && \
!std::is_same_v<TYPE, llvm::StringRef>, \
"only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"); \
template <> struct SequenceElementTraits<TYPE> { \
static const bool flow = FLOW; \

3
llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp
View File

@ -237,8 +237,7 @@ struct LocIndex {
}
template<typename IntT> static LocIndex fromRawInteger(IntT ID) {
static_assert(std::is_unsigned<IntT>::value &&
sizeof(ID) == sizeof(uint64_t),
static_assert(std::is_unsigned_v<IntT> && sizeof(ID) == sizeof(uint64_t),
"Cannot convert raw integer to LocIndex");
return {static_cast<u32_location_t>(ID >> 32),
static_cast<u32_index_t>(ID)};

2
llvm/lib/DebugInfo/CodeView/EnumTables.cpp
View File

@ -14,7 +14,7 @@ using namespace llvm;
using namespace codeview;
#define CV_ENUM_CLASS_ENT(enum_class, enum) \
{ #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
{ #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
#define CV_ENUM_ENT(ns, enum) \
{ #enum, ns::enum }

2
llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp
View File

@ -27,7 +27,7 @@ static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
};
#define ENUM_ENTRY(enum_class, enum) \
{ #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
{ #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
static const EnumEntry<uint16_t> ClassOptionNames[] = {
ENUM_ENTRY(ClassOptions, Packed),

2
llvm/lib/DebugInfo/PDB/Native/EnumTables.cpp
View File

@ -14,7 +14,7 @@ using namespace llvm;
using namespace llvm::pdb;
#define PDB_ENUM_CLASS_ENT(enum_class, enum) \
{ #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
{ #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
#define PDB_ENUM_ENT(ns, enum) \
{ #enum, ns::enum }

2
llvm/lib/Object/DXContainer.cpp
View File

@ -32,7 +32,7 @@ static Error readStruct(StringRef Buffer, const char *Src, T &Struct) {
template <typename T>
static Error readInteger(StringRef Buffer, const char *Src, T &Val) {
static_assert(std::is_integral<T>::value,
static_assert(std::is_integral_v<T>,
"Cannot call readInteger on non-integral type.");
// Don't read before the beginning or past the end of the file
if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())

2
llvm/lib/ProfileData/InstrProf.cpp
View File

@ -1351,7 +1351,7 @@ uint64_t Header::formatVersion() const {
Expected<Header> Header::readFromBuffer(const unsigned char *Buffer) {
using namespace support;
static_assert(std::is_standard_layout<Header>::value,
static_assert(std::is_standard_layout_v<Header>,
"The header should be standard layout type since we use offset "
"of fields to read.");
Header H;

3
llvm/lib/Support/ItaniumManglingCanonicalizer.cpp
View File

@ -27,8 +27,7 @@ struct FoldingSetNodeIDBuilder {
ID.AddString(llvm::StringRef(Str.begin(), Str.size()));
}
template <typename T>
std::enable_if_t<std::is_integral<T>::value || std::is_enum<T>::value>
operator()(T V) {
std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>> operator()(T V) {
ID.AddInteger((unsigned long long)V);
}
void operator()(itanium_demangle::NodeArray A) {

4
llvm/lib/Support/NativeFormatting.cpp
View File

@ -55,7 +55,7 @@ static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) {
template <typename T>
static void write_unsigned_impl(raw_ostream &S, T N, size_t MinDigits,
IntegerStyle Style, bool IsNegative) {
static_assert(std::is_unsigned<T>::value, "Value is not unsigned!");
static_assert(std::is_unsigned_v<T>, "Value is not unsigned!");
char NumberBuffer[128];
std::memset(NumberBuffer, '0', sizeof(NumberBuffer));
@ -92,7 +92,7 @@ static void write_unsigned(raw_ostream &S, T N, size_t MinDigits,
template <typename T>
static void write_signed(raw_ostream &S, T N, size_t MinDigits,
IntegerStyle Style) {
static_assert(std::is_signed<T>::value, "Value is not signed!");
static_assert(std::is_signed_v<T>, "Value is not signed!");
using UnsignedT = std::make_unsigned_t<T>;

4
llvm/lib/Target/X86/X86ISelLowering.cpp
View File

@ -3574,8 +3574,8 @@ template <typename T>
static bool hasCalleePopSRet(const SmallVectorImpl<T> &Args,
const X86Subtarget &Subtarget) {
// Not C++20 (yet), so no concepts available.
static_assert(std::is_same<T, ISD::OutputArg>::value ||
std::is_same<T, ISD::InputArg>::value,
static_assert(std::is_same_v<T, ISD::OutputArg> ||
std::is_same_v<T, ISD::InputArg>,
"requires ISD::OutputArg or ISD::InputArg");
// Only 32-bit pops the sret. It's a 64-bit world these days, so early-out

8
llvm/lib/Transforms/Scalar/NaryReassociate.cpp
View File

@ -576,13 +576,13 @@ NaryReassociatePass::findClosestMatchingDominator(const SCEV *CandidateExpr,
}
template <typename MaxMinT> static SCEVTypes convertToSCEVype(MaxMinT &MM) {
if (std::is_same<smax_pred_ty, typename MaxMinT::PredType>::value)
if (std::is_same_v<smax_pred_ty, typename MaxMinT::PredType>)
return scSMaxExpr;
else if (std::is_same<umax_pred_ty, typename MaxMinT::PredType>::value)
else if (std::is_same_v<umax_pred_ty, typename MaxMinT::PredType>)
return scUMaxExpr;
else if (std::is_same<smin_pred_ty, typename MaxMinT::PredType>::value)
else if (std::is_same_v<smin_pred_ty, typename MaxMinT::PredType>)
return scSMinExpr;
else if (std::is_same<umin_pred_ty, typename MaxMinT::PredType>::value)
else if (std::is_same_v<umin_pred_ty, typename MaxMinT::PredType>)
return scUMinExpr;
llvm_unreachable("Can't convert MinMax pattern to SCEV type");

5
llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
View File

@ -7217,12 +7217,11 @@ namespace {
/// value, otherwise.
struct ValueSelect {
template <typename U>
static std::enable_if_t<std::is_same<Value *, U>::value, Value *>
get(Value *V) {
static std::enable_if_t<std::is_same_v<Value *, U>, Value *> get(Value *V) {
return V;
}
template <typename U>
static std::enable_if_t<!std::is_same<Value *, U>::value, U> get(Value *) {
static std::enable_if_t<!std::is_same_v<Value *, U>, U> get(Value *) {
return U();
}
};

8
llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp
View File

@ -256,8 +256,8 @@ public:
"This test makes sure NewArchiveMemberList is used by MembersData since "
"the following asserts test invariants required for MembersData.");
static_assert(
!std::is_copy_constructible<
decltype(NewArchiveMemberList::Members)::value_type>::value,
!std::is_copy_constructible_v<
decltype(NewArchiveMemberList::Members)::value_type>,
"MembersData::MembersPerArchitecture has a dependency on "
"MembersData::FileBuffers so it should not be able to "
"be copied on its own without FileBuffers. Unfortunately, "
@ -265,8 +265,8 @@ public:
"of a non-copyable type is itself non-copyable so we have to test the "
"actual type of the stored data (ie, value_type).");
static_assert(
!std::is_copy_assignable<
decltype(NewArchiveMemberList::Members)::value_type>::value,
!std::is_copy_assignable_v<
decltype(NewArchiveMemberList::Members)::value_type>,
"MembersData::MembersPerArchitecture has a dependency on "
"MembersData::FileBuffers so it should not be able to "
"be copied on its own without FileBuffers. Unfortunately, "

41
llvm/unittests/ADT/ArrayRefTest.cpp
View File

@ -16,34 +16,27 @@ using namespace llvm;
// Check that the ArrayRef-of-pointer converting constructor only allows adding
// cv qualifiers (not removing them, or otherwise changing the type)
static_assert(
std::is_convertible<ArrayRef<int *>, ArrayRef<const int *>>::value,
"Adding const");
static_assert(
std::is_convertible<ArrayRef<int *>, ArrayRef<volatile int *>>::value,
"Adding volatile");
static_assert(!std::is_convertible<ArrayRef<int *>, ArrayRef<float *>>::value,
static_assert(std::is_convertible_v<ArrayRef<int *>, ArrayRef<const int *>>,
"Adding const");
static_assert(std::is_convertible_v<ArrayRef<int *>, ArrayRef<volatile int *>>,
"Adding volatile");
static_assert(!std::is_convertible_v<ArrayRef<int *>, ArrayRef<float *>>,
"Changing pointer of one type to a pointer of another");
static_assert(
!std::is_convertible<ArrayRef<const int *>, ArrayRef<int *>>::value,
"Removing const");
static_assert(
!std::is_convertible<ArrayRef<volatile int *>, ArrayRef<int *>>::value,
"Removing volatile");
static_assert(!std::is_convertible_v<ArrayRef<const int *>, ArrayRef<int *>>,
"Removing const");
static_assert(!std::is_convertible_v<ArrayRef<volatile int *>, ArrayRef<int *>>,
"Removing volatile");
// Check that we can't accidentally assign a temporary location to an ArrayRef.
// (Unfortunately we can't make use of the same thing with constructors.)
static_assert(!std::is_assignable_v<ArrayRef<int *> &, int *>,
"Assigning from single prvalue element");
static_assert(!std::is_assignable_v<ArrayRef<int *> &, int *&&>,
"Assigning from single xvalue element");
static_assert(std::is_assignable_v<ArrayRef<int *> &, int *&>,
"Assigning from single lvalue element");
static_assert(
!std::is_assignable<ArrayRef<int *>&, int *>::value,
"Assigning from single prvalue element");
static_assert(
!std::is_assignable<ArrayRef<int *>&, int * &&>::value,
"Assigning from single xvalue element");
static_assert(
std::is_assignable<ArrayRef<int *>&, int * &>::value,
"Assigning from single lvalue element");
static_assert(
!std::is_assignable<ArrayRef<int *>&, std::initializer_list<int *>>::value,
!std::is_assignable_v<ArrayRef<int *> &, std::initializer_list<int *>>,
"Assigning from an initializer list");
namespace {
@ -261,7 +254,7 @@ TEST(ArrayRefTest, makeArrayRefFromStdArray) {
}
}
static_assert(std::is_trivially_copyable<ArrayRef<int>>::value,
static_assert(std::is_trivially_copyable_v<ArrayRef<int>>,
"trivially copyable");
TEST(ArrayRefTest, makeMutableArrayRef) {

2
llvm/unittests/ADT/DenseMapTest.cpp
View File

@ -682,7 +682,7 @@ struct B : public A {
namespace llvm {
template <typename T>
struct DenseMapInfo<T, std::enable_if_t<std::is_base_of<A, T>::value>> {
struct DenseMapInfo<T, std::enable_if_t<std::is_base_of_v<A, T>>> {
static inline T getEmptyKey() { return {static_cast<int>(~0)}; }
static inline T getTombstoneKey() { return {static_cast<int>(~0U - 1)}; }
static unsigned getHashValue(const T &Val) { return Val.value; }

14
llvm/unittests/ADT/DenseSetTest.cpp
View File

@ -14,12 +14,14 @@ using namespace llvm;
namespace {
static_assert(std::is_const<std::remove_pointer<
DenseSet<int>::const_iterator::pointer>::type>::value,
"Iterator pointer type should be const");
static_assert(std::is_const<std::remove_reference<
DenseSet<int>::const_iterator::reference>::type>::value,
"Iterator reference type should be const");
static_assert(
std::is_const_v<
std::remove_pointer_t<DenseSet<int>::const_iterator::pointer>>,
"Iterator pointer type should be const");
static_assert(
std::is_const_v<
std::remove_reference_t<DenseSet<int>::const_iterator::reference>>,
"Iterator reference type should be const");
// Test hashing with a set of only two entries.
TEST(DenseSetTest, DoubleEntrySetTest) {

10
llvm/unittests/ADT/EnumeratedArrayTest.cpp
View File

@ -106,15 +106,15 @@ enum class Colors { Red, Blue, Green, Last = Green };
using Array = EnumeratedArray<float, Colors, Colors::Last, size_t>;
static_assert(std::is_same<Array::value_type, float>::value,
static_assert(std::is_same_v<Array::value_type, float>,
"Incorrect value_type type");
static_assert(std::is_same<Array::reference, float &>::value,
static_assert(std::is_same_v<Array::reference, float &>,
"Incorrect reference type!");
static_assert(std::is_same<Array::pointer, float *>::value,
static_assert(std::is_same_v<Array::pointer, float *>,
"Incorrect pointer type!");
static_assert(std::is_same<Array::const_reference, const float &>::value,
static_assert(std::is_same_v<Array::const_reference, const float &>,
"Incorrect const_reference type!");
static_assert(std::is_same<Array::const_pointer, const float *>::value,
static_assert(std::is_same_v<Array::const_pointer, const float *>,
"Incorrect const_pointer type!");
} // namespace

14
llvm/unittests/ADT/IListIteratorTest.cpp
View File

@ -158,16 +158,14 @@ TEST(IListIteratorTest, ReverseConstructor) {
EXPECT_EQ(CL.rbegin(), const_reverse_iterator(CL.end()));
// Confirm lack of implicit conversions.
static_assert(!std::is_convertible<iterator, reverse_iterator>::value,
static_assert(!std::is_convertible_v<iterator, reverse_iterator>,
"unexpected implicit conversion");
static_assert(!std::is_convertible<reverse_iterator, iterator>::value,
static_assert(!std::is_convertible_v<reverse_iterator, iterator>,
"unexpected implicit conversion");
static_assert(!std::is_convertible_v<const_iterator, const_reverse_iterator>,
"unexpected implicit conversion");
static_assert(!std::is_convertible_v<const_reverse_iterator, const_iterator>,
"unexpected implicit conversion");
static_assert(
!std::is_convertible<const_iterator, const_reverse_iterator>::value,
"unexpected implicit conversion");
static_assert(
!std::is_convertible<const_reverse_iterator, const_iterator>::value,
"unexpected implicit conversion");
}
} // end namespace

37
llvm/unittests/ADT/IListNodeTest.cpp
View File

@ -22,47 +22,46 @@ struct TagB {};
TEST(IListNodeTest, Options) {
static_assert(
std::is_same<compute_node_options<Node>::type,
compute_node_options<Node, ilist_tag<void>>::type>::value,
std::is_same_v<compute_node_options<Node>::type,
compute_node_options<Node, ilist_tag<void>>::type>,
"default tag is void");
static_assert(
!std::is_same<compute_node_options<Node, ilist_tag<TagA>>::type,
compute_node_options<Node, ilist_tag<void>>::type>::value,
!std::is_same_v<compute_node_options<Node, ilist_tag<TagA>>::type,
compute_node_options<Node, ilist_tag<void>>::type>,
"default tag is void, different from TagA");
static_assert(
!std::is_same<compute_node_options<Node, ilist_tag<TagA>>::type,
compute_node_options<Node, ilist_tag<TagB>>::type>::value,
!std::is_same_v<compute_node_options<Node, ilist_tag<TagA>>::type,
compute_node_options<Node, ilist_tag<TagB>>::type>,
"TagA is not TagB");
static_assert(
std::is_same<
std::is_same_v<
compute_node_options<Node, ilist_sentinel_tracking<false>>::type,
compute_node_options<Node, ilist_sentinel_tracking<false>,
ilist_tag<void>>::type>::value,
ilist_tag<void>>::type>,
"default tag is void, even with sentinel tracking off");
static_assert(
std::is_same<
std::is_same_v<
compute_node_options<Node, ilist_sentinel_tracking<false>>::type,
compute_node_options<Node, ilist_tag<void>,
ilist_sentinel_tracking<false>>::type>::value,
ilist_sentinel_tracking<false>>::type>,
"order shouldn't matter");
static_assert(
std::is_same<
std::is_same_v<
compute_node_options<Node, ilist_sentinel_tracking<true>>::type,
compute_node_options<Node, ilist_sentinel_tracking<true>,
ilist_tag<void>>::type>::value,
ilist_tag<void>>::type>,
"default tag is void, even with sentinel tracking on");
static_assert(
std::is_same<
std::is_same_v<
compute_node_options<Node, ilist_sentinel_tracking<true>>::type,
compute_node_options<Node, ilist_tag<void>,
ilist_sentinel_tracking<true>>::type>::value,
ilist_sentinel_tracking<true>>::type>,
"order shouldn't matter");
static_assert(
std::is_same<
compute_node_options<Node, ilist_sentinel_tracking<true>,
ilist_tag<TagA>>::type,
compute_node_options<Node, ilist_tag<TagA>,
ilist_sentinel_tracking<true>>::type>::value,
std::is_same_v<compute_node_options<Node, ilist_sentinel_tracking<true>,
ilist_tag<TagA>>::type,
compute_node_options<Node, ilist_tag<TagA>,
ilist_sentinel_tracking<true>>::type>,
"order shouldn't matter with real tags");
}

2
llvm/unittests/ADT/ImmutableListTest.cpp
View File

@ -266,7 +266,7 @@ TEST_F(ImmutableListTest, LongListOrderingTest) {
ASSERT_EQ(6, i);
}
static_assert(std::is_trivially_copyable<ImmutableList<Wrapper<long>>>::value,
static_assert(std::is_trivially_copyable_v<ImmutableList<Wrapper<long>>>,
"trivially copyable");
} // namespace

28
llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
View File

@ -101,24 +101,22 @@ TEST(IntrusiveRefCntPtr, UsesTraitsToRetainAndRelease) {
struct X : RefCountedBase<X> {};
struct Y : X {};
struct Z : RefCountedBase<Z> {};
static_assert(!std::is_convertible<IntrusiveRefCntPtr<X> &&,
IntrusiveRefCntPtr<Y>>::value,
"X&& -> Y should be rejected with SFINAE");
static_assert(!std::is_convertible<const IntrusiveRefCntPtr<X> &,
IntrusiveRefCntPtr<Y>>::value,
static_assert(
!std::is_convertible_v<IntrusiveRefCntPtr<X> &&, IntrusiveRefCntPtr<Y>>,
"X&& -> Y should be rejected with SFINAE");
static_assert(!std::is_convertible_v<const IntrusiveRefCntPtr<X> &,
IntrusiveRefCntPtr<Y>>,
"const X& -> Y should be rejected with SFINAE");
static_assert(!std::is_convertible_v<std::unique_ptr<X>, IntrusiveRefCntPtr<Y>>,
"X -> Y should be rejected with SFINAE");
static_assert(
!std::is_convertible<std::unique_ptr<X>, IntrusiveRefCntPtr<Y>>::value,
"X -> Y should be rejected with SFINAE");
static_assert(!std::is_convertible<IntrusiveRefCntPtr<X> &&,
IntrusiveRefCntPtr<Z>>::value,
"X&& -> Z should be rejected with SFINAE");
static_assert(!std::is_convertible<const IntrusiveRefCntPtr<X> &,
IntrusiveRefCntPtr<Z>>::value,
!std::is_convertible_v<IntrusiveRefCntPtr<X> &&, IntrusiveRefCntPtr<Z>>,
"X&& -> Z should be rejected with SFINAE");
static_assert(!std::is_convertible_v<const IntrusiveRefCntPtr<X> &,
IntrusiveRefCntPtr<Z>>,
"const X& -> Z should be rejected with SFINAE");
static_assert(
!std::is_convertible<std::unique_ptr<X>, IntrusiveRefCntPtr<Z>>::value,
"X -> Z should be rejected with SFINAE");
static_assert(!std::is_convertible_v<std::unique_ptr<X>, IntrusiveRefCntPtr<Z>>,
"X -> Z should be rejected with SFINAE");
TEST(IntrusiveRefCntPtr, InteropsWithConvertible) {
// Check converting constructors and operator=.

34
llvm/unittests/ADT/IteratorTest.cpp
View File

@ -27,14 +27,11 @@ struct AdaptedIter : iterator_adaptor_base<AdaptedIter, WeirdIter> {};
// Test that iterator_adaptor_base forwards typedefs, if value_type is
// unchanged.
static_assert(std::is_same<typename AdaptedIter::value_type, Shadow<0>>::value,
"");
static_assert(
std::is_same<typename AdaptedIter::difference_type, Shadow<1>>::value, "");
static_assert(std::is_same<typename AdaptedIter::pointer, Shadow<2>>::value,
"");
static_assert(std::is_same<typename AdaptedIter::reference, Shadow<3>>::value,
static_assert(std::is_same_v<typename AdaptedIter::value_type, Shadow<0>>, "");
static_assert(std::is_same_v<typename AdaptedIter::difference_type, Shadow<1>>,
"");
static_assert(std::is_same_v<typename AdaptedIter::pointer, Shadow<2>>, "");
static_assert(std::is_same_v<typename AdaptedIter::reference, Shadow<3>>, "");
// Ensure that pointe{e,r}_iterator adaptors correctly forward the category of
// the underlying iterator.
@ -87,13 +84,12 @@ static_assert(&IntIterator::operator* == &IntIterator::operator*, "");
static_assert(&IntIterator::operator-> == &IntIterator::operator->, "");
static_assert(&IntIterator::operator[] == &IntIterator::operator[], "");
template <class T,
std::enable_if_t<std::is_assignable<T, int>::value, bool> = false>
template <class T, std::enable_if_t<std::is_assignable_v<T, int>, bool> = false>
constexpr bool canAssignFromInt(T &&) {
return true;
}
template <class T,
std::enable_if_t<!std::is_assignable<T, int>::value, bool> = false>
std::enable_if_t<!std::is_assignable_v<T, int>, bool> = false>
constexpr bool canAssignFromInt(T &&) {
return false;
}
@ -143,15 +139,17 @@ TEST(IteratorAdaptorTest, Dereference) {
}
// pointeE_iterator
static_assert(IsAdaptedIterCategorySame<pointee_iterator_defaulted,
RandomAccessIter>::value, "");
static_assert(IsAdaptedIterCategorySame<pointee_iterator_defaulted,
BidiIter>::value, "");
static_assert(
IsAdaptedIterCategorySame_v<pointee_iterator_defaulted, RandomAccessIter>,
"");
static_assert(IsAdaptedIterCategorySame_v<pointee_iterator_defaulted, BidiIter>,
"");
// pointeR_iterator
static_assert(IsAdaptedIterCategorySame<pointer_iterator_defaulted,
RandomAccessIter>::value, "");
static_assert(IsAdaptedIterCategorySame<pointer_iterator_defaulted,
BidiIter>::value, "");
static_assert(
IsAdaptedIterCategorySame_v<pointer_iterator_defaulted, RandomAccessIter>,
"");
static_assert(IsAdaptedIterCategorySame_v<pointer_iterator_defaulted, BidiIter>,
"");
TEST(PointeeIteratorTest, Basic) {
int arr[4] = {1, 2, 3, 4};

17
llvm/unittests/ADT/OptionalTest.cpp
View File

@ -18,10 +18,10 @@
using namespace llvm;
static_assert(std::is_trivially_copyable<Optional<int>>::value,
static_assert(std::is_trivially_copyable_v<Optional<int>>,
"trivially copyable");
static_assert(std::is_trivially_copyable<Optional<std::array<int, 3>>>::value,
static_assert(std::is_trivially_copyable_v<Optional<std::array<int, 3>>>,
"trivially copyable");
void OptionalWorksInConstexpr() {
@ -70,9 +70,8 @@ unsigned NonDefaultConstructible::CopyConstructions = 0;
unsigned NonDefaultConstructible::Destructions = 0;
unsigned NonDefaultConstructible::CopyAssignments = 0;
static_assert(
!std::is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
"not trivially copyable");
static_assert(!std::is_trivially_copyable_v<Optional<NonDefaultConstructible>>,
"not trivially copyable");
TEST(OptionalTest, NonDefaultConstructibleTest) {
Optional<NonDefaultConstructible> O;
@ -241,7 +240,7 @@ struct MultiArgConstructor {
};
unsigned MultiArgConstructor::Destructions = 0;
static_assert(!std::is_trivially_copyable<Optional<MultiArgConstructor>>::value,
static_assert(!std::is_trivially_copyable_v<Optional<MultiArgConstructor>>,
"not trivially copyable");
TEST(OptionalTest, Emplace) {
@ -323,7 +322,7 @@ unsigned MoveOnly::MoveConstructions = 0;
unsigned MoveOnly::Destructions = 0;
unsigned MoveOnly::MoveAssignments = 0;
static_assert(!std::is_trivially_copyable<Optional<MoveOnly>>::value,
static_assert(!std::is_trivially_copyable_v<Optional<MoveOnly>>,
"not trivially copyable");
TEST(OptionalTest, MoveOnlyNull) {
@ -427,7 +426,7 @@ private:
unsigned Immovable::Constructions = 0;
unsigned Immovable::Destructions = 0;
static_assert(!std::is_trivially_copyable<Optional<Immovable>>::value,
static_assert(!std::is_trivially_copyable_v<Optional<Immovable>>,
"not trivially copyable");
TEST(OptionalTest, ImmovableEmplace) {
@ -565,7 +564,7 @@ TEST(OptionalTest, DeletedMoveConstructor) {
NonTMove1 = std::move(NonTMove2);
static_assert(
std::is_trivially_copyable<NoTMoveOptT>::value,
std::is_trivially_copyable_v<NoTMoveOptT>,
"Expect Optional<NoTMove> to still use the trivial specialization "
"of OptionalStorage despite the deleted move constructor / assignment.");
}

9
llvm/unittests/ADT/PointerIntPairTest.cpp
View File

@ -62,7 +62,7 @@ TEST(PointerIntPairTest, GetSet) {
EXPECT_EQ(&s, Pair2.getPointer());
EXPECT_EQ(E::Case3, Pair2.getInt());
static_assert(std::is_trivially_copyable<PointerIntPair<S *, 2, E>>::value,
static_assert(std::is_trivially_copyable_v<PointerIntPair<S *, 2, E>>,
"trivially copyable");
}
@ -100,10 +100,9 @@ TEST(PointerIntPairTest, ManyUnusedBits) {
EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1,
(int)PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);
static_assert(
std::is_trivially_copyable<
PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits>>::value,
"trivially copyable");
static_assert(std::is_trivially_copyable_v<
PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits>>,
"trivially copyable");
}
} // end anonymous namespace

4
llvm/unittests/ADT/PointerUnionTest.cpp
View File

@ -279,13 +279,13 @@ TEST_F(PointerUnionTest, NewCastInfra) {
EXPECT_EQ(dyn_cast<long long *>(constd4), nullptr);
auto *result1 = cast<double *>(constd4);
static_assert(std::is_same<double *, decltype(result1)>::value,
static_assert(std::is_same_v<double *, decltype(result1)>,
"type mismatch for cast with PointerUnion");
PointerUnion<int *, const double *> constd2(&d);
auto *result2 = cast<const double *>(constd2);
EXPECT_EQ(result2, &d);
static_assert(std::is_same<const double *, decltype(result2)>::value,
static_assert(std::is_same_v<const double *, decltype(result2)>,
"type mismatch for cast with PointerUnion");
}

2
llvm/unittests/ADT/SmallVectorTest.cpp
View File

@ -1229,7 +1229,7 @@ protected:
VectorT V;
template <class T> static bool isValueType() {
return std::is_same<T, typename VectorT::value_type>::value;
return std::is_same_v<T, typename VectorT::value_type>;
}
void SetUp() override {

33
llvm/unittests/ADT/StringRefTest.cpp
View File

@ -34,24 +34,18 @@ std::ostream &operator<<(std::ostream &OS,
// Check that we can't accidentally assign a temporary std::string to a
// StringRef. (Unfortunately we can't make use of the same thing with
// constructors.)
static_assert(
!std::is_assignable<StringRef&, std::string>::value,
"Assigning from prvalue std::string");
static_assert(
!std::is_assignable<StringRef&, std::string &&>::value,
"Assigning from xvalue std::string");
static_assert(
std::is_assignable<StringRef&, std::string &>::value,
"Assigning from lvalue std::string");
static_assert(
std::is_assignable<StringRef&, const char *>::value,
"Assigning from prvalue C string");
static_assert(
std::is_assignable<StringRef&, const char * &&>::value,
"Assigning from xvalue C string");
static_assert(
std::is_assignable<StringRef&, const char * &>::value,
"Assigning from lvalue C string");
static_assert(!std::is_assignable_v<StringRef &, std::string>,
"Assigning from prvalue std::string");
static_assert(!std::is_assignable_v<StringRef &, std::string &&>,
"Assigning from xvalue std::string");
static_assert(std::is_assignable_v<StringRef &, std::string &>,
"Assigning from lvalue std::string");
static_assert(std::is_assignable_v<StringRef &, const char *>,
"Assigning from prvalue C string");
static_assert(std::is_assignable_v<StringRef &, const char *&&>,
"Assigning from xvalue C string");
static_assert(std::is_assignable_v<StringRef &, const char *&>,
"Assigning from lvalue C string");
namespace {
TEST(StringRefTest, Construction) {
@ -1144,7 +1138,6 @@ TEST(StringRefTest, LFCRLineEnding) {
EXPECT_EQ(StringRef("\n\r"), Cases[2].detectEOL());
}
static_assert(std::is_trivially_copyable<StringRef>::value,
"trivially copyable");
static_assert(std::is_trivially_copyable_v<StringRef>, "trivially copyable");
} // end anonymous namespace

6
llvm/unittests/ADT/TypeTraitsTest.cpp
View File

@ -19,11 +19,11 @@ namespace {
/// Check a callable type of the form `bool(const int &)`.
template <typename CallableT> struct CheckFunctionTraits {
static_assert(
std::is_same<typename function_traits<CallableT>::result_t, bool>::value,
std::is_same_v<typename function_traits<CallableT>::result_t, bool>,
"expected result_t to be `bool`");
static_assert(
std::is_same<typename function_traits<CallableT>::template arg_t<0>,
const int &>::value,
std::is_same_v<typename function_traits<CallableT>::template arg_t<0>,
const int &>,
"expected arg_t<0> to be `const int &`");
static_assert(function_traits<CallableT>::num_args == 1,
"expected num_args to be 1");

2
llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
View File

@ -91,7 +91,7 @@ TEST_F(BlockFrequencyInfoTest, Basic) {
EXPECT_EQ(BFI.getBlockFreq(BB3).getFrequency(), BB3Freq);
}
static_assert(std::is_trivially_copyable<bfi_detail::BlockMass>::value,
static_assert(std::is_trivially_copyable_v<bfi_detail::BlockMass>,
"trivially copyable");
} // end anonymous namespace

10
llvm/unittests/Analysis/CallGraphTest.cpp
View File

@ -23,11 +23,11 @@ template <typename Ty> void canSpecializeGraphTraitsIterators(Ty *G) {
auto X = ++I;
// Should be able to iterate over all nodes of the graph.
static_assert(std::is_same<decltype(*I), NodeRef>::value,
static_assert(std::is_same_v<decltype(*I), NodeRef>,
"Node type does not match");
static_assert(std::is_same<decltype(*X), NodeRef>::value,
static_assert(std::is_same_v<decltype(*X), NodeRef>,
"Node type does not match");
static_assert(std::is_same<decltype(*E), NodeRef>::value,
static_assert(std::is_same_v<decltype(*E), NodeRef>,
"Node type does not match");
NodeRef N = GraphTraits<Ty *>::getEntryNode(G);
@ -36,9 +36,9 @@ template <typename Ty> void canSpecializeGraphTraitsIterators(Ty *G) {
auto F = GraphTraits<NodeRef>::child_end(N);
// Should be able to iterate over immediate successors of a node.
static_assert(std::is_same<decltype(*S), NodeRef>::value,
static_assert(std::is_same_v<decltype(*S), NodeRef>,
"Node type does not match");
static_assert(std::is_same<decltype(*F), NodeRef>::value,
static_assert(std::is_same_v<decltype(*F), NodeRef>,
"Node type does not match");
}

2
llvm/unittests/Bitstream/BitstreamReaderTest.cpp
View File

@ -161,7 +161,7 @@ TEST(BitstreamReaderTest, shortRead) {
}
}
static_assert(std::is_trivially_copyable<BitCodeAbbrevOp>::value,
static_assert(std::is_trivially_copyable_v<BitCodeAbbrevOp>,
"trivially copyable");
} // end anonymous namespace

14
llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp
View File

@ -181,16 +181,14 @@ TEST(MachineInstrBundleIteratorTest, ReverseConstructor) {
EXPECT_EQ(crbegin(), const_reverse_iterator(cend()));
// Confirm lack of implicit conversions.
static_assert(!std::is_convertible<iterator, reverse_iterator>::value,
static_assert(!std::is_convertible_v<iterator, reverse_iterator>,
"unexpected implicit conversion");
static_assert(!std::is_convertible<reverse_iterator, iterator>::value,
static_assert(!std::is_convertible_v<reverse_iterator, iterator>,
"unexpected implicit conversion");
static_assert(!std::is_convertible_v<const_iterator, const_reverse_iterator>,
"unexpected implicit conversion");
static_assert(!std::is_convertible_v<const_reverse_iterator, const_iterator>,
"unexpected implicit conversion");
static_assert(
!std::is_convertible<const_iterator, const_reverse_iterator>::value,
"unexpected implicit conversion");
static_assert(
!std::is_convertible<const_reverse_iterator, const_iterator>::value,
"unexpected implicit conversion");
}
} // end namespace

3
llvm/unittests/CodeGen/MachineInstrTest.cpp
View File

@ -472,7 +472,6 @@ TEST(MachineInstrBuilder, BuildMI) {
EXPECT_THAT(BuildMI(MBB, MIMD, MCID), HasMIMetadata(MIMD));
}
static_assert(std::is_trivially_copyable<MCOperand>::value,
"trivially copyable");
static_assert(std::is_trivially_copyable_v<MCOperand>, "trivially copyable");
} // end namespace

11
llvm/unittests/CodeGen/TypeTraitsTest.cpp
View File

@ -17,13 +17,12 @@
using namespace llvm;
#if __has_feature(is_trivially_copyable) || (defined(__GNUC__) && __GNUC__ >= 5)
static_assert(std::is_trivially_copyable<PressureChange>::value,
static_assert(std::is_trivially_copyable_v<PressureChange>,
"trivially copyable");
static_assert(std::is_trivially_copyable<SDep>::value, "trivially copyable");
static_assert(std::is_trivially_copyable<SDValue>::value, "trivially copyable");
static_assert(std::is_trivially_copyable<SlotIndex>::value,
"trivially copyable");
static_assert(std::is_trivially_copyable<IdentifyingPassPtr>::value,
static_assert(std::is_trivially_copyable_v<SDep>, "trivially copyable");
static_assert(std::is_trivially_copyable_v<SDValue>, "trivially copyable");
static_assert(std::is_trivially_copyable_v<SlotIndex>, "trivially copyable");
static_assert(std::is_trivially_copyable_v<IdentifyingPassPtr>,
"trivially copyable");
#endif

2
llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp
View File

@ -67,7 +67,7 @@ static void spsSerializationRoundTrip(const T &Value) {
template <typename T> static void testFixedIntegralTypeSerialization() {
spsSerializationRoundTrip<T, T>(0);
spsSerializationRoundTrip<T, T>(static_cast<T>(1));
if (std::is_signed<T>::value) {
if (std::is_signed_v<T>) {
spsSerializationRoundTrip<T, T>(static_cast<T>(-1));
spsSerializationRoundTrip<T, T>(std::numeric_limits<T>::min());
}

9
llvm/unittests/IR/CFGBuilder.cpp
View File

@ -267,11 +267,10 @@ TEST(CFGBuilder, Rebuild) {
EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("d")->getTerminator()));
}
static_assert(std::is_trivially_copyable<succ_iterator>::value,
static_assert(std::is_trivially_copyable_v<succ_iterator>,
"trivially copyable");
static_assert(std::is_trivially_copyable<const_succ_iterator>::value,
static_assert(std::is_trivially_copyable_v<const_succ_iterator>,
"trivially copyable");
static_assert(std::is_trivially_copyable<succ_range>::value,
"trivially copyable");
static_assert(std::is_trivially_copyable<const_succ_range>::value,
static_assert(std::is_trivially_copyable_v<succ_range>, "trivially copyable");
static_assert(std::is_trivially_copyable_v<const_succ_range>,
"trivially copyable");

2
llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp
View File

@ -23,7 +23,7 @@ const auto CFGDelete = CFGBuilder::ActionKind::Delete;
using DomUpdate = DominatorTree::UpdateType;
static_assert(
std::is_same<DomUpdate, PostDominatorTree::UpdateType>::value,
std::is_same_v<DomUpdate, PostDominatorTree::UpdateType>,
"Trees differing only in IsPostDom should have the same update types");
using DomSNCA = DomTreeBuilder::SemiNCAInfo<DomTreeBuilder::BBDomTree>;
using PostDomSNCA = DomTreeBuilder::SemiNCAInfo<DomTreeBuilder::BBPostDomTree>;

4
llvm/unittests/IR/PassBuilderCallbacksTest.cpp
View File

@ -401,8 +401,8 @@ struct MockPassInstrumentationCallbacks {
template <typename IRUnitT>
using ExtraMockPassHandle =
std::conditional_t<std::is_same<IRUnitT, Loop>::value,
MockPassHandle<LoopNest>, MockPassHandle<IRUnitT>>;
std::conditional_t<std::is_same_v<IRUnitT, Loop>, MockPassHandle<LoopNest>,
MockPassHandle<IRUnitT>>;
template <typename PassManagerT> class PassBuilderCallbacksTest;

3
llvm/unittests/IR/ValueMapTest.cpp
View File

@ -115,8 +115,7 @@ TYPED_TEST(ValueMapTest, OperationsWork) {
template<typename ExpectedType, typename VarType>
void CompileAssertHasType(VarType) {
static_assert(std::is_same<ExpectedType, VarType>::value,
"Not the same type");
static_assert(std::is_same_v<ExpectedType, VarType>, "Not the same type");
}
TYPED_TEST(ValueMapTest, Iteration) {

10
llvm/unittests/Support/Casting.cpp
View File

@ -122,15 +122,15 @@ template <> struct CastInfo<T4, T3> {
using namespace llvm;
// Test the peculiar behavior of Use in simplify_type.
static_assert(std::is_same<simplify_type<Use>::SimpleType, Value *>::value,
static_assert(std::is_same_v<simplify_type<Use>::SimpleType, Value *>,
"Use doesn't simplify correctly!");
static_assert(std::is_same<simplify_type<Use *>::SimpleType, Value *>::value,
static_assert(std::is_same_v<simplify_type<Use *>::SimpleType, Value *>,
"Use doesn't simplify correctly!");
// Test that a regular class behaves as expected.
static_assert(std::is_same<simplify_type<foo>::SimpleType, int>::value,
static_assert(std::is_same_v<simplify_type<foo>::SimpleType, int>,
"Unexpected simplify_type result!");
static_assert(std::is_same<simplify_type<foo *>::SimpleType, foo *>::value,
static_assert(std::is_same_v<simplify_type<foo *>::SimpleType, foo *>,
"Unexpected simplify_type result!");
namespace {
@ -177,7 +177,7 @@ TEST(CastingTest, cast) {
std::unique_ptr<const bar> BP(B2);
auto FP = cast<foo>(std::move(BP));
static_assert(std::is_same<std::unique_ptr<const foo>, decltype(FP)>::value,
static_assert(std::is_same_v<std::unique_ptr<const foo>, decltype(FP)>,
"Incorrect deduced return type!");
EXPECT_NE(FP.get(), null_foo);
FP.release();

17
llvm/unittests/Support/ErrorOrTest.cpp
View File

@ -113,27 +113,26 @@ TEST(ErrorOr, ImplicitConversionNoAmbiguity) {
// ErrorOr<int*> x(nullptr);
// ErrorOr<std::unique_ptr<int>> y = x; // invalid conversion
static_assert(
!std::is_convertible<const ErrorOr<int *> &,
ErrorOr<std::unique_ptr<int>>>::value,
!std::is_convertible_v<const ErrorOr<int *> &,
ErrorOr<std::unique_ptr<int>>>,
"do not invoke explicit ctors in implicit conversion from lvalue");
// ErrorOr<std::unique_ptr<int>> y = ErrorOr<int*>(nullptr); // invalid
// // conversion
static_assert(
!std::is_convertible<ErrorOr<int *> &&,
ErrorOr<std::unique_ptr<int>>>::value,
!std::is_convertible_v<ErrorOr<int *> &&, ErrorOr<std::unique_ptr<int>>>,
"do not invoke explicit ctors in implicit conversion from rvalue");
// ErrorOr<int*> x(nullptr);
// ErrorOr<std::unique_ptr<int>> y;
// y = x; // invalid conversion
static_assert(!std::is_assignable<ErrorOr<std::unique_ptr<int>>&,
const ErrorOr<int *> &>::value,
static_assert(!std::is_assignable_v<ErrorOr<std::unique_ptr<int>> &,
const ErrorOr<int *> &>,
"do not invoke explicit ctors in assignment");
// ErrorOr<std::unique_ptr<int>> x;
// x = ErrorOr<int*>(nullptr); // invalid conversion
static_assert(!std::is_assignable<ErrorOr<std::unique_ptr<int>>&,
ErrorOr<int *> &&>::value,
"do not invoke explicit ctors in assignment");
static_assert(
!std::is_assignable_v<ErrorOr<std::unique_ptr<int>> &, ErrorOr<int *> &&>,
"do not invoke explicit ctors in assignment");
} // end anon namespace

2
llvm/unittests/Support/ScaledNumberTest.cpp
View File

@ -562,7 +562,7 @@ TEST(ScaledNumberHelpersTest, toIntBug) {
EXPECT_EQ(1u, (n * n).toInt<uint32_t>());
}
static_assert(std::is_trivially_copyable<ScaledNumber<uint32_t>>::value,
static_assert(std::is_trivially_copyable_v<ScaledNumber<uint32_t>>,
"trivially copyable");
} // end namespace

10
llvm/unittests/Support/ThreadLocalTest.cpp
View File

@ -25,9 +25,8 @@ struct S {
TEST_F(ThreadLocalTest, Basics) {
ThreadLocal<const S> x;
static_assert(
std::is_const<std::remove_pointer<decltype(x.get())>::type>::value,
"ThreadLocal::get didn't return a pointer to const object");
static_assert(std::is_const_v<std::remove_pointer_t<decltype(x.get())>>,
"ThreadLocal::get didn't return a pointer to const object");
EXPECT_EQ(nullptr, x.get());
@ -40,9 +39,8 @@ TEST_F(ThreadLocalTest, Basics) {
ThreadLocal<S> y;
static_assert(
!std::is_const<std::remove_pointer<decltype(y.get())>::type>::value,
"ThreadLocal::get returned a pointer to const object");
static_assert(!std::is_const_v<std::remove_pointer_t<decltype(y.get())>>,
"ThreadLocal::get returned a pointer to const object");
EXPECT_EQ(nullptr, y.get());