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

[njames93]

Summary

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

[nikic]

llvm/lib/DebugInfo/CodeView/EnumTables.cpp

17

Missing t?

[njames93]

llvm/lib/DebugInfo/CodeView/EnumTables.cpp

17

Cheers, that was done manually :)

[njames93]

Fix error.

[dblaikie]

Sounds great!

llvm/include/llvm/Support/YAMLTraits.h

 
 } // end namespace yaml
 } // end namespace llvm
 
 #define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW)                          \
   namespace llvm {                                                             \
   namespace yaml {                                                             \
   static_assert(                                                               \
-      !std::is_fundamental<TYPE>::value &&                                     \
-      !std::is_same<TYPE, std::string>::value &&                               \
-      !std::is_same<TYPE, llvm::StringRef>::value,                             \
+      !std::is_fundamental_v<TYPE> && !std::is_same_v<TYPE, std::string> &&    \
+          !std::is_same_v<TYPE, llvm::StringRef>,                              \
       "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control");          \
   template <> struct SequenceElementTraits<TYPE> {                             \
     static const bool flow = FLOW;                                             \
   };                                                                           \
   }                                                                            \
   }
 
 /// Utility for declaring that a std::vector of a particular type

llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp

struct LocIndex {
   LocIndex(u32_location_t Location, u32_index_t Index)
       : Location(Location), Index(Index) {}
 
   uint64_t getAsRawInteger() const {
     return (static_cast<uint64_t>(Location) << 32) | Index;
   }
 
   template<typename IntT> static LocIndex fromRawInteger(IntT ID) {
-    static_assert(std::is_unsigned<IntT>::value &&
-                      sizeof(ID) == sizeof(uint64_t),
+    static_assert(std::is_unsigned_v<IntT> && sizeof(ID) == sizeof(uint64_t),
                   "Cannot convert raw integer to LocIndex");
     return {static_cast<u32_location_t>(ID >> 32),
             static_cast<u32_index_t>(ID)};
   }
 
   /// Get the start of the interval reserved for VarLocs of kind RegisterKind
   /// which reside in \p Reg. The end is at rawIndexForReg(Reg+1)-1.
   static uint64_t rawIndexForReg(Register Reg) {

llvm/lib/DebugInfo/CodeView/EnumTables.cpp

 //===- EnumTables.cpp - Enum to string conversion tables ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/EnumTables.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <type_traits>
 
 using namespace llvm;
 using namespace codeview;
 
 #define CV_ENUM_CLASS_ENT(enum_class, enum)                                    \
-  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
+  { #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
 
 #define CV_ENUM_ENT(ns, enum)                                                  \
   { #enum, ns::enum }
 
 static const EnumEntry<SymbolKind> SymbolTypeNames[] = {
 #define CV_SYMBOL(enum, val) {#enum, enum},
 #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
 #undef CV_SYMBOL

llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

 using namespace llvm::codeview;
 
 static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
 #define CV_TYPE(enum, val) {#enum, enum},
 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
 };
 
 #define ENUM_ENTRY(enum_class, enum)                                           \
-  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
+  { #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
 
 static const EnumEntry<uint16_t> ClassOptionNames[] = {
     ENUM_ENTRY(ClassOptions, Packed),
     ENUM_ENTRY(ClassOptions, HasConstructorOrDestructor),
     ENUM_ENTRY(ClassOptions, HasOverloadedOperator),
     ENUM_ENTRY(ClassOptions, Nested),
     ENUM_ENTRY(ClassOptions, ContainsNestedClass),
     ENUM_ENTRY(ClassOptions, HasOverloadedAssignmentOperator),

llvm/lib/DebugInfo/PDB/Native/EnumTables.cpp

 //===- EnumTables.cpp - Enum to string conversion tables --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/EnumTables.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 #define PDB_ENUM_CLASS_ENT(enum_class, enum)                                   \
-  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
+  { #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
 
 #define PDB_ENUM_ENT(ns, enum)                                                 \
   { #enum, ns::enum }
 
 static const EnumEntry<uint16_t> OMFSegMapDescFlagNames[] = {
     PDB_ENUM_CLASS_ENT(OMFSegDescFlags, Read),
     PDB_ENUM_CLASS_ENT(OMFSegDescFlags, Write),
     PDB_ENUM_CLASS_ENT(OMFSegDescFlags, Execute),

llvm/lib/Object/DXContainer.cpp

static Error readStruct(StringRef Buffer, const char *Src, T &Struct) {
   // DXContainer is always little endian
   if (sys::IsBigEndianHost)
     Struct.swapBytes();
   return Error::success();
 }
 
 template <typename T>
 static Error readInteger(StringRef Buffer, const char *Src, T &Val) {
-  static_assert(std::is_integral<T>::value,
+  static_assert(std::is_integral_v<T>,
                 "Cannot call readInteger on non-integral type.");
   // Don't read before the beginning or past the end of the file
   if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
     return parseFailed("Reading structure out of file bounds");
 
   // The DXContainer offset table is comprised of uint32_t values but not padded
   // to a 64-bit boundary. So Parts may start unaligned if there is an odd
   // number of parts and part data itself is not required to be padded.

llvm/lib/ProfileData/InstrProf.cpp

 
 uint64_t Header::formatVersion() const {
   using namespace support;
   return endian::byte_swap<uint64_t, little>(Version);
 }
 
 Expected<Header> Header::readFromBuffer(const unsigned char *Buffer) {
   using namespace support;
-  static_assert(std::is_standard_layout<Header>::value,
+  static_assert(std::is_standard_layout_v<Header>,
                 "The header should be standard layout type since we use offset "
                 "of fields to read.");
   Header H;
 
   H.Magic = read(Buffer, offsetOf(&Header::Magic));
   // Check the magic number.
   uint64_t Magic = endian::byte_swap<uint64_t, little>(H.Magic);
   if (Magic != IndexedInstrProf::Magic)

llvm/lib/Support/ItaniumManglingCanonicalizer.cpp

 namespace {
 struct FoldingSetNodeIDBuilder {
   llvm::FoldingSetNodeID &ID;
   void operator()(const Node *P) { ID.AddPointer(P); }
   void operator()(StringView Str) {
     ID.AddString(llvm::StringRef(Str.begin(), Str.size()));
   }
   template <typename T>
-  std::enable_if_t<std::is_integral<T>::value || std::is_enum<T>::value>
-  operator()(T V) {
+  std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>> operator()(T V) {
     ID.AddInteger((unsigned long long)V);
   }
   void operator()(itanium_demangle::NodeArray A) {
     ID.AddInteger(A.size());
     for (const Node *N : A)
       (*this)(N);
   }
 };

llvm/lib/Support/NativeFormatting.cpp

while (!Buffer.empty()) {
     S.write(ThisGroup.data(), 3);
     Buffer = Buffer.drop_front(3);
   }
 }
 
 template <typename T>
 static void write_unsigned_impl(raw_ostream &S, T N, size_t MinDigits,
                                 IntegerStyle Style, bool IsNegative) {
-  static_assert(std::is_unsigned<T>::value, "Value is not unsigned!");
+  static_assert(std::is_unsigned_v<T>, "Value is not unsigned!");
 
   char NumberBuffer[128];
   std::memset(NumberBuffer, '0', sizeof(NumberBuffer));
 
   size_t Len = 0;
   Len = format_to_buffer(N, NumberBuffer);
 
   if (IsNegative)
write_unsigned_impl(S, static_cast<uint32_t>(N), MinDigits, Style,
                         IsNegative);
   else
     write_unsigned_impl(S, N, MinDigits, Style, IsNegative);
 }
 
 template <typename T>
 static void write_signed(raw_ostream &S, T N, size_t MinDigits,
                          IntegerStyle Style) {
-  static_assert(std::is_signed<T>::value, "Value is not signed!");
+  static_assert(std::is_signed_v<T>, "Value is not signed!");
 
   using UnsignedT = std::make_unsigned_t<T>;
 
   if (N >= 0) {
     write_unsigned(S, static_cast<UnsignedT>(N), MinDigits, Style);
     return;
   }
 

llvm/lib/Target/X86/X86ISelLowering.cpp

 
 /// Determines whether Args, either a set of outgoing arguments to a call, or a
 /// set of incoming args of a call, contains an sret pointer that the callee
 /// pops
 template <typename T>
 static bool hasCalleePopSRet(const SmallVectorImpl<T> &Args,
                              const X86Subtarget &Subtarget) {
   // Not C++20 (yet), so no concepts available.
-  static_assert(std::is_same<T, ISD::OutputArg>::value ||
-                    std::is_same<T, ISD::InputArg>::value,
+  static_assert(std::is_same_v<T, ISD::OutputArg> ||
+                    std::is_same_v<T, ISD::InputArg>,
                 "requires ISD::OutputArg or ISD::InputArg");
 
   // Only 32-bit pops the sret.  It's a 64-bit world these days, so early-out
   // for most compilations.
   if (!Subtarget.is32Bit())
     return false;
 
   if (Args.empty())

llvm/lib/Transforms/Scalar/NaryReassociate.cpp

if (Value *Candidate = Candidates.back()) {
         return CandidateInstruction;
     }
     Candidates.pop_back();
   }
   return nullptr;
 }
 
 template <typename MaxMinT> static SCEVTypes convertToSCEVype(MaxMinT &MM) {
-  if (std::is_same<smax_pred_ty, typename MaxMinT::PredType>::value)
+  if (std::is_same_v<smax_pred_ty, typename MaxMinT::PredType>)
     return scSMaxExpr;
-  else if (std::is_same<umax_pred_ty, typename MaxMinT::PredType>::value)
+  else if (std::is_same_v<umax_pred_ty, typename MaxMinT::PredType>)
     return scUMaxExpr;
-  else if (std::is_same<smin_pred_ty, typename MaxMinT::PredType>::value)
+  else if (std::is_same_v<smin_pred_ty, typename MaxMinT::PredType>)
     return scSMinExpr;
-  else if (std::is_same<umin_pred_ty, typename MaxMinT::PredType>::value)
+  else if (std::is_same_v<umin_pred_ty, typename MaxMinT::PredType>)
     return scUMinExpr;
 
   llvm_unreachable("Can't convert MinMax pattern to SCEV type");
   return scUnknown;
 }
 
 // Parameters:
 //  I - instruction matched by MaxMinMatch matcher

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

static bool isFirstInsertElement(const InsertElementInst *IE1,
   llvm_unreachable("Two different buildvectors not expected.");
 }
 
 namespace {
 /// Returns incoming Value *, if the requested type is Value * too, or a default
 /// value, otherwise.
 struct ValueSelect {
   template <typename U>
-  static std::enable_if_t<std::is_same<Value *, U>::value, Value *>
-  get(Value *V) {
+  static std::enable_if_t<std::is_same_v<Value *, U>, Value *> get(Value *V) {
     return V;
   }
   template <typename U>
-  static std::enable_if_t<!std::is_same<Value *, U>::value, U> get(Value *) {
+  static std::enable_if_t<!std::is_same_v<Value *, U>, U> get(Value *) {
     return U();
   }
 };
 } // namespace
 
 /// Does the analysis of the provided shuffle masks and performs the requested
 /// actions on the vectors with the given shuffle masks. It tries to do it in
 /// several steps.

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

public:
   ArrayRef<StringRef> getFiles() const { return Files; }
 
   static_assert(
       std::is_same<decltype(MembersData::MembersPerArchitecture)::mapped_type,
                    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<
-          decltype(NewArchiveMemberList::Members)::value_type>::value,
+      !std::is_copy_constructible_v<
+          decltype(NewArchiveMemberList::Members)::value_type>,
       "MembersData::MembersPerArchitecture has a dependency on "
       "MembersData::FileBuffers so it should not be able to "
       "be copied on its own without FileBuffers. Unfortunately, "
       "is_copy_constructible does not detect whether the container (ie vector) "
       "of a non-copyable type is itself non-copyable so we have to test the "
       "actual type of the stored data (ie, value_type).");
   static_assert(
-      !std::is_copy_assignable<
-          decltype(NewArchiveMemberList::Members)::value_type>::value,
+      !std::is_copy_assignable_v<
+          decltype(NewArchiveMemberList::Members)::value_type>,
       "MembersData::MembersPerArchitecture has a dependency on "
       "MembersData::FileBuffers so it should not be able to "
       "be copied on its own without FileBuffers. Unfortunately, "
       "is_copy_constructible does not detect whether the container (ie vector) "
       "of a non-copyable type is itself non-copyable so we have to test the "
       "actual type of the stored data (ie, value_type).");
 };
 

llvm/unittests/ADT/ArrayRefTest.cpp

 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 #include <limits>
 #include <vector>
 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,
+static_assert(std::is_convertible_v<ArrayRef<int *>, ArrayRef<const int *>>,
               "Adding const");
-static_assert(
-    std::is_convertible<ArrayRef<int *>, ArrayRef<volatile int *>>::value,
+static_assert(std::is_convertible_v<ArrayRef<int *>, ArrayRef<volatile int *>>,
               "Adding volatile");
-static_assert(!std::is_convertible<ArrayRef<int *>, ArrayRef<float *>>::value,
+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,
+static_assert(!std::is_convertible_v<ArrayRef<const int *>, ArrayRef<int *>>,
               "Removing const");
-static_assert(
-    !std::is_convertible<ArrayRef<volatile int *>, ArrayRef<int *>>::value,
+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<ArrayRef<int *>&, int *>::value,
+static_assert(!std::is_assignable_v<ArrayRef<int *> &, int *>,
               "Assigning from single prvalue element");
-static_assert(
-    !std::is_assignable<ArrayRef<int *>&, int * &&>::value,
+static_assert(!std::is_assignable_v<ArrayRef<int *> &, int *&&>,
               "Assigning from single xvalue element");
-static_assert(
-    std::is_assignable<ArrayRef<int *>&, int * &>::value,
+static_assert(std::is_assignable_v<ArrayRef<int *> &, int *&>,
               "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 {
 
 TEST(ArrayRefTest, AllocatorCopy) {
   BumpPtrAllocator Alloc;
   static const uint16_t Words1[] = { 1, 4, 200, 37 };
   ArrayRef<uint16_t> Array1 = makeArrayRef(Words1, 4);
TEST(ArrayRefTest, makeArrayRefFromStdArray) {
   ArrayRef<int> A2 = makeArrayRef(A1);
 
   EXPECT_EQ(A1.size(), A2.size());
   for (std::size_t i = 0; i < A1.size(); ++i) {
     EXPECT_EQ(A1[i], A2[i]);
   }
 }
 
-static_assert(std::is_trivially_copyable<ArrayRef<int>>::value,
+static_assert(std::is_trivially_copyable_v<ArrayRef<int>>,
               "trivially copyable");
 
 TEST(ArrayRefTest, makeMutableArrayRef) {
   int A = 0;
   auto AR = makeMutableArrayRef(A);
   EXPECT_EQ(AR.data(), &A);
   EXPECT_EQ(AR.size(), (size_t)1);
 

llvm/unittests/ADT/DenseMapTest.cpp

 };
 struct B : public A {
   using A::A;
 };
 } // namespace
 
 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; }
   static bool isEqual(const T &LHS, const T &RHS) {
     return LHS.value == RHS.value;
   }
 };
 } // namespace llvm

llvm/unittests/ADT/DenseSetTest.cpp

 //===- llvm/unittest/ADT/DenseSetTest.cpp - DenseSet unit tests --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/DenseSet.h"
 #include "gtest/gtest.h"
 #include <type_traits>
 
 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>>,
+static_assert(
+    std::is_const_v<
+        std::remove_reference_t<DenseSet<int>::const_iterator::reference>>,
 
 // Test hashing with a set of only two entries.
 TEST(DenseSetTest, DoubleEntrySetTest) {
   llvm::DenseSet<unsigned> set(2);
   set.insert(0);
   set.insert(1);
   // Original failure was an infinite loop in this call:
   EXPECT_EQ(0u, set.count(2));

llvm/unittests/ADT/EnumeratedArrayTest.cpp

 //===--------------------------------------------------------------------===//
 
 namespace {
 
 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
 
 } // namespace llvm

llvm/unittests/ADT/IListIteratorTest.cpp

TEST(IListIteratorTest, ReverseConstructor) {
 
   // Check const iterator constructors.
   EXPECT_EQ(CL.begin(), const_iterator(L.rend()));
   EXPECT_EQ(CL.begin(), const_iterator(CL.rend()));
   EXPECT_EQ(CL.rbegin(), const_reverse_iterator(L.end()));
   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<const_iterator, const_reverse_iterator>::value,
+  static_assert(!std::is_convertible_v<const_iterator, const_reverse_iterator>,
                 "unexpected implicit conversion");
-  static_assert(
-      !std::is_convertible<const_reverse_iterator, const_iterator>::value,
+  static_assert(!std::is_convertible_v<const_reverse_iterator, const_iterator>,
                 "unexpected implicit conversion");
 }
 
 } // end namespace

llvm/unittests/ADT/IListNodeTest.cpp

 
 struct Node;
 
 struct TagA {};
 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>,
+      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>::value,
+                                          ilist_sentinel_tracking<true>>::type>,
       "order shouldn't matter with real tags");
 }
 
 } // end namespace

llvm/unittests/ADT/ImmutableListTest.cpp

TEST_F(ImmutableListTest, LongListOrderingTest) {
   for (ImmutableList<Wrapper<long>>::iterator I = L3.begin(), E = L3.end();
        I != E; ++I) {
     ASSERT_EQ(i, *I);
     i++;
   }
   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

llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp

TEST(IntrusiveRefCntPtr, UsesTraitsToRetainAndRelease) {
   EXPECT_TRUE(Retained);
 }
 
 // Test that the generic constructors use SFINAE to disable invalid
 // conversions.
 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>>,
+static_assert(!std::is_convertible_v<const IntrusiveRefCntPtr<X> &,
+                                     IntrusiveRefCntPtr<Y>>,
               "const X& -> Y should be rejected with SFINAE");
-static_assert(
-    !std::is_convertible<std::unique_ptr<X>, IntrusiveRefCntPtr<Y>>::value,
+static_assert(!std::is_convertible_v<std::unique_ptr<X>, IntrusiveRefCntPtr<Y>>,
               "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,
+static_assert(
+    !std::is_convertible_v<IntrusiveRefCntPtr<X> &&, IntrusiveRefCntPtr<Z>>,
+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,
+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=.
   auto Y1 = makeIntrusiveRefCnt<Y>();
   auto Y2 = makeIntrusiveRefCnt<Y>();
   auto Y3 = makeIntrusiveRefCnt<Y>();
   auto Y4 = makeIntrusiveRefCnt<Y>();
   const void *P1 = Y1.get();

llvm/unittests/ADT/IteratorTest.cpp

 struct WeirdIter
     : llvm::iterator_facade_base<WeirdIter, std::input_iterator_tag, Shadow<0>,
                                  Shadow<1>, Shadow<2>, Shadow<3>> {};
 
 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.
 
 using RandomAccessIter = SmallVectorImpl<int*>::iterator;
 using BidiIter = ilist<int*>::iterator;
 
 template<class T>

 // There should only be a single (const-qualified) operator*, operator->, and
 // operator[]. This test confirms that there isn't a non-const overload. Rather
 // than adding those, users should double-check that T, PointerT, and ReferenceT
 // have the right constness, and/or make fields mutable.
 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;
 }
 
 TEST(IteratorAdaptorTest, Dereference) {
   int Number = 1;
 
   // Construct some iterators and check whether they can be assigned to.
TEST(IteratorAdaptorTest, Dereference) {
   EXPECT_EQ(3, (*CPC).I);
   *P = 4;
   EXPECT_EQ(4, Number);
   *PC = 5;
   EXPECT_EQ(5, Number);
 }
 
 // pointeE_iterator
-static_assert(IsAdaptedIterCategorySame<pointee_iterator_defaulted,
-                                        RandomAccessIter>::value, "");
-static_assert(IsAdaptedIterCategorySame<pointee_iterator_defaulted,
-                                        BidiIter>::value, "");
+static_assert(
+    IsAdaptedIterCategorySame_v<pointee_iterator_defaulted, RandomAccessIter>,
+    "");
+static_assert(IsAdaptedIterCategorySame_v<pointee_iterator_defaulted, BidiIter>,
+              "");
 // pointeR_iterator
-static_assert(IsAdaptedIterCategorySame<pointer_iterator_defaulted,
-                                        RandomAccessIter>::value, "");
-static_assert(IsAdaptedIterCategorySame<pointer_iterator_defaulted,
-                                        BidiIter>::value, "");
+static_assert(
+    IsAdaptedIterCategorySame_v<pointer_iterator_defaulted, RandomAccessIter>,
+    "");
+static_assert(IsAdaptedIterCategorySame_v<pointer_iterator_defaulted, BidiIter>,
+              "");
 
 TEST(PointeeIteratorTest, Basic) {
   int arr[4] = {1, 2, 3, 4};
   SmallVector<int *, 4> V;
   V.push_back(&arr[0]);
   V.push_back(&arr[1]);
   V.push_back(&arr[2]);
   V.push_back(&arr[3]);

llvm/unittests/ADT/OptionalTest.cpp

 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 
 #include <array>
 #include <utility>
 
 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() {
   constexpr auto x1 = Optional<int>();
   constexpr Optional<int> x2{};
   static_assert(!x1.has_value() && !x2.has_value(),
                 "Default construction and hasValue() are contexpr");
   static_assert(!x1.has_value() && !x2.has_value(),
static void ResetCounts() {
     CopyAssignments = 0;
   }
 };
 
 unsigned NonDefaultConstructible::CopyConstructions = 0;
 unsigned NonDefaultConstructible::Destructions = 0;
 unsigned NonDefaultConstructible::CopyAssignments = 0;
 
-static_assert(
-    !std::is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
+static_assert(!std::is_trivially_copyable_v<Optional<NonDefaultConstructible>>,
               "not trivially copyable");
 
 TEST(OptionalTest, NonDefaultConstructibleTest) {
   Optional<NonDefaultConstructible> O;
   EXPECT_FALSE(O);
 }
 
 TEST(OptionalTest, ResetTest) {
   NonDefaultConstructible::ResetCounts();
~MultiArgConstructor() {
     ++Destructions;
   }
   static void ResetCounts() {
     Destructions = 0;
   }
 };
 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) {
   MultiArgConstructor::ResetCounts();
   Optional<MultiArgConstructor> A;
 
   A.emplace(1, 2);
   EXPECT_TRUE(A.has_value());
static void ResetCounts() {
     MoveAssignments = 0;
   }
 };
 
 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) {
   MoveOnly::ResetCounts();
   Optional<MoveOnly> O;
   EXPECT_EQ(0u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(0u, MoveOnly::Destructions);

 private:
   // This should disable all move/copy operations.
   Immovable(Immovable&& other) = delete;
 };
 
 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) {
   Optional<Immovable> A;
   Immovable::ResetCounts();
   A.emplace(4);
   EXPECT_TRUE((bool)A);
   EXPECT_EQ(4, A->val);
TEST(OptionalTest, DeletedMoveConstructor) {
   using NoTMoveOptT = Optional<NoTMove>;
 
   NoTMoveOptT NonTMove1;
   NoTMoveOptT NonTMove2{std::move(NonTMove1)};
 
   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.");
 }
 
 class NoCopyStringMap {
 public:
   NoCopyStringMap() = default;
 

llvm/unittests/ADT/PointerIntPairTest.cpp

TEST(PointerIntPairTest, GetSet) {
   Pair2.setPointer(nullptr);
   EXPECT_EQ(nullptr, Pair2.getPointer());
   EXPECT_EQ(E::Case2, Pair2.getInt());
 
   Pair2.setPointerAndInt(&s, E::Case3);
   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");
 }
 
 TEST(PointerIntPairTest, DefaultInitialize) {
   PointerIntPair<float *, 2> Pair;
   EXPECT_EQ(nullptr, Pair.getPointer());
   EXPECT_EQ(0U, Pair.getInt());
 }
TEST(PointerIntPairTest, ManyUnusedBits) {
 
   pair.setPointerAndInt({ 0x7FFFFFFF }, true );
   EXPECT_EQ((uintptr_t)0x7FFFFFFF, pair.getPointer().Value);
   EXPECT_TRUE(pair.getInt());
 
   EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1,
             (int)PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);
 
-  static_assert(
-      std::is_trivially_copyable<
-          PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits>>::value,
+  static_assert(std::is_trivially_copyable_v<
+                    PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits>>,
                 "trivially copyable");
 }
 
 } // end anonymous namespace

llvm/unittests/ADT/PointerUnionTest.cpp

TEST_F(PointerUnionTest, NewCastInfra) {
   // test for const
   const PU4 constd4(&d);
   EXPECT_TRUE(isa<double *>(constd4));
   EXPECT_FALSE(isa<int *>(constd4));
   EXPECT_EQ(cast<double *>(constd4), &d);
   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");
 }
 
 } // end anonymous namespace

llvm/unittests/ADT/SmallVectorTest.cpp

 protected:
   const char *AssertionMessage =
       "Attempting to reference an element of the vector in an operation \" "
       "\"that invalidates it";
 
   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 {
     SmallVectorTestBase::SetUp();
 
     // Fill up the small size so that insertions move the elements.
     for (int I = 0, E = NumBuiltinElts(V); I != E; ++I)
       V.emplace_back(I + 1);

llvm/unittests/ADT/StringRefTest.cpp

std::ostream &operator<<(std::ostream &OS,
   return 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,
+static_assert(!std::is_assignable_v<StringRef &, std::string>,
               "Assigning from prvalue std::string");
-static_assert(
-    !std::is_assignable<StringRef&, std::string &&>::value,
+static_assert(!std::is_assignable_v<StringRef &, std::string &&>,
               "Assigning from xvalue std::string");
-static_assert(
-    std::is_assignable<StringRef&, std::string &>::value,
+static_assert(std::is_assignable_v<StringRef &, std::string &>,
               "Assigning from lvalue std::string");
-static_assert(
-    std::is_assignable<StringRef&, const char *>::value,
+static_assert(std::is_assignable_v<StringRef &, const char *>,
               "Assigning from prvalue C string");
-static_assert(
-    std::is_assignable<StringRef&, const char * &&>::value,
+static_assert(std::is_assignable_v<StringRef &, const char *&&>,
               "Assigning from xvalue C string");
-static_assert(
-    std::is_assignable<StringRef&, const char * &>::value,
+static_assert(std::is_assignable_v<StringRef &, const char *&>,
               "Assigning from lvalue C string");
 
 namespace {
 TEST(StringRefTest, Construction) {
   EXPECT_EQ("", StringRef());
   EXPECT_EQ("hello", StringRef("hello"));
   EXPECT_EQ("hello", StringRef("hello world", 5));
   EXPECT_EQ("hello", StringRef(std::string("hello")));
   EXPECT_EQ("hello", StringRef(std::string_view("hello")));

 TEST(StringRefTest, LFCRLineEnding) {
   constexpr StringRef Cases[] = {"\n\rDoggo\n\rPupper", "Floofer\n\r",
                                  "Woofer\n\rSubWoofer\n"};
   EXPECT_EQ(StringRef("\n\r"), Cases[0].detectEOL());
   EXPECT_EQ(StringRef("\n\r"), Cases[1].detectEOL());
   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

llvm/unittests/ADT/TypeTraitsTest.cpp

 //===----------------------------------------------------------------------===//
 // function_traits
 //===----------------------------------------------------------------------===//
 
 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");
 };
 
 /// Test function pointers.
 using FuncType = bool (*)(const int &);
 struct CheckFunctionPointer : CheckFunctionTraits<FuncType> {};

llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp

TEST_F(BlockFrequencyInfoTest, Basic) {
   SmallPtrSet<BasicBlock *, 4> BlocksToScale({BB1, BB2});
   BFI.setBlockFreqAndScale(&BB0, BB0Freq * 2, BlocksToScale);
   EXPECT_EQ(BFI.getBlockFreq(&BB0).getFrequency(), 2 * BB0Freq);
   EXPECT_EQ(BFI.getBlockFreq(BB1).getFrequency(), 2 * BB1Freq);
   EXPECT_EQ(BFI.getBlockFreq(BB2).getFrequency(), 2 * BB2Freq);
   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
 } // end namespace llvm

llvm/unittests/Analysis/CallGraphTest.cpp

 template <typename Ty> void canSpecializeGraphTraitsIterators(Ty *G) {
   typedef typename GraphTraits<Ty *>::NodeRef NodeRef;
 
   auto I = GraphTraits<Ty *>::nodes_begin(G);
   auto E = GraphTraits<Ty *>::nodes_end(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);
 
   auto S = GraphTraits<NodeRef>::child_begin(N);
   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");
 }
 
 TEST(CallGraphTest, GraphTraitsSpecialization) {
   LLVMContext Context;
   Module M("", Context);
   CallGraph CG(M);
 

llvm/unittests/Bitstream/BitstreamReaderTest.cpp

TEST(BitstreamReaderTest, shortRead) {
   for (unsigned I = 1; I != 8; ++I) {
     SimpleBitstreamCursor Cursor(ArrayRef<uint8_t>(Bytes, I));
     Expected<SimpleBitstreamCursor::word_t> MaybeRead = Cursor.Read(8);
     ASSERT_TRUE((bool)MaybeRead);
     EXPECT_EQ(8ull, MaybeRead.get());
   }
 }
 
-static_assert(std::is_trivially_copyable<BitCodeAbbrevOp>::value,
+static_assert(std::is_trivially_copyable_v<BitCodeAbbrevOp>,
               "trivially copyable");
 
 } // end anonymous namespace

llvm/unittests/CodeGen/MachineInstrBundleIteratorTest.cpp

TEST(MachineInstrBundleIteratorTest, ReverseConstructor) {
 
   // Check const iterator constructors.
   EXPECT_EQ(cbegin(), const_iterator(rend()));
   EXPECT_EQ(cbegin(), const_iterator(crend()));
   EXPECT_EQ(crbegin(), const_reverse_iterator(end()));
   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<const_iterator, const_reverse_iterator>::value,
+  static_assert(!std::is_convertible_v<const_iterator, const_reverse_iterator>,
                 "unexpected implicit conversion");
-  static_assert(
-      !std::is_convertible<const_reverse_iterator, const_iterator>::value,
+  static_assert(!std::is_convertible_v<const_reverse_iterator, const_iterator>,
                 "unexpected implicit conversion");
 }
 
 } // end namespace

llvm/unittests/CodeGen/MachineInstrTest.cpp

TEST(MachineInstrBuilder, BuildMI) {
   EXPECT_THAT(BuildMI(*MBB, MBB->end(), MIMD, MCID), HasMIMetadata(MIMD));
   EXPECT_THAT(BuildMI(*MBB, MBB->end(), MIMD, MCID), HasMIMetadata(MIMD));
   EXPECT_THAT(BuildMI(*MBB, MBB->instr_end(), MIMD, MCID), HasMIMetadata(MIMD));
   EXPECT_THAT(BuildMI(*MBB, *MBB->begin(), MIMD, MCID), HasMIMetadata(MIMD));
   EXPECT_THAT(BuildMI(*MBB, &*MBB->begin(), MIMD, MCID), HasMIMetadata(MIMD));
   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

llvm/unittests/CodeGen/TypeTraitsTest.cpp

 #include "llvm/CodeGen/SlotIndexes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "gtest/gtest.h"
 #include <type_traits>
 
 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
 

llvm/unittests/ExecutionEngine/Orc/SimplePackedSerializationTest.cpp

static void spsSerializationRoundTrip(const T &Value) {
 
   EXPECT_EQ(Value, DSValue)
       << "Incorrect value after serialization/deserialization round-trip";
 }
 
 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());
   }
   spsSerializationRoundTrip<T, T>(std::numeric_limits<T>::max());
 }
 
 TEST(SimplePackedSerializationTest, BoolSerialization) {
   spsSerializationRoundTrip<bool, bool>(true);

llvm/unittests/IR/CFGBuilder.cpp

TEST(CFGBuilder, Rebuild) {
   EXPECT_EQ(i, NumUpdates);
 
   EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("entry")->getTerminator()));
   EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("a")->getTerminator()));
   EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("c")->getTerminator()));
   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");

llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp

 using namespace llvm;
 
 namespace {
 const auto CFGInsert = CFGBuilder::ActionKind::Insert;
 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>;
 const auto Insert = DominatorTree::Insert;
 const auto Delete = DominatorTree::Delete;
 
 std::vector<DomUpdate> ToDomUpdates(CFGBuilder &B,
                                     std::vector<CFGBuilder::Update> &In) {

llvm/unittests/IR/PassBuilderCallbacksTest.cpp

void ignoreNonMockPassInstrumentation(StringRef IRName) {
     EXPECT_CALL(*this,
                 runAfterAnalysis(Not(HasNameRegex("Mock")), HasName(IRName)))
         .Times(AnyNumber());
   }
 };
 
 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;
 
 /// This test fixture is shared between all the actual tests below and
 /// takes care of setting up appropriate defaults.
 ///
 /// The template specialization serves to extract the IRUnit and AM types from
 /// the given PassManagerT.

llvm/unittests/IR/ValueMapTest.cpp

TYPED_TEST(ValueMapTest, OperationsWork) {
   Elems.push_back(std::make_pair(this->BitcastV.get(), 2));
   VM.insert(Elems.begin(), Elems.end());
   EXPECT_EQ(1, VM.lookup(this->AddV.get()));
   EXPECT_EQ(2, VM.lookup(this->BitcastV.get()));
 }
 
 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) {
   ValueMap<TypeParam*, int> VM;
   VM[this->BitcastV.get()] = 2;
   VM[this->AddV.get()] = 3;
   size_t size = 0;
   for (typename ValueMap<TypeParam*, int>::iterator I = VM.begin(), E = VM.end();

llvm/unittests/Support/Casting.cpp

template <> struct CastInfo<T4, T3> {
   }
 };
 
 } // namespace llvm
 
 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 {
 
 const foo *null_foo = nullptr;
 
 bar B;
 extern bar &B1;
TEST(CastingTest, cast) {
   // Can't pass null pointer to cast<>.
   // foo *F7 = cast<foo>(fub());
   // EXPECT_EQ(F7, null_foo);
   foo *F8 = B1.baz();
   EXPECT_NE(F8, null_foo);
 
   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();
 }
 
 TEST(CastingTest, cast_or_null) {
   const foo *F11 = cast_or_null<foo>(B2);
   EXPECT_NE(F11, null_foo);

llvm/unittests/Support/ErrorOrTest.cpp

TEST(ErrorOr, ImplicitConversionNoAmbiguity) {
   EXPECT_FALSE(x6);
   EXPECT_FALSE(x7);
   EXPECT_FALSE(x8);
 }
 
 // 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 *> &&>,
 } // end anon namespace

llvm/unittests/Support/ScaledNumberTest.cpp

TEST(ScaledNumberHelpersTest, arithmeticOperators) {
   EXPECT_EQ(ScaledNumber<uint64_t>(1, 4), ScaledNumber<uint64_t>(1, 3) << 1);
 }
 
 TEST(ScaledNumberHelpersTest, toIntBug) {
   ScaledNumber<uint32_t> n(1, 0);
   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

llvm/unittests/Support/ThreadLocalTest.cpp

 
 struct S {
   int i;
 };
 
 TEST_F(ThreadLocalTest, Basics) {
   ThreadLocal<const S> x;
 
-  static_assert(
-      std::is_const<std::remove_pointer<decltype(x.get())>::type>::value,
+  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());
 
   S s;
   x.set(&s);
   EXPECT_EQ(&s, x.get());
 
   x.erase();
   EXPECT_EQ(nullptr, x.get());
 
   ThreadLocal<S> y;
 
-  static_assert(
-      !std::is_const<std::remove_pointer<decltype(y.get())>::type>::value,
+  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());
 
   y.set(&s);
   EXPECT_EQ(&s, y.get());
 
   y.erase();
   EXPECT_EQ(nullptr, y.get());
 }
 
 }