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

This reverts commit 632a389f96355cbe7ed8fa7b8d2ed6267c92457c.

This relands commit
1834a310d060d55748ca38d4ae0482864c2047d8.

Differential Revision: https://reviews.llvm.org/D137493

30 files changed, 152 insertions, 184 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");
diff --git a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
index 91009ab..9162128 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<bfi_detail::BlockMass>::value,
+static_assert(std::is_trivially_copyable_v<bfi_detail::BlockMass>,
               "trivially copyable");
 
 } // end anonymous namespace
diff --git a/llvm/unittests/Analysis/CallGraphTest.cpp b/llvm/unittests/Analysis/CallGraphTest.cpp
index 0060d2c..566733f 100644
--- a/llvm/unittests/Analysis/CallGraphTest.cpp
+++ b/llvm/unittests/Analysis/CallGraphTest.cpp
@@ -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");
 }
 
diff --git a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
index 669288e..f9056f0 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<BitCodeAbbrevOp>::value,
+static_assert(std::is_trivially_copyable_v<BitCodeAbbrevOp>,
               "trivially copyable");
 
 } // end anonymous namespace
diff --git a/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp b/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp
index 5ce0983..b583856 100644
--- a/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp
+++ b/llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp
@@ -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
diff --git a/llvm/unittests/CodeGen/MachineInstrTest.cpp b/llvm/unittests/CodeGen/MachineInstrTest.cpp
index 6488f24..19e46075 100644
--- a/llvm/unittests/CodeGen/MachineInstrTest.cpp
+++ b/llvm/unittests/CodeGen/MachineInstrTest.cpp
@@ -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
diff --git a/llvm/unittests/CodeGen/TypeTraitsTest.cpp b/llvm/unittests/CodeGen/TypeTraitsTest.cpp
index af1f36c..0ca4fa4 100644
--- a/llvm/unittests/CodeGen/TypeTraitsTest.cpp
+++ b/llvm/unittests/CodeGen/TypeTraitsTest.cpp
@@ -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
 
diff --git a/llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp b/llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp
index ee73614..6c441a3 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 <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());
   }
diff --git a/llvm/unittests/IR/CFGBuilder.cpp b/llvm/unittests/IR/CFGBuilder.cpp
index c9bc52c..cede196 100644
--- a/llvm/unittests/IR/CFGBuilder.cpp
+++ b/llvm/unittests/IR/CFGBuilder.cpp
@@ -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");
diff --git a/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp b/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp
index 08d41e4..27948c1 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<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>;
diff --git a/llvm/unittests/IR/PassBuilderCallbacksTest.cpp b/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
index 7785c97..91fa4e8 100644
--- a/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
+++ b/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
@@ -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;
 
diff --git a/llvm/unittests/IR/ValueMapTest.cpp b/llvm/unittests/IR/ValueMapTest.cpp
index 06d5378..ae2912c 100644
--- a/llvm/unittests/IR/ValueMapTest.cpp
+++ b/llvm/unittests/IR/ValueMapTest.cpp
@@ -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) {
diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp
index bebb36f..8ccabae 100644
--- a/llvm/unittests/Support/Casting.cpp
+++ b/llvm/unittests/Support/Casting.cpp
@@ -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();
diff --git a/llvm/unittests/Support/ErrorOrTest.cpp b/llvm/unittests/Support/ErrorOrTest.cpp
index 6e5bd2e..cb0e636 100644
--- a/llvm/unittests/Support/ErrorOrTest.cpp
+++ b/llvm/unittests/Support/ErrorOrTest.cpp
@@ -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
diff --git a/llvm/unittests/Support/ScaledNumberTest.cpp b/llvm/unittests/Support/ScaledNumberTest.cpp
index 82ecce0..817e8b0 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<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
diff --git a/llvm/unittests/Support/ThreadLocalTest.cpp b/llvm/unittests/Support/ThreadLocalTest.cpp
index 075d7d9..454e4f2 100644
--- a/llvm/unittests/Support/ThreadLocalTest.cpp
+++ b/llvm/unittests/Support/ThreadLocalTest.cpp
@@ -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());