diff --git a/llvm/include/llvm/Support/YAMLTraits.h b/llvm/include/llvm/Support/YAMLTraits.h index cb0588a7203bd8..8ade9b15642b55 100644 --- a/llvm/include/llvm/Support/YAMLTraits.h +++ b/llvm/include/llvm/Support/YAMLTraits.h @@ -2019,8 +2019,9 @@ template struct StdMapStringCustomMappingTraitsImpl { namespace llvm { \ namespace yaml { \ static_assert( \ - !std::is_fundamental_v && !std::is_same_v && \ - !std::is_same_v, \ + !std::is_fundamental::value && \ + !std::is_same::value && \ + !std::is_same::value, \ "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"); \ template <> struct SequenceElementTraits { \ static const bool flow = FLOW; \ diff --git a/llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp b/llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp index 7706b3f1f2d862..32e07eb77efe2b 100644 --- a/llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp +++ b/llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp @@ -237,7 +237,8 @@ struct LocIndex { } template static LocIndex fromRawInteger(IntT ID) { - static_assert(std::is_unsigned_v && sizeof(ID) == sizeof(uint64_t), + static_assert(std::is_unsigned::value && + sizeof(ID) == sizeof(uint64_t), "Cannot convert raw integer to LocIndex"); return {static_cast(ID >> 32), static_cast(ID)}; diff --git a/llvm/lib/DebugInfo/CodeView/EnumTables.cpp b/llvm/lib/DebugInfo/CodeView/EnumTables.cpp index 1774b35921bdbb..adf4ae519dae80 100644 --- a/llvm/lib/DebugInfo/CodeView/EnumTables.cpp +++ b/llvm/lib/DebugInfo/CodeView/EnumTables.cpp @@ -14,7 +14,7 @@ using namespace llvm; using namespace codeview; #define CV_ENUM_CLASS_ENT(enum_class, enum) \ - { #enum, std::underlying_type_t(enum_class::enum) } + { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) } #define CV_ENUM_ENT(ns, enum) \ { #enum, ns::enum } diff --git a/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp b/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp index 96ec7f656bb6a5..6507132cb3ecbc 100644 --- a/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp +++ b/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp @@ -27,7 +27,7 @@ static const EnumEntry LeafTypeNames[] = { }; #define ENUM_ENTRY(enum_class, enum) \ - { #enum, std::underlying_type_t(enum_class::enum) } + { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) } static const EnumEntry ClassOptionNames[] = { ENUM_ENTRY(ClassOptions, Packed), diff --git a/llvm/lib/DebugInfo/PDB/Native/EnumTables.cpp b/llvm/lib/DebugInfo/PDB/Native/EnumTables.cpp index ff88e2b4e79a9c..32bad9cea7ce11 100644 --- a/llvm/lib/DebugInfo/PDB/Native/EnumTables.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/EnumTables.cpp @@ -14,7 +14,7 @@ using namespace llvm; using namespace llvm::pdb; #define PDB_ENUM_CLASS_ENT(enum_class, enum) \ - { #enum, std::underlying_type_t(enum_class::enum) } + { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) } #define PDB_ENUM_ENT(ns, enum) \ { #enum, ns::enum } diff --git a/llvm/lib/Object/DXContainer.cpp b/llvm/lib/Object/DXContainer.cpp index 35a58ed82e8ccc..a83cf70b31741c 100644 --- a/llvm/lib/Object/DXContainer.cpp +++ b/llvm/lib/Object/DXContainer.cpp @@ -32,7 +32,7 @@ static Error readStruct(StringRef Buffer, const char *Src, T &Struct) { template static Error readInteger(StringRef Buffer, const char *Src, T &Val) { - static_assert(std::is_integral_v, + static_assert(std::is_integral::value, "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()) diff --git a/llvm/lib/ProfileData/InstrProf.cpp b/llvm/lib/ProfileData/InstrProf.cpp index fec25a84423f74..eab1eab82ac2fc 100644 --- a/llvm/lib/ProfileData/InstrProf.cpp +++ b/llvm/lib/ProfileData/InstrProf.cpp @@ -1351,7 +1351,7 @@ uint64_t Header::formatVersion() const { Expected
Header::readFromBuffer(const unsigned char *Buffer) { using namespace support; - static_assert(std::is_standard_layout_v
, + static_assert(std::is_standard_layout
::value, "The header should be standard layout type since we use offset " "of fields to read."); Header H; diff --git a/llvm/lib/Support/ItaniumManglingCanonicalizer.cpp b/llvm/lib/Support/ItaniumManglingCanonicalizer.cpp index d95d84f7837e9d..52d5de93ff7d75 100644 --- a/llvm/lib/Support/ItaniumManglingCanonicalizer.cpp +++ b/llvm/lib/Support/ItaniumManglingCanonicalizer.cpp @@ -27,7 +27,8 @@ struct FoldingSetNodeIDBuilder { ID.AddString(llvm::StringRef(Str.begin(), Str.size())); } template - std::enable_if_t || std::is_enum_v> operator()(T V) { + std::enable_if_t::value || std::is_enum::value> + operator()(T V) { ID.AddInteger((unsigned long long)V); } void operator()(itanium_demangle::NodeArray A) { diff --git a/llvm/lib/Support/NativeFormatting.cpp b/llvm/lib/Support/NativeFormatting.cpp index ee2d8853dd6299..cceaad4e8b9e66 100644 --- a/llvm/lib/Support/NativeFormatting.cpp +++ b/llvm/lib/Support/NativeFormatting.cpp @@ -55,7 +55,7 @@ static void writeWithCommas(raw_ostream &S, ArrayRef Buffer) { template static void write_unsigned_impl(raw_ostream &S, T N, size_t MinDigits, IntegerStyle Style, bool IsNegative) { - static_assert(std::is_unsigned_v, "Value is not unsigned!"); + static_assert(std::is_unsigned::value, "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 static void write_signed(raw_ostream &S, T N, size_t MinDigits, IntegerStyle Style) { - static_assert(std::is_signed_v, "Value is not signed!"); + static_assert(std::is_signed::value, "Value is not signed!"); using UnsignedT = std::make_unsigned_t; diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp b/llvm/lib/Target/X86/X86ISelLowering.cpp index 2884fee57a1a24..e32b0cb3d45e43 100644 --- a/llvm/lib/Target/X86/X86ISelLowering.cpp +++ b/llvm/lib/Target/X86/X86ISelLowering.cpp @@ -3574,8 +3574,8 @@ template static bool hasCalleePopSRet(const SmallVectorImpl &Args, const X86Subtarget &Subtarget) { // Not C++20 (yet), so no concepts available. - static_assert(std::is_same_v || - std::is_same_v, + static_assert(std::is_same::value || + std::is_same::value, "requires ISD::OutputArg or ISD::InputArg"); // Only 32-bit pops the sret. It's a 64-bit world these days, so early-out diff --git a/llvm/lib/Transforms/Scalar/NaryReassociate.cpp b/llvm/lib/Transforms/Scalar/NaryReassociate.cpp index ab6c28c8037958..6dca30d9876e23 100644 --- a/llvm/lib/Transforms/Scalar/NaryReassociate.cpp +++ b/llvm/lib/Transforms/Scalar/NaryReassociate.cpp @@ -576,13 +576,13 @@ NaryReassociatePass::findClosestMatchingDominator(const SCEV *CandidateExpr, } template static SCEVTypes convertToSCEVype(MaxMinT &MM) { - if (std::is_same_v) + if (std::is_same::value) return scSMaxExpr; - else if (std::is_same_v) + else if (std::is_same::value) return scUMaxExpr; - else if (std::is_same_v) + else if (std::is_same::value) return scSMinExpr; - else if (std::is_same_v) + else if (std::is_same::value) return scUMinExpr; llvm_unreachable("Can't convert MinMax pattern to SCEV type"); diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp index eb22d9f19e0497..ecfaabee59f46e 100644 --- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp +++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp @@ -7219,11 +7219,12 @@ namespace { /// value, otherwise. struct ValueSelect { template - static std::enable_if_t, Value *> get(Value *V) { + static std::enable_if_t::value, Value *> + get(Value *V) { return V; } template - static std::enable_if_t, U> get(Value *) { + static std::enable_if_t::value, U> get(Value *) { return U(); } }; diff --git a/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp b/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp index d3760a9ac30f96..5fec8475f5eefc 100644 --- a/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp +++ b/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp @@ -256,8 +256,8 @@ class NewArchiveMemberList { "This test makes sure NewArchiveMemberList is used by MembersData since " "the following asserts test invariants required for MembersData."); static_assert( - !std::is_copy_constructible_v< - decltype(NewArchiveMemberList::Members)::value_type>, + !std::is_copy_constructible< + decltype(NewArchiveMemberList::Members)::value_type>::value, "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 @@ class NewArchiveMemberList { "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_v< - decltype(NewArchiveMemberList::Members)::value_type>, + !std::is_copy_assignable< + decltype(NewArchiveMemberList::Members)::value_type>::value, "MembersData::MembersPerArchitecture has a dependency on " "MembersData::FileBuffers so it should not be able to " "be copied on its own without FileBuffers. Unfortunately, " diff --git a/llvm/unittests/ADT/ArrayRefTest.cpp b/llvm/unittests/ADT/ArrayRefTest.cpp index 9fcddc88e69f15..eded12d37bb7da 100644 --- a/llvm/unittests/ADT/ArrayRefTest.cpp +++ b/llvm/unittests/ADT/ArrayRefTest.cpp @@ -16,27 +16,34 @@ 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_v, ArrayRef>, - "Adding const"); -static_assert(std::is_convertible_v, ArrayRef>, - "Adding volatile"); -static_assert(!std::is_convertible_v, ArrayRef>, +static_assert( + std::is_convertible, ArrayRef>::value, + "Adding const"); +static_assert( + std::is_convertible, ArrayRef>::value, + "Adding volatile"); +static_assert(!std::is_convertible, ArrayRef>::value, "Changing pointer of one type to a pointer of another"); -static_assert(!std::is_convertible_v, ArrayRef>, - "Removing const"); -static_assert(!std::is_convertible_v, ArrayRef>, - "Removing volatile"); +static_assert( + !std::is_convertible, ArrayRef>::value, + "Removing const"); +static_assert( + !std::is_convertible, ArrayRef>::value, + "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 &, int *>, - "Assigning from single prvalue element"); -static_assert(!std::is_assignable_v &, int *&&>, - "Assigning from single xvalue element"); -static_assert(std::is_assignable_v &, int *&>, - "Assigning from single lvalue element"); static_assert( - !std::is_assignable_v &, std::initializer_list>, + !std::is_assignable&, int *>::value, + "Assigning from single prvalue element"); +static_assert( + !std::is_assignable&, int * &&>::value, + "Assigning from single xvalue element"); +static_assert( + std::is_assignable&, int * &>::value, + "Assigning from single lvalue element"); +static_assert( + !std::is_assignable&, std::initializer_list>::value, "Assigning from an initializer list"); namespace { @@ -254,7 +261,7 @@ TEST(ArrayRefTest, makeArrayRefFromStdArray) { } } -static_assert(std::is_trivially_copyable_v>, +static_assert(std::is_trivially_copyable>::value, "trivially copyable"); TEST(ArrayRefTest, makeMutableArrayRef) { diff --git a/llvm/unittests/ADT/DenseMapTest.cpp b/llvm/unittests/ADT/DenseMapTest.cpp index 6893f439b46f4a..cb77ad887ba15d 100644 --- a/llvm/unittests/ADT/DenseMapTest.cpp +++ b/llvm/unittests/ADT/DenseMapTest.cpp @@ -682,7 +682,7 @@ struct B : public A { namespace llvm { template -struct DenseMapInfo>> { +struct DenseMapInfo::value>> { static inline T getEmptyKey() { return {static_cast(~0)}; } static inline T getTombstoneKey() { return {static_cast(~0U - 1)}; } static unsigned getHashValue(const T &Val) { return Val.value; } diff --git a/llvm/unittests/ADT/DenseSetTest.cpp b/llvm/unittests/ADT/DenseSetTest.cpp index f14542eafc251d..82ac1d8bff0f2c 100644 --- a/llvm/unittests/ADT/DenseSetTest.cpp +++ b/llvm/unittests/ADT/DenseSetTest.cpp @@ -14,14 +14,12 @@ using namespace llvm; namespace { -static_assert( - std::is_const_v< - std::remove_pointer_t::const_iterator::pointer>>, - "Iterator pointer type should be const"); -static_assert( - std::is_const_v< - std::remove_reference_t::const_iterator::reference>>, - "Iterator reference type should be const"); +static_assert(std::is_const::const_iterator::pointer>::type>::value, + "Iterator pointer type should be const"); +static_assert(std::is_const::const_iterator::reference>::type>::value, + "Iterator reference type should be const"); // Test hashing with a set of only two entries. TEST(DenseSetTest, DoubleEntrySetTest) { diff --git a/llvm/unittests/ADT/EnumeratedArrayTest.cpp b/llvm/unittests/ADT/EnumeratedArrayTest.cpp index a978ce4ab99b71..99754280471417 100644 --- a/llvm/unittests/ADT/EnumeratedArrayTest.cpp +++ b/llvm/unittests/ADT/EnumeratedArrayTest.cpp @@ -106,15 +106,15 @@ enum class Colors { Red, Blue, Green, Last = Green }; using Array = EnumeratedArray; -static_assert(std::is_same_v, +static_assert(std::is_same::value, "Incorrect value_type type"); -static_assert(std::is_same_v, +static_assert(std::is_same::value, "Incorrect reference type!"); -static_assert(std::is_same_v, +static_assert(std::is_same::value, "Incorrect pointer type!"); -static_assert(std::is_same_v, +static_assert(std::is_same::value, "Incorrect const_reference type!"); -static_assert(std::is_same_v, +static_assert(std::is_same::value, "Incorrect const_pointer type!"); } // namespace diff --git a/llvm/unittests/ADT/IListIteratorTest.cpp b/llvm/unittests/ADT/IListIteratorTest.cpp index bd638a8e22b229..559e32de077c5f 100644 --- a/llvm/unittests/ADT/IListIteratorTest.cpp +++ b/llvm/unittests/ADT/IListIteratorTest.cpp @@ -158,14 +158,16 @@ TEST(IListIteratorTest, ReverseConstructor) { EXPECT_EQ(CL.rbegin(), const_reverse_iterator(CL.end())); // Confirm lack of implicit conversions. - static_assert(!std::is_convertible_v, + static_assert(!std::is_convertible::value, "unexpected implicit conversion"); - static_assert(!std::is_convertible_v, - "unexpected implicit conversion"); - static_assert(!std::is_convertible_v, - "unexpected implicit conversion"); - static_assert(!std::is_convertible_v, + static_assert(!std::is_convertible::value, "unexpected implicit conversion"); + static_assert( + !std::is_convertible::value, + "unexpected implicit conversion"); + static_assert( + !std::is_convertible::value, + "unexpected implicit conversion"); } } // end namespace diff --git a/llvm/unittests/ADT/IListNodeTest.cpp b/llvm/unittests/ADT/IListNodeTest.cpp index 057eabb4e4ab7e..cf775eb5d0699f 100644 --- a/llvm/unittests/ADT/IListNodeTest.cpp +++ b/llvm/unittests/ADT/IListNodeTest.cpp @@ -22,46 +22,47 @@ struct TagB {}; TEST(IListNodeTest, Options) { static_assert( - std::is_same_v::type, - compute_node_options>::type>, + std::is_same::type, + compute_node_options>::type>::value, "default tag is void"); static_assert( - !std::is_same_v>::type, - compute_node_options>::type>, + !std::is_same>::type, + compute_node_options>::type>::value, "default tag is void, different from TagA"); static_assert( - !std::is_same_v>::type, - compute_node_options>::type>, + !std::is_same>::type, + compute_node_options>::type>::value, "TagA is not TagB"); static_assert( - std::is_same_v< + std::is_same< compute_node_options>::type, compute_node_options, - ilist_tag>::type>, + ilist_tag>::type>::value, "default tag is void, even with sentinel tracking off"); static_assert( - std::is_same_v< + std::is_same< compute_node_options>::type, compute_node_options, - ilist_sentinel_tracking>::type>, + ilist_sentinel_tracking>::type>::value, "order shouldn't matter"); static_assert( - std::is_same_v< + std::is_same< compute_node_options>::type, compute_node_options, - ilist_tag>::type>, + ilist_tag>::type>::value, "default tag is void, even with sentinel tracking on"); static_assert( - std::is_same_v< + std::is_same< compute_node_options>::type, compute_node_options, - ilist_sentinel_tracking>::type>, + ilist_sentinel_tracking>::type>::value, "order shouldn't matter"); static_assert( - std::is_same_v, - ilist_tag>::type, - compute_node_options, - ilist_sentinel_tracking>::type>, + std::is_same< + compute_node_options, + ilist_tag>::type, + compute_node_options, + ilist_sentinel_tracking>::type>::value, "order shouldn't matter with real tags"); } diff --git a/llvm/unittests/ADT/ImmutableListTest.cpp b/llvm/unittests/ADT/ImmutableListTest.cpp index 2da0ca65d1a4f7..28624c0d551d48 100644 --- a/llvm/unittests/ADT/ImmutableListTest.cpp +++ b/llvm/unittests/ADT/ImmutableListTest.cpp @@ -266,7 +266,7 @@ TEST_F(ImmutableListTest, LongListOrderingTest) { ASSERT_EQ(6, i); } -static_assert(std::is_trivially_copyable_v>>, +static_assert(std::is_trivially_copyable>>::value, "trivially copyable"); } // namespace diff --git a/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp b/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp index 45b8028aef2008..e4b649837f6f04 100644 --- a/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp +++ b/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp @@ -101,22 +101,24 @@ TEST(IntrusiveRefCntPtr, UsesTraitsToRetainAndRelease) { struct X : RefCountedBase {}; struct Y : X {}; struct Z : RefCountedBase {}; -static_assert( - !std::is_convertible_v &&, IntrusiveRefCntPtr>, - "X&& -> Y should be rejected with SFINAE"); -static_assert(!std::is_convertible_v &, - IntrusiveRefCntPtr>, +static_assert(!std::is_convertible &&, + IntrusiveRefCntPtr>::value, + "X&& -> Y should be rejected with SFINAE"); +static_assert(!std::is_convertible &, + IntrusiveRefCntPtr>::value, "const X& -> Y should be rejected with SFINAE"); -static_assert(!std::is_convertible_v, IntrusiveRefCntPtr>, - "X -> Y should be rejected with SFINAE"); static_assert( - !std::is_convertible_v &&, IntrusiveRefCntPtr>, - "X&& -> Z should be rejected with SFINAE"); -static_assert(!std::is_convertible_v &, - IntrusiveRefCntPtr>, + !std::is_convertible, IntrusiveRefCntPtr>::value, + "X -> Y should be rejected with SFINAE"); +static_assert(!std::is_convertible &&, + IntrusiveRefCntPtr>::value, + "X&& -> Z should be rejected with SFINAE"); +static_assert(!std::is_convertible &, + IntrusiveRefCntPtr>::value, "const X& -> Z should be rejected with SFINAE"); -static_assert(!std::is_convertible_v, IntrusiveRefCntPtr>, - "X -> Z should be rejected with SFINAE"); +static_assert( + !std::is_convertible, IntrusiveRefCntPtr>::value, + "X -> Z should be rejected with SFINAE"); TEST(IntrusiveRefCntPtr, InteropsWithConvertible) { // Check converting constructors and operator=. diff --git a/llvm/unittests/ADT/IteratorTest.cpp b/llvm/unittests/ADT/IteratorTest.cpp index dd487c1be03b22..7269bfc4b6fb0a 100644 --- a/llvm/unittests/ADT/IteratorTest.cpp +++ b/llvm/unittests/ADT/IteratorTest.cpp @@ -27,11 +27,14 @@ struct AdaptedIter : iterator_adaptor_base {}; // Test that iterator_adaptor_base forwards typedefs, if value_type is // unchanged. -static_assert(std::is_same_v>, ""); -static_assert(std::is_same_v>, +static_assert(std::is_same>::value, + ""); +static_assert( + std::is_same>::value, ""); +static_assert(std::is_same>::value, + ""); +static_assert(std::is_same>::value, ""); -static_assert(std::is_same_v>, ""); -static_assert(std::is_same_v>, ""); // Ensure that pointe{e,r}_iterator adaptors correctly forward the category of // the underlying iterator. @@ -84,12 +87,13 @@ static_assert(&IntIterator::operator* == &IntIterator::operator*, ""); static_assert(&IntIterator::operator-> == &IntIterator::operator->, ""); static_assert(&IntIterator::operator[] == &IntIterator::operator[], ""); -template , bool> = false> +template ::value, bool> = false> constexpr bool canAssignFromInt(T &&) { return true; } template , bool> = false> + std::enable_if_t::value, bool> = false> constexpr bool canAssignFromInt(T &&) { return false; } @@ -139,17 +143,15 @@ TEST(IteratorAdaptorTest, Dereference) { } // pointeE_iterator -static_assert( - IsAdaptedIterCategorySame_v, - ""); -static_assert(IsAdaptedIterCategorySame_v, - ""); +static_assert(IsAdaptedIterCategorySame::value, ""); +static_assert(IsAdaptedIterCategorySame::value, ""); // pointeR_iterator -static_assert( - IsAdaptedIterCategorySame_v, - ""); -static_assert(IsAdaptedIterCategorySame_v, - ""); +static_assert(IsAdaptedIterCategorySame::value, ""); +static_assert(IsAdaptedIterCategorySame::value, ""); TEST(PointeeIteratorTest, Basic) { int arr[4] = {1, 2, 3, 4}; diff --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp index 5f1f88d1073994..e615d56e2b625d 100644 --- a/llvm/unittests/ADT/OptionalTest.cpp +++ b/llvm/unittests/ADT/OptionalTest.cpp @@ -18,10 +18,10 @@ using namespace llvm; -static_assert(std::is_trivially_copyable_v>, +static_assert(std::is_trivially_copyable>::value, "trivially copyable"); -static_assert(std::is_trivially_copyable_v>>, +static_assert(std::is_trivially_copyable>>::value, "trivially copyable"); void OptionalWorksInConstexpr() { @@ -70,8 +70,9 @@ unsigned NonDefaultConstructible::CopyConstructions = 0; unsigned NonDefaultConstructible::Destructions = 0; unsigned NonDefaultConstructible::CopyAssignments = 0; -static_assert(!std::is_trivially_copyable_v>, - "not trivially copyable"); +static_assert( + !std::is_trivially_copyable>::value, + "not trivially copyable"); TEST(OptionalTest, NonDefaultConstructibleTest) { Optional O; @@ -240,7 +241,7 @@ struct MultiArgConstructor { }; unsigned MultiArgConstructor::Destructions = 0; -static_assert(!std::is_trivially_copyable_v>, +static_assert(!std::is_trivially_copyable>::value, "not trivially copyable"); TEST(OptionalTest, Emplace) { @@ -322,7 +323,7 @@ unsigned MoveOnly::MoveConstructions = 0; unsigned MoveOnly::Destructions = 0; unsigned MoveOnly::MoveAssignments = 0; -static_assert(!std::is_trivially_copyable_v>, +static_assert(!std::is_trivially_copyable>::value, "not trivially copyable"); TEST(OptionalTest, MoveOnlyNull) { @@ -426,7 +427,7 @@ struct Immovable { unsigned Immovable::Constructions = 0; unsigned Immovable::Destructions = 0; -static_assert(!std::is_trivially_copyable_v>, +static_assert(!std::is_trivially_copyable>::value, "not trivially copyable"); TEST(OptionalTest, ImmovableEmplace) { @@ -564,7 +565,7 @@ TEST(OptionalTest, DeletedMoveConstructor) { NonTMove1 = std::move(NonTMove2); static_assert( - std::is_trivially_copyable_v, + std::is_trivially_copyable::value, "Expect Optional to still use the trivial specialization " "of OptionalStorage despite the deleted move constructor / assignment."); } diff --git a/llvm/unittests/ADT/PointerIntPairTest.cpp b/llvm/unittests/ADT/PointerIntPairTest.cpp index 9e5e0ee1614bea..8a42e5b9f55716 100644 --- a/llvm/unittests/ADT/PointerIntPairTest.cpp +++ b/llvm/unittests/ADT/PointerIntPairTest.cpp @@ -62,7 +62,7 @@ TEST(PointerIntPairTest, GetSet) { EXPECT_EQ(&s, Pair2.getPointer()); EXPECT_EQ(E::Case3, Pair2.getInt()); - static_assert(std::is_trivially_copyable_v>, + static_assert(std::is_trivially_copyable>::value, "trivially copyable"); } @@ -100,9 +100,10 @@ TEST(PointerIntPairTest, ManyUnusedBits) { EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1, (int)PointerLikeTypeTraits::NumLowBitsAvailable); - static_assert(std::is_trivially_copyable_v< - PointerIntPair>, - "trivially copyable"); + static_assert( + std::is_trivially_copyable< + PointerIntPair>::value, + "trivially copyable"); } } // end anonymous namespace diff --git a/llvm/unittests/ADT/PointerUnionTest.cpp b/llvm/unittests/ADT/PointerUnionTest.cpp index 43ab6a97cffdd4..180ae45931ccb8 100644 --- a/llvm/unittests/ADT/PointerUnionTest.cpp +++ b/llvm/unittests/ADT/PointerUnionTest.cpp @@ -279,13 +279,13 @@ TEST_F(PointerUnionTest, NewCastInfra) { EXPECT_EQ(dyn_cast(constd4), nullptr); auto *result1 = cast(constd4); - static_assert(std::is_same_v, + static_assert(std::is_same::value, "type mismatch for cast with PointerUnion"); PointerUnion constd2(&d); auto *result2 = cast(constd2); EXPECT_EQ(result2, &d); - static_assert(std::is_same_v, + static_assert(std::is_same::value, "type mismatch for cast with PointerUnion"); } diff --git a/llvm/unittests/ADT/SmallVectorTest.cpp b/llvm/unittests/ADT/SmallVectorTest.cpp index 62e6f4339f94ad..e7ac9c0d76fddb 100644 --- a/llvm/unittests/ADT/SmallVectorTest.cpp +++ b/llvm/unittests/ADT/SmallVectorTest.cpp @@ -1229,7 +1229,7 @@ class SmallVectorReferenceInvalidationTest : public SmallVectorTestBase { VectorT V; template static bool isValueType() { - return std::is_same_v; + return std::is_same::value; } void SetUp() override { diff --git a/llvm/unittests/ADT/StringRefTest.cpp b/llvm/unittests/ADT/StringRefTest.cpp index 4ea1ea54551856..3827ebeb23980c 100644 --- a/llvm/unittests/ADT/StringRefTest.cpp +++ b/llvm/unittests/ADT/StringRefTest.cpp @@ -34,18 +34,24 @@ 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_v, - "Assigning from prvalue std::string"); -static_assert(!std::is_assignable_v, - "Assigning from xvalue std::string"); -static_assert(std::is_assignable_v, - "Assigning from lvalue std::string"); -static_assert(std::is_assignable_v, - "Assigning from prvalue C string"); -static_assert(std::is_assignable_v, - "Assigning from xvalue C string"); -static_assert(std::is_assignable_v, - "Assigning from lvalue C string"); +static_assert( + !std::is_assignable::value, + "Assigning from prvalue std::string"); +static_assert( + !std::is_assignable::value, + "Assigning from xvalue std::string"); +static_assert( + std::is_assignable::value, + "Assigning from lvalue std::string"); +static_assert( + std::is_assignable::value, + "Assigning from prvalue C string"); +static_assert( + std::is_assignable::value, + "Assigning from xvalue C string"); +static_assert( + std::is_assignable::value, + "Assigning from lvalue C string"); namespace { TEST(StringRefTest, Construction) { @@ -1138,6 +1144,7 @@ TEST(StringRefTest, LFCRLineEnding) { EXPECT_EQ(StringRef("\n\r"), Cases[2].detectEOL()); } -static_assert(std::is_trivially_copyable_v, "trivially copyable"); +static_assert(std::is_trivially_copyable::value, + "trivially copyable"); } // end anonymous namespace diff --git a/llvm/unittests/ADT/TypeTraitsTest.cpp b/llvm/unittests/ADT/TypeTraitsTest.cpp index a56aa7e98cfe09..30fb98a3f2f54f 100644 --- a/llvm/unittests/ADT/TypeTraitsTest.cpp +++ b/llvm/unittests/ADT/TypeTraitsTest.cpp @@ -19,11 +19,11 @@ namespace { /// Check a callable type of the form `bool(const int &)`. template struct CheckFunctionTraits { static_assert( - std::is_same_v::result_t, bool>, + std::is_same::result_t, bool>::value, "expected result_t to be `bool`"); static_assert( - std::is_same_v::template arg_t<0>, - const int &>, + std::is_same::template arg_t<0>, + const int &>::value, "expected arg_t<0> to be `const int &`"); static_assert(function_traits::num_args == 1, "expected num_args to be 1"); diff --git a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp index 91621287c8a9ba..91009ab7d074f4 100644 --- a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp +++ b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp @@ -91,7 +91,7 @@ TEST_F(BlockFrequencyInfoTest, Basic) { EXPECT_EQ(BFI.getBlockFreq(BB3).getFrequency(), BB3Freq); } -static_assert(std::is_trivially_copyable_v, +static_assert(std::is_trivially_copyable::value, "trivially copyable"); } // end anonymous namespace diff --git a/llvm/unittests/Analysis/CallGraphTest.cpp b/llvm/unittests/Analysis/CallGraphTest.cpp index 566733f10c8a96..0060d2c4b23969 100644 --- a/llvm/unittests/Analysis/CallGraphTest.cpp +++ b/llvm/unittests/Analysis/CallGraphTest.cpp @@ -23,11 +23,11 @@ template void canSpecializeGraphTraitsIterators(Ty *G) { auto X = ++I; // Should be able to iterate over all nodes of the graph. - static_assert(std::is_same_v, + static_assert(std::is_same::value, "Node type does not match"); - static_assert(std::is_same_v, + static_assert(std::is_same::value, "Node type does not match"); - static_assert(std::is_same_v, + static_assert(std::is_same::value, "Node type does not match"); NodeRef N = GraphTraits::getEntryNode(G); @@ -36,9 +36,9 @@ template void canSpecializeGraphTraitsIterators(Ty *G) { auto F = GraphTraits::child_end(N); // Should be able to iterate over immediate successors of a node. - static_assert(std::is_same_v, + static_assert(std::is_same::value, "Node type does not match"); - static_assert(std::is_same_v, + static_assert(std::is_same::value, "Node type does not match"); } diff --git a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp index f9056f00a2133c..669288e4264762 100644 --- a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp +++ b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp @@ -161,7 +161,7 @@ TEST(BitstreamReaderTest, shortRead) { } } -static_assert(std::is_trivially_copyable_v, +static_assert(std::is_trivially_copyable::value, "trivially copyable"); } // end anonymous namespace diff --git a/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp b/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp index b583856fb559ab..5ce0983ae3cdc3 100644 --- a/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp +++ b/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp @@ -181,14 +181,16 @@ TEST(MachineInstrBundleIteratorTest, ReverseConstructor) { EXPECT_EQ(crbegin(), const_reverse_iterator(cend())); // Confirm lack of implicit conversions. - static_assert(!std::is_convertible_v, + static_assert(!std::is_convertible::value, "unexpected implicit conversion"); - static_assert(!std::is_convertible_v, - "unexpected implicit conversion"); - static_assert(!std::is_convertible_v, - "unexpected implicit conversion"); - static_assert(!std::is_convertible_v, + static_assert(!std::is_convertible::value, "unexpected implicit conversion"); + static_assert( + !std::is_convertible::value, + "unexpected implicit conversion"); + static_assert( + !std::is_convertible::value, + "unexpected implicit conversion"); } } // end namespace diff --git a/llvm/unittests/CodeGen/MachineInstrTest.cpp b/llvm/unittests/CodeGen/MachineInstrTest.cpp index 19e46075dbae44..6488f24e54a8a6 100644 --- a/llvm/unittests/CodeGen/MachineInstrTest.cpp +++ b/llvm/unittests/CodeGen/MachineInstrTest.cpp @@ -472,6 +472,7 @@ TEST(MachineInstrBuilder, BuildMI) { EXPECT_THAT(BuildMI(MBB, MIMD, MCID), HasMIMetadata(MIMD)); } -static_assert(std::is_trivially_copyable_v, "trivially copyable"); +static_assert(std::is_trivially_copyable::value, + "trivially copyable"); } // end namespace diff --git a/llvm/unittests/CodeGen/TypeTraitsTest.cpp b/llvm/unittests/CodeGen/TypeTraitsTest.cpp index 0ca4fa4e82c7c6..af1f36c1e9454a 100644 --- a/llvm/unittests/CodeGen/TypeTraitsTest.cpp +++ b/llvm/unittests/CodeGen/TypeTraitsTest.cpp @@ -17,12 +17,13 @@ using namespace llvm; #if __has_feature(is_trivially_copyable) || (defined(__GNUC__) && __GNUC__ >= 5) -static_assert(std::is_trivially_copyable_v, +static_assert(std::is_trivially_copyable::value, "trivially copyable"); -static_assert(std::is_trivially_copyable_v, "trivially copyable"); -static_assert(std::is_trivially_copyable_v, "trivially copyable"); -static_assert(std::is_trivially_copyable_v, "trivially copyable"); -static_assert(std::is_trivially_copyable_v, +static_assert(std::is_trivially_copyable::value, "trivially copyable"); +static_assert(std::is_trivially_copyable::value, "trivially copyable"); +static_assert(std::is_trivially_copyable::value, + "trivially copyable"); +static_assert(std::is_trivially_copyable::value, "trivially copyable"); #endif diff --git a/llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp b/llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp index 6c441a31882a63..ee73614d53d44d 100644 --- a/llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp @@ -67,7 +67,7 @@ static void spsSerializationRoundTrip(const T &Value) { template static void testFixedIntegralTypeSerialization() { spsSerializationRoundTrip(0); spsSerializationRoundTrip(static_cast(1)); - if (std::is_signed_v) { + if (std::is_signed::value) { spsSerializationRoundTrip(static_cast(-1)); spsSerializationRoundTrip(std::numeric_limits::min()); } diff --git a/llvm/unittests/IR/CFGBuilder.cpp b/llvm/unittests/IR/CFGBuilder.cpp index cede196d250aa2..c9bc52ca7a66ad 100644 --- a/llvm/unittests/IR/CFGBuilder.cpp +++ b/llvm/unittests/IR/CFGBuilder.cpp @@ -267,10 +267,11 @@ TEST(CFGBuilder, Rebuild) { EXPECT_TRUE(isa(B.getOrAddBlock("d")->getTerminator())); } -static_assert(std::is_trivially_copyable_v, +static_assert(std::is_trivially_copyable::value, "trivially copyable"); -static_assert(std::is_trivially_copyable_v, +static_assert(std::is_trivially_copyable::value, "trivially copyable"); -static_assert(std::is_trivially_copyable_v, "trivially copyable"); -static_assert(std::is_trivially_copyable_v, +static_assert(std::is_trivially_copyable::value, + "trivially copyable"); +static_assert(std::is_trivially_copyable::value, "trivially copyable"); diff --git a/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp b/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp index 27948c1ad6f1ae..08d41e46d4a839 100644 --- a/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp +++ b/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp @@ -23,7 +23,7 @@ const auto CFGDelete = CFGBuilder::ActionKind::Delete; using DomUpdate = DominatorTree::UpdateType; static_assert( - std::is_same_v, + std::is_same::value, "Trees differing only in IsPostDom should have the same update types"); using DomSNCA = DomTreeBuilder::SemiNCAInfo; using PostDomSNCA = DomTreeBuilder::SemiNCAInfo; diff --git a/llvm/unittests/IR/PassBuilderCallbacksTest.cpp b/llvm/unittests/IR/PassBuilderCallbacksTest.cpp index 91fa4e88ad7841..7785c975645370 100644 --- a/llvm/unittests/IR/PassBuilderCallbacksTest.cpp +++ b/llvm/unittests/IR/PassBuilderCallbacksTest.cpp @@ -401,8 +401,8 @@ struct MockPassInstrumentationCallbacks { template using ExtraMockPassHandle = - std::conditional_t, MockPassHandle, - MockPassHandle>; + std::conditional_t::value, + MockPassHandle, MockPassHandle>; template class PassBuilderCallbacksTest; diff --git a/llvm/unittests/IR/ValueMapTest.cpp b/llvm/unittests/IR/ValueMapTest.cpp index ae2912c8f4322e..06d53788553515 100644 --- a/llvm/unittests/IR/ValueMapTest.cpp +++ b/llvm/unittests/IR/ValueMapTest.cpp @@ -115,7 +115,8 @@ TYPED_TEST(ValueMapTest, OperationsWork) { template void CompileAssertHasType(VarType) { - static_assert(std::is_same_v, "Not the same type"); + static_assert(std::is_same::value, + "Not the same type"); } TYPED_TEST(ValueMapTest, Iteration) { diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp index 8ccabaeea5de8d..bebb36fc61f22d 100644 --- a/llvm/unittests/Support/Casting.cpp +++ b/llvm/unittests/Support/Casting.cpp @@ -122,15 +122,15 @@ template <> struct CastInfo { using namespace llvm; // Test the peculiar behavior of Use in simplify_type. -static_assert(std::is_same_v::SimpleType, Value *>, +static_assert(std::is_same::SimpleType, Value *>::value, "Use doesn't simplify correctly!"); -static_assert(std::is_same_v::SimpleType, Value *>, +static_assert(std::is_same::SimpleType, Value *>::value, "Use doesn't simplify correctly!"); // Test that a regular class behaves as expected. -static_assert(std::is_same_v::SimpleType, int>, +static_assert(std::is_same::SimpleType, int>::value, "Unexpected simplify_type result!"); -static_assert(std::is_same_v::SimpleType, foo *>, +static_assert(std::is_same::SimpleType, foo *>::value, "Unexpected simplify_type result!"); namespace { @@ -177,7 +177,7 @@ TEST(CastingTest, cast) { std::unique_ptr BP(B2); auto FP = cast(std::move(BP)); - static_assert(std::is_same_v, decltype(FP)>, + static_assert(std::is_same, decltype(FP)>::value, "Incorrect deduced return type!"); EXPECT_NE(FP.get(), null_foo); FP.release(); diff --git a/llvm/unittests/Support/ErrorOrTest.cpp b/llvm/unittests/Support/ErrorOrTest.cpp index cb0e63660452b8..6e5bd2edd3129e 100644 --- a/llvm/unittests/Support/ErrorOrTest.cpp +++ b/llvm/unittests/Support/ErrorOrTest.cpp @@ -113,26 +113,27 @@ TEST(ErrorOr, ImplicitConversionNoAmbiguity) { // ErrorOr x(nullptr); // ErrorOr> y = x; // invalid conversion static_assert( - !std::is_convertible_v &, - ErrorOr>>, + !std::is_convertible &, + ErrorOr>>::value, "do not invoke explicit ctors in implicit conversion from lvalue"); // ErrorOr> y = ErrorOr(nullptr); // invalid // // conversion static_assert( - !std::is_convertible_v &&, ErrorOr>>, + !std::is_convertible &&, + ErrorOr>>::value, "do not invoke explicit ctors in implicit conversion from rvalue"); // ErrorOr x(nullptr); // ErrorOr> y; // y = x; // invalid conversion -static_assert(!std::is_assignable_v> &, - const ErrorOr &>, +static_assert(!std::is_assignable>&, + const ErrorOr &>::value, "do not invoke explicit ctors in assignment"); // ErrorOr> x; // x = ErrorOr(nullptr); // invalid conversion -static_assert( - !std::is_assignable_v> &, ErrorOr &&>, - "do not invoke explicit ctors in assignment"); +static_assert(!std::is_assignable>&, + ErrorOr &&>::value, + "do not invoke explicit ctors in assignment"); } // end anon namespace diff --git a/llvm/unittests/Support/ScaledNumberTest.cpp b/llvm/unittests/Support/ScaledNumberTest.cpp index 817e8b076686a3..82ecce09444d90 100644 --- a/llvm/unittests/Support/ScaledNumberTest.cpp +++ b/llvm/unittests/Support/ScaledNumberTest.cpp @@ -562,7 +562,7 @@ TEST(ScaledNumberHelpersTest, toIntBug) { EXPECT_EQ(1u, (n * n).toInt()); } -static_assert(std::is_trivially_copyable_v>, +static_assert(std::is_trivially_copyable>::value, "trivially copyable"); } // end namespace diff --git a/llvm/unittests/Support/ThreadLocalTest.cpp b/llvm/unittests/Support/ThreadLocalTest.cpp index 454e4f21a05fe8..075d7d95b25b02 100644 --- a/llvm/unittests/Support/ThreadLocalTest.cpp +++ b/llvm/unittests/Support/ThreadLocalTest.cpp @@ -25,8 +25,9 @@ struct S { TEST_F(ThreadLocalTest, Basics) { ThreadLocal x; - static_assert(std::is_const_v>, - "ThreadLocal::get didn't return a pointer to const object"); + static_assert( + std::is_const::type>::value, + "ThreadLocal::get didn't return a pointer to const object"); EXPECT_EQ(nullptr, x.get()); @@ -39,8 +40,9 @@ TEST_F(ThreadLocalTest, Basics) { ThreadLocal y; - static_assert(!std::is_const_v>, - "ThreadLocal::get returned a pointer to const object"); + static_assert( + !std::is_const::type>::value, + "ThreadLocal::get returned a pointer to const object"); EXPECT_EQ(nullptr, y.get());