aboutsummaryrefslogtreecommitdiff
path: root/llvm/unittests/ADT
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/unittests/ADT')
-rw-r--r--llvm/unittests/ADT/ArrayRefTest.cpp41
-rw-r--r--llvm/unittests/ADT/DenseMapTest.cpp2
-rw-r--r--llvm/unittests/ADT/DenseSetTest.cpp14
-rw-r--r--llvm/unittests/ADT/EnumeratedArrayTest.cpp10
-rw-r--r--llvm/unittests/ADT/IListIteratorTest.cpp14
-rw-r--r--llvm/unittests/ADT/IListNodeTest.cpp37
-rw-r--r--llvm/unittests/ADT/ImmutableListTest.cpp2
-rw-r--r--llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp28
-rw-r--r--llvm/unittests/ADT/IteratorTest.cpp16
-rw-r--r--llvm/unittests/ADT/OptionalTest.cpp17
-rw-r--r--llvm/unittests/ADT/PointerIntPairTest.cpp9
-rw-r--r--llvm/unittests/ADT/PointerUnionTest.cpp4
-rw-r--r--llvm/unittests/ADT/SmallVectorTest.cpp2
-rw-r--r--llvm/unittests/ADT/StringRefTest.cpp33
-rw-r--r--llvm/unittests/ADT/TypeTraitsTest.cpp6
15 files changed, 106 insertions, 129 deletions
diff --git a/llvm/unittests/ADT/ArrayRefTest.cpp b/llvm/unittests/ADT/ArrayRefTest.cpp
index eded12d..9fcddc8 100644
--- a/llvm/unittests/ADT/ArrayRefTest.cpp
+++ b/llvm/unittests/ADT/ArrayRefTest.cpp
@@ -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) {
diff --git a/llvm/unittests/ADT/DenseMapTest.cpp b/llvm/unittests/ADT/DenseMapTest.cpp
index cb77ad8..6893f43 100644
--- a/llvm/unittests/ADT/DenseMapTest.cpp
+++ b/llvm/unittests/ADT/DenseMapTest.cpp
@@ -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; }
diff --git a/llvm/unittests/ADT/DenseSetTest.cpp b/llvm/unittests/ADT/DenseSetTest.cpp
index 82ac1d8..f14542e 100644
--- a/llvm/unittests/ADT/DenseSetTest.cpp
+++ b/llvm/unittests/ADT/DenseSetTest.cpp
@@ -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) {
diff --git a/llvm/unittests/ADT/EnumeratedArrayTest.cpp b/llvm/unittests/ADT/EnumeratedArrayTest.cpp
index 9975428..a978ce4 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<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
diff --git a/llvm/unittests/ADT/IListIteratorTest.cpp b/llvm/unittests/ADT/IListIteratorTest.cpp
index 559e32de..bd638a8 100644
--- a/llvm/unittests/ADT/IListIteratorTest.cpp
+++ b/llvm/unittests/ADT/IListIteratorTest.cpp
@@ -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
diff --git a/llvm/unittests/ADT/IListNodeTest.cpp b/llvm/unittests/ADT/IListNodeTest.cpp
index cf775eb..057eabb 100644
--- a/llvm/unittests/ADT/IListNodeTest.cpp
+++ b/llvm/unittests/ADT/IListNodeTest.cpp
@@ -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");
}
diff --git a/llvm/unittests/ADT/ImmutableListTest.cpp b/llvm/unittests/ADT/ImmutableListTest.cpp
index 28624c0..2da0ca6 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<ImmutableList<Wrapper<long>>>::value,
+static_assert(std::is_trivially_copyable_v<ImmutableList<Wrapper<long>>>,
"trivially copyable");
} // namespace
diff --git a/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp b/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
index e4b6498..45b8028 100644
--- a/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
+++ b/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
@@ -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=.
diff --git a/llvm/unittests/ADT/IteratorTest.cpp b/llvm/unittests/ADT/IteratorTest.cpp
index 7269bfc..8c90049 100644
--- a/llvm/unittests/ADT/IteratorTest.cpp
+++ b/llvm/unittests/ADT/IteratorTest.cpp
@@ -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;
}
diff --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp
index e615d56e..5f1f88d 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<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.");
}
diff --git a/llvm/unittests/ADT/PointerIntPairTest.cpp b/llvm/unittests/ADT/PointerIntPairTest.cpp
index 8a42e5b..9e5e0ee 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<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
diff --git a/llvm/unittests/ADT/PointerUnionTest.cpp b/llvm/unittests/ADT/PointerUnionTest.cpp
index 180ae45..43ab6a9 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<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");
}
diff --git a/llvm/unittests/ADT/SmallVectorTest.cpp b/llvm/unittests/ADT/SmallVectorTest.cpp
index e7ac9c0..62e6f433 100644
--- a/llvm/unittests/ADT/SmallVectorTest.cpp
+++ b/llvm/unittests/ADT/SmallVectorTest.cpp
@@ -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 {
diff --git a/llvm/unittests/ADT/StringRefTest.cpp b/llvm/unittests/ADT/StringRefTest.cpp
index 3827ebe..4ea1ea54 100644
--- a/llvm/unittests/ADT/StringRefTest.cpp
+++ b/llvm/unittests/ADT/StringRefTest.cpp
@@ -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
diff --git a/llvm/unittests/ADT/TypeTraitsTest.cpp b/llvm/unittests/ADT/TypeTraitsTest.cpp
index 30fb98a..a56aa7e 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 <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");
generated by cgit v1.1 at 2025-08-04 07:30:01 +0000