From 6b6a542c1d819b47d26e462ac14b89a951615beb Mon Sep 17 00:00:00 2001
From: Jonas Devlieghere <jonas@devlieghere.com>
Date: Mon, 17 Apr 2023 11:26:56 -0700
Subject: [PATCH] Revert "[ADT] Apply fixes from modernize-type-traits (NFC)"

This reverts commit 9395cf063a013003704118deccf7633533170a5b because it
breaks the modules build:

  STLFunctionalExtras.h:54:3: error:
  'llvm::function_ref<std::__1::optional<std::__1::basic_string<char>>
  (llvm::StringRef, llvm::StringRef)>::function_ref' from module
  'LLVM_Utils.ADT.STLFunctionalExtras' is not present in definition of
  'llvm::function_ref<std::__1::optional<std::__1::basic_string<char>>
  (llvm::StringRef, llvm::StringRef)>' in module
  'LLVM_Utils.ADT.STLFunctionalExtras'

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/53806/
---
 llvm/include/llvm/ADT/APFloat.h             | 10 ++---
 llvm/include/llvm/ADT/Any.h                 |  4 +-
 llvm/include/llvm/ADT/ArrayRef.h            | 14 +++----
 llvm/include/llvm/ADT/Bitfields.h           | 21 +++++-----
 llvm/include/llvm/ADT/CoalescingBitVector.h |  2 +-
 llvm/include/llvm/ADT/DenseMap.h            |  2 +-
 llvm/include/llvm/ADT/FoldingSet.h          |  2 +-
 llvm/include/llvm/ADT/FunctionExtras.h      | 13 ++++---
 llvm/include/llvm/ADT/Hashing.h             | 10 ++---
 llvm/include/llvm/ADT/IntrusiveRefCntPtr.h  |  4 +-
 llvm/include/llvm/ADT/PointerIntPair.h      |  6 +--
 llvm/include/llvm/ADT/PriorityWorklist.h    |  2 +-
 llvm/include/llvm/ADT/STLExtras.h           | 60 ++++++++++++++---------------
 llvm/include/llvm/ADT/STLFunctionalExtras.h | 12 +++---
 llvm/include/llvm/ADT/Sequence.h            | 34 +++++++++-------
 llvm/include/llvm/ADT/SmallVector.h         | 27 ++++++-------
 llvm/include/llvm/ADT/StringRef.h           |  2 +-
 llvm/include/llvm/ADT/TinyPtrVector.h       |  7 ++--
 llvm/include/llvm/ADT/bit.h                 | 11 +++---
 llvm/include/llvm/ADT/iterator.h            | 16 ++++----
 20 files changed, 134 insertions(+), 125 deletions(-)

diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h
index 80d9d21..f5eb9f3 100644
--- a/llvm/include/llvm/ADT/APFloat.h
+++ b/llvm/include/llvm/ADT/APFloat.h
@@ -757,7 +757,7 @@ class APFloat : public APFloatBase {
   typedef detail::IEEEFloat IEEEFloat;
   typedef detail::DoubleAPFloat DoubleAPFloat;
 
-  static_assert(std::is_standard_layout_v<IEEEFloat>);
+  static_assert(std::is_standard_layout<IEEEFloat>::value);
 
   union Storage {
     const fltSemantics *semantics;
@@ -849,9 +849,9 @@ class APFloat : public APFloatBase {
   } U;
 
   template <typename T> static bool usesLayout(const fltSemantics &Semantics) {
-    static_assert(std::is_same_v<T, IEEEFloat> ||
-                  std::is_same_v<T, DoubleAPFloat>);
-    if (std::is_same_v<T, DoubleAPFloat>) {
+    static_assert(std::is_same<T, IEEEFloat>::value ||
+                  std::is_same<T, DoubleAPFloat>::value);
+    if (std::is_same<T, DoubleAPFloat>::value) {
       return &Semantics == &PPCDoubleDouble();
     }
     return &Semantics != &PPCDoubleDouble();
@@ -912,7 +912,7 @@ public:
   APFloat(const fltSemantics &Semantics, StringRef S);
   APFloat(const fltSemantics &Semantics, integerPart I) : U(Semantics, I) {}
   template <typename T,
-            typename = std::enable_if_t<std::is_floating_point_v<T>>>
+            typename = std::enable_if_t<std::is_floating_point<T>::value>>
   APFloat(const fltSemantics &Semantics, T V) = delete;
   // TODO: Remove this constructor. This isn't faster than the first one.
   APFloat(const fltSemantics &Semantics, uninitializedTag)
diff --git a/llvm/include/llvm/ADT/Any.h b/llvm/include/llvm/ADT/Any.h
index 4231427..acb7101a 100644
--- a/llvm/include/llvm/ADT/Any.h
+++ b/llvm/include/llvm/ADT/Any.h
@@ -70,7 +70,7 @@ public:
   // instead.
   template <typename T,
             std::enable_if_t<
-                std::conjunction_v<
+                std::conjunction<
                     std::negation<std::is_same<std::decay_t<T>, Any>>,
                     // We also disable this overload when an `Any` object can be
                     // converted to the parameter type because in that case,
@@ -83,7 +83,7 @@ public:
                     // adopting it to work-around usage of `Any` with types that
                     // need to be implicitly convertible from an `Any`.
                     std::negation<std::is_convertible<Any, std::decay_t<T>>>,
-                    std::is_copy_constructible<std::decay_t<T>>>,
+                    std::is_copy_constructible<std::decay_t<T>>>::value,
                 int> = 0>
   Any(T &&Value) {
     Storage =
diff --git a/llvm/include/llvm/ADT/ArrayRef.h b/llvm/include/llvm/ADT/ArrayRef.h
index ebcf087..a25cf1c 100644
--- a/llvm/include/llvm/ADT/ArrayRef.h
+++ b/llvm/include/llvm/ADT/ArrayRef.h
@@ -122,8 +122,8 @@ namespace llvm {
     /// ensure that only ArrayRefs of pointers can be converted.
     template <typename U>
     ArrayRef(const ArrayRef<U *> &A,
-             std::enable_if_t<std::is_convertible_v<U *const *, T const *>> * =
-                 nullptr)
+             std::enable_if_t<std::is_convertible<U *const *, T const *>::value>
+                 * = nullptr)
         : Data(A.data()), Length(A.size()) {}
 
     /// Construct an ArrayRef<const T*> from a SmallVector<T*>. This is
@@ -132,7 +132,7 @@ namespace llvm {
     template <typename U, typename DummyT>
     /*implicit*/ ArrayRef(
         const SmallVectorTemplateCommon<U *, DummyT> &Vec,
-        std::enable_if_t<std::is_convertible_v<U *const *, T const *>> * =
+        std::enable_if_t<std::is_convertible<U *const *, T const *>::value> * =
             nullptr)
         : Data(Vec.data()), Length(Vec.size()) {}
 
@@ -140,8 +140,8 @@ namespace llvm {
     /// to ensure that only vectors of pointers can be converted.
     template <typename U, typename A>
     ArrayRef(const std::vector<U *, A> &Vec,
-             std::enable_if_t<std::is_convertible_v<U *const *, T const *>> * =
-                 nullptr)
+             std::enable_if_t<std::is_convertible<U *const *, T const *>::value>
+                 * = nullptr)
         : Data(Vec.data()), Length(Vec.size()) {}
 
     /// @}
@@ -261,7 +261,7 @@ namespace llvm {
     /// The declaration here is extra complicated so that "arrayRef = {}"
     /// continues to select the move assignment operator.
     template <typename U>
-    std::enable_if_t<std::is_same_v<U, T>, ArrayRef<T>> &
+    std::enable_if_t<std::is_same<U, T>::value, ArrayRef<T>> &
     operator=(U &&Temporary) = delete;
 
     /// Disallow accidental assignment from a temporary.
@@ -269,7 +269,7 @@ namespace llvm {
     /// The declaration here is extra complicated so that "arrayRef = {}"
     /// continues to select the move assignment operator.
     template <typename U>
-    std::enable_if_t<std::is_same_v<U, T>, ArrayRef<T>> &
+    std::enable_if_t<std::is_same<U, T>::value, ArrayRef<T>> &
     operator=(std::initializer_list<U>) = delete;
 
     /// @}
diff --git a/llvm/include/llvm/ADT/Bitfields.h b/llvm/include/llvm/ADT/Bitfields.h
index 1fd9346..4064d71 100644
--- a/llvm/include/llvm/ADT/Bitfields.h
+++ b/llvm/include/llvm/ADT/Bitfields.h
@@ -117,9 +117,9 @@ template <typename T, unsigned Bits> struct BitPatterns {
 /// type so it can be packed and unpacked into a `bits` sized integer,
 /// `Compressor` is specialized on signed-ness so no runtime cost is incurred.
 /// The `pack` method also checks that the passed in `UserValue` is valid.
-template <typename T, unsigned Bits, bool = std::is_unsigned_v<T>>
+template <typename T, unsigned Bits, bool = std::is_unsigned<T>::value>
 struct Compressor {
-  static_assert(std::is_unsigned_v<T>, "T must be unsigned");
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   using BP = BitPatterns<T, Bits>;
 
   static T pack(T UserValue, T UserMaxValue) {
@@ -132,7 +132,7 @@ struct Compressor {
 };
 
 template <typename T, unsigned Bits> struct Compressor<T, Bits, false> {
-  static_assert(std::is_signed_v<T>, "T must be signed");
+  static_assert(std::is_signed<T>::value, "T must be signed");
   using BP = BitPatterns<T, Bits>;
 
   static T pack(T UserValue, T UserMaxValue) {
@@ -154,7 +154,8 @@ template <typename T, unsigned Bits> struct Compressor<T, Bits, false> {
 /// Impl is where Bifield description and Storage are put together to interact
 /// with values.
 template <typename Bitfield, typename StorageType> struct Impl {
-  static_assert(std::is_unsigned_v<StorageType>, "Storage must be unsigned");
+  static_assert(std::is_unsigned<StorageType>::value,
+                "Storage must be unsigned");
   using IntegerType = typename Bitfield::IntegerType;
   using C = Compressor<IntegerType, Bitfield::Bits>;
   using BP = BitPatterns<StorageType, Bitfield::Bits>;
@@ -192,7 +193,8 @@ template <typename Bitfield, typename StorageType> struct Impl {
 /// consistent semantics, this excludes typed enums and `bool` that are replaced
 /// with their unsigned counterparts. The correct type is restored in the public
 /// API.
-template <typename T, bool = std::is_enum_v<T>> struct ResolveUnderlyingType {
+template <typename T, bool = std::is_enum<T>::value>
+struct ResolveUnderlyingType {
   using type = std::underlying_type_t<T>;
 };
 template <typename T> struct ResolveUnderlyingType<T, false> {
@@ -215,7 +217,7 @@ struct Bitfield {
   /// \tparam Size      The size of the field.
   /// \tparam MaxValue  For enums the maximum enum allowed.
   template <typename T, unsigned Offset, unsigned Size,
-            T MaxValue = std::is_enum_v<T>
+            T MaxValue = std::is_enum<T>::value
                              ? T(0) // coupled with static_assert below
                              : std::numeric_limits<T>::max()>
   struct Element {
@@ -234,11 +236,12 @@ struct Bitfield {
     static_assert(Bits > 0, "Bits must be non zero");
     static constexpr size_t TypeBits = sizeof(IntegerType) * CHAR_BIT;
     static_assert(Bits <= TypeBits, "Bits may not be greater than T size");
-    static_assert(!std::is_enum_v<T> || MaxValue != T(0),
+    static_assert(!std::is_enum<T>::value || MaxValue != T(0),
                   "Enum Bitfields must provide a MaxValue");
-    static_assert(!std::is_enum_v<T> || std::is_unsigned_v<IntegerType>,
+    static_assert(!std::is_enum<T>::value ||
+                      std::is_unsigned<IntegerType>::value,
                   "Enum must be unsigned");
-    static_assert(std::is_integral_v<IntegerType> &&
+    static_assert(std::is_integral<IntegerType>::value &&
                       std::numeric_limits<IntegerType>::is_integer,
                   "IntegerType must be an integer type");
 
diff --git a/llvm/include/llvm/ADT/CoalescingBitVector.h b/llvm/include/llvm/ADT/CoalescingBitVector.h
index 54fd156..4940bc1 100644
--- a/llvm/include/llvm/ADT/CoalescingBitVector.h
+++ b/llvm/include/llvm/ADT/CoalescingBitVector.h
@@ -36,7 +36,7 @@ namespace llvm {
 ///
 /// \tparam IndexT - The type of the index into the bitvector.
 template <typename IndexT> class CoalescingBitVector {
-  static_assert(std::is_unsigned_v<IndexT>,
+  static_assert(std::is_unsigned<IndexT>::value,
                 "Index must be an unsigned integer.");
 
   using ThisT = CoalescingBitVector<IndexT>;
diff --git a/llvm/include/llvm/ADT/DenseMap.h b/llvm/include/llvm/ADT/DenseMap.h
index 87c82b0..8a680c0 100644
--- a/llvm/include/llvm/ADT/DenseMap.h
+++ b/llvm/include/llvm/ADT/DenseMap.h
@@ -464,7 +464,7 @@ protected:
   }
 
   static const KeyT getEmptyKey() {
-    static_assert(std::is_base_of_v<DenseMapBase, DerivedT>,
+    static_assert(std::is_base_of<DenseMapBase, DerivedT>::value,
                   "Must pass the derived type to this template!");
     return KeyInfoT::getEmptyKey();
   }
diff --git a/llvm/include/llvm/ADT/FoldingSet.h b/llvm/include/llvm/ADT/FoldingSet.h
index 0ce6643..2376689 100644
--- a/llvm/include/llvm/ADT/FoldingSet.h
+++ b/llvm/include/llvm/ADT/FoldingSet.h
@@ -830,7 +830,7 @@ struct FoldingSetTrait<std::pair<T1, T2>> {
 };
 
 template <typename T>
-struct FoldingSetTrait<T, std::enable_if_t<std::is_enum_v<T>>> {
+struct FoldingSetTrait<T, std::enable_if_t<std::is_enum<T>::value>> {
   static void Profile(const T &X, FoldingSetNodeID &ID) {
     ID.AddInteger(static_cast<std::underlying_type_t<T>>(X));
   }
diff --git a/llvm/include/llvm/ADT/FunctionExtras.h b/llvm/include/llvm/ADT/FunctionExtras.h
index 9eda865..8f04277 100644
--- a/llvm/include/llvm/ADT/FunctionExtras.h
+++ b/llvm/include/llvm/ADT/FunctionExtras.h
@@ -60,20 +60,21 @@ namespace detail {
 template <typename T>
 using EnableIfTrivial =
     std::enable_if_t<llvm::is_trivially_move_constructible<T>::value &&
-                     std::is_trivially_destructible_v<T>>;
+                     std::is_trivially_destructible<T>::value>;
 template <typename CallableT, typename ThisT>
 using EnableUnlessSameType =
-    std::enable_if_t<!std::is_same_v<remove_cvref_t<CallableT>, ThisT>>;
+    std::enable_if_t<!std::is_same<remove_cvref_t<CallableT>, ThisT>::value>;
 template <typename CallableT, typename Ret, typename... Params>
-using EnableIfCallable = std::enable_if_t<std::disjunction_v<
+using EnableIfCallable = std::enable_if_t<std::disjunction<
     std::is_void<Ret>,
     std::is_same<decltype(std::declval<CallableT>()(std::declval<Params>()...)),
                  Ret>,
     std::is_same<const decltype(std::declval<CallableT>()(
                      std::declval<Params>()...)),
                  Ret>,
-    std::is_convertible<
-        decltype(std::declval<CallableT>()(std::declval<Params>()...)), Ret>>>;
+    std::is_convertible<decltype(std::declval<CallableT>()(
+                            std::declval<Params>()...)),
+                        Ret>>::value>;
 
 template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
 protected:
@@ -96,7 +97,7 @@ protected:
   // It doesn't have to be exact though, and in one way it is more strict
   // because we want to still be able to observe either moves *or* copies.
   template <typename T> struct AdjustedParamTBase {
-    static_assert(!std::is_reference_v<T>,
+    static_assert(!std::is_reference<T>::value,
                   "references should be handled by template specialization");
     using type = std::conditional_t<
         llvm::is_trivially_copy_constructible<T>::value &&
diff --git a/llvm/include/llvm/ADT/Hashing.h b/llvm/include/llvm/ADT/Hashing.h
index dc03a11..ef98310 100644
--- a/llvm/include/llvm/ADT/Hashing.h
+++ b/llvm/include/llvm/ADT/Hashing.h
@@ -355,12 +355,10 @@ inline uint64_t get_execution_seed() {
 // for equality. For all the platforms we care about, this holds for integers
 // and pointers, but there are platforms where it doesn't and we would like to
 // support user-defined types which happen to satisfy this property.
-template <typename T>
-struct is_hashable_data
-    : std::integral_constant<bool, ((is_integral_or_enum<T>::value ||
-                                     std::is_pointer_v<T>)&&64 %
-                                        sizeof(T) ==
-                                    0)> {};
+template <typename T> struct is_hashable_data
+  : std::integral_constant<bool, ((is_integral_or_enum<T>::value ||
+                                   std::is_pointer<T>::value) &&
+                                  64 % sizeof(T) == 0)> {};
 
 // Special case std::pair to detect when both types are viable and when there
 // is no alignment-derived padding in the pair. This is a bit of a lie because
diff --git a/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h b/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h
index 40abf0a..e41eb06 100644
--- a/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h
+++ b/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h
@@ -177,13 +177,13 @@ public:
   IntrusiveRefCntPtr(IntrusiveRefCntPtr &&S) : Obj(S.Obj) { S.Obj = nullptr; }
 
   template <class X,
-            std::enable_if_t<std::is_convertible_v<X *, T *>, bool> = true>
+            std::enable_if_t<std::is_convertible<X *, T *>::value, bool> = true>
   IntrusiveRefCntPtr(IntrusiveRefCntPtr<X> S) : Obj(S.get()) {
     S.Obj = nullptr;
   }
 
   template <class X,
-            std::enable_if_t<std::is_convertible_v<X *, T *>, bool> = true>
+            std::enable_if_t<std::is_convertible<X *, T *>::value, bool> = true>
   IntrusiveRefCntPtr(std::unique_ptr<X> S) : Obj(S.release()) {
     retain();
   }
diff --git a/llvm/include/llvm/ADT/PointerIntPair.h b/llvm/include/llvm/ADT/PointerIntPair.h
index 5b6cd3e..f73f5bc 100644
--- a/llvm/include/llvm/ADT/PointerIntPair.h
+++ b/llvm/include/llvm/ADT/PointerIntPair.h
@@ -30,9 +30,9 @@ template <typename Ptr> struct PunnedPointer {
 
   // Asserts that allow us to let the compiler implement the destructor and
   // copy/move constructors
-  static_assert(std::is_trivially_destructible_v<Ptr>, "");
-  static_assert(std::is_trivially_copy_constructible_v<Ptr>, "");
-  static_assert(std::is_trivially_move_constructible_v<Ptr>, "");
+  static_assert(std::is_trivially_destructible<Ptr>::value, "");
+  static_assert(std::is_trivially_copy_constructible<Ptr>::value, "");
+  static_assert(std::is_trivially_move_constructible<Ptr>::value, "");
 
   explicit constexpr PunnedPointer(intptr_t i = 0) { *this = i; }
 
diff --git a/llvm/include/llvm/ADT/PriorityWorklist.h b/llvm/include/llvm/ADT/PriorityWorklist.h
index 7c76744..2b6510f 100644
--- a/llvm/include/llvm/ADT/PriorityWorklist.h
+++ b/llvm/include/llvm/ADT/PriorityWorklist.h
@@ -109,7 +109,7 @@ public:
 
   /// Insert a sequence of new elements into the PriorityWorklist.
   template <typename SequenceT>
-  std::enable_if_t<!std::is_convertible_v<SequenceT, T>>
+  std::enable_if_t<!std::is_convertible<SequenceT, T>::value>
   insert(SequenceT &&Input) {
     if (std::begin(Input) == std::end(Input))
       // Nothing to do for an empty input sequence.
diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
index f683a21..6475ac7 100644
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -166,7 +166,7 @@ using is_detected = typename detail::detector<void, Op, Args...>::value_t;
 ///   * To access the number of arguments: Traits::num_args
 ///   * To access the type of an argument: Traits::arg_t<Index>
 ///   * To access the type of the result:  Traits::result_t
-template <typename T, bool isClass = std::is_class_v<T>>
+template <typename T, bool isClass = std::is_class<T>::value>
 struct function_traits : public function_traits<decltype(&T::operator())> {};
 
 /// Overload for class function types.
@@ -265,9 +265,9 @@ using TypeAtIndex = std::tuple_element_t<I, std::tuple<Ts...>>;
 /// Helper which adds two underlying types of enumeration type.
 /// Implicit conversion to a common type is accepted.
 template <typename EnumTy1, typename EnumTy2,
-          typename UT1 = std::enable_if_t<std::is_enum_v<EnumTy1>,
+          typename UT1 = std::enable_if_t<std::is_enum<EnumTy1>::value,
                                           std::underlying_type_t<EnumTy1>>,
-          typename UT2 = std::enable_if_t<std::is_enum_v<EnumTy2>,
+          typename UT2 = std::enable_if_t<std::is_enum<EnumTy2>::value,
                                           std::underlying_type_t<EnumTy2>>>
 constexpr auto addEnumValues(EnumTy1 LHS, EnumTy2 RHS) {
   return static_cast<UT1>(LHS) + static_cast<UT2>(RHS);
@@ -638,9 +638,9 @@ template <> struct fwd_or_bidi_tag_impl<true> {
 /// of \p IterT does not derive from bidirectional_iterator_tag, and to
 /// bidirectional_iterator_tag otherwise.
 template <typename IterT> struct fwd_or_bidi_tag {
-  using type = typename fwd_or_bidi_tag_impl<std::is_base_of_v<
+  using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
       std::bidirectional_iterator_tag,
-      typename std::iterator_traits<IterT>::iterator_category>>::type;
+      typename std::iterator_traits<IterT>::iterator_category>::value>::type;
 };
 
 } // namespace detail
@@ -1421,9 +1421,8 @@ public:
   }
 
   /// Allow conversion to any type accepting an iterator_range.
-  template <typename RangeT,
-            typename = std::enable_if_t<
-                std::is_constructible_v<RangeT, iterator_range<iterator>>>>
+  template <typename RangeT, typename = std::enable_if_t<std::is_constructible<
+                                 RangeT, iterator_range<iterator>>::value>>
   operator RangeT() const {
     return RangeT(iterator_range<iterator>(*this));
   }
@@ -1501,7 +1500,7 @@ namespace detail {
 /// always be a reference, to avoid returning a reference to a temporary.
 template <typename EltTy, typename FirstTy> class first_or_second_type {
 public:
-  using type = std::conditional_t<std::is_reference_v<EltTy>, FirstTy,
+  using type = std::conditional_t<std::is_reference<EltTy>::value, FirstTy,
                                   std::remove_reference_t<FirstTy>>;
 };
 } // end namespace detail
@@ -1775,13 +1774,12 @@ inline void sort(Container &&C, Compare Comp) {
 /// Get the size of a range. This is a wrapper function around std::distance
 /// which is only enabled when the operation is O(1).
 template <typename R>
-auto size(
-    R &&Range,
-    std::enable_if_t<
-        std::is_base_of_v<std::random_access_iterator_tag,
-                          typename std::iterator_traits<
-                              decltype(Range.begin())>::iterator_category>,
-        void> * = nullptr) {
+auto size(R &&Range,
+          std::enable_if_t<
+              std::is_base_of<std::random_access_iterator_tag,
+                              typename std::iterator_traits<decltype(
+                                  Range.begin())>::iterator_category>::value,
+              void> * = nullptr) {
   return std::distance(Range.begin(), Range.end());
 }
 
@@ -2169,11 +2167,11 @@ void replace(Container &Cont, typename Container::iterator ContIt,
 ///              [&](StringRef name) { os << name; },
 ///              [&] { os << ", "; });
 /// \endcode
-template <
-    typename ForwardIterator, typename UnaryFunctor, typename NullaryFunctor,
-    typename =
-        std::enable_if_t<!std::is_constructible_v<StringRef, UnaryFunctor> &&
-                         !std::is_constructible_v<StringRef, NullaryFunctor>>>
+template <typename ForwardIterator, typename UnaryFunctor,
+          typename NullaryFunctor,
+          typename = std::enable_if_t<
+              !std::is_constructible<StringRef, UnaryFunctor>::value &&
+              !std::is_constructible<StringRef, NullaryFunctor>::value>>
 inline void interleave(ForwardIterator begin, ForwardIterator end,
                        UnaryFunctor each_fn, NullaryFunctor between_fn) {
   if (begin == end)
@@ -2188,8 +2186,8 @@ inline void interleave(ForwardIterator begin, ForwardIterator end,
 
 template <typename Container, typename UnaryFunctor, typename NullaryFunctor,
           typename = std::enable_if_t<
-              !std::is_constructible_v<StringRef, UnaryFunctor> &&
-              !std::is_constructible_v<StringRef, NullaryFunctor>>>
+              !std::is_constructible<StringRef, UnaryFunctor>::value &&
+              !std::is_constructible<StringRef, NullaryFunctor>::value>>
 inline void interleave(const Container &c, UnaryFunctor each_fn,
                        NullaryFunctor between_fn) {
   interleave(c.begin(), c.end(), each_fn, between_fn);
@@ -2492,11 +2490,11 @@ bool hasNItems(
     IterTy &&Begin, IterTy &&End, unsigned N,
     Pred &&ShouldBeCounted =
         [](const decltype(*std::declval<IterTy>()) &) { return true; },
-    std::enable_if_t<!std::is_base_of_v<
-                         std::random_access_iterator_tag,
+    std::enable_if_t<
+        !std::is_base_of<std::random_access_iterator_tag,
                          typename std::iterator_traits<std::remove_reference_t<
-                             decltype(Begin)>>::iterator_category>,
-                     void> * = nullptr) {
+                             decltype(Begin)>>::iterator_category>::value,
+        void> * = nullptr) {
   for (; N; ++Begin) {
     if (Begin == End)
       return false; // Too few.
@@ -2517,11 +2515,11 @@ bool hasNItemsOrMore(
     IterTy &&Begin, IterTy &&End, unsigned N,
     Pred &&ShouldBeCounted =
         [](const decltype(*std::declval<IterTy>()) &) { return true; },
-    std::enable_if_t<!std::is_base_of_v<
-                         std::random_access_iterator_tag,
+    std::enable_if_t<
+        !std::is_base_of<std::random_access_iterator_tag,
                          typename std::iterator_traits<std::remove_reference_t<
-                             decltype(Begin)>>::iterator_category>,
-                     void> * = nullptr) {
+                             decltype(Begin)>>::iterator_category>::value,
+        void> * = nullptr) {
   for (; N; ++Begin) {
     if (Begin == End)
       return false; // Too few.
diff --git a/llvm/include/llvm/ADT/STLFunctionalExtras.h b/llvm/include/llvm/ADT/STLFunctionalExtras.h
index f3044fe..dd7fc6d 100644
--- a/llvm/include/llvm/ADT/STLFunctionalExtras.h
+++ b/llvm/include/llvm/ADT/STLFunctionalExtras.h
@@ -54,13 +54,13 @@ public:
   function_ref(
       Callable &&callable,
       // This is not the copy-constructor.
-      std::enable_if_t<!std::is_same_v<remove_cvref_t<Callable>, function_ref>>
-          * = nullptr,
+      std::enable_if_t<!std::is_same<remove_cvref_t<Callable>,
+                                     function_ref>::value> * = nullptr,
       // Functor must be callable and return a suitable type.
-      std::enable_if_t<std::is_void_v<Ret> ||
-                       std::is_convertible_v<decltype(std::declval<Callable>()(
-                                                 std::declval<Params>()...)),
-                                             Ret>> * = nullptr)
+      std::enable_if_t<std::is_void<Ret>::value ||
+                       std::is_convertible<decltype(std::declval<Callable>()(
+                                               std::declval<Params>()...)),
+                                           Ret>::value> * = nullptr)
       : callback(callback_fn<std::remove_reference_t<Callable>>),
         callable(reinterpret_cast<intptr_t>(&callable)) {}
 
diff --git a/llvm/include/llvm/ADT/Sequence.h b/llvm/include/llvm/ADT/Sequence.h
index 9a63552..ddda9a9 100644
--- a/llvm/include/llvm/ADT/Sequence.h
+++ b/llvm/include/llvm/ADT/Sequence.h
@@ -126,7 +126,7 @@ template <typename T, typename U> bool canTypeFitValue(const U Value) {
 struct CheckedInt {
   // Integral constructor, asserts if Value cannot be represented as intmax_t.
   template <typename Integral,
-            std::enable_if_t<std::is_integral_v<Integral>, bool> = 0>
+            std::enable_if_t<std::is_integral<Integral>::value, bool> = 0>
   static CheckedInt from(Integral FromValue) {
     if (!canTypeFitValue<intmax_t>(FromValue))
       assertOutOfBounds();
@@ -136,7 +136,8 @@ struct CheckedInt {
   }
 
   // Enum constructor, asserts if Value cannot be represented as intmax_t.
-  template <typename Enum, std::enable_if_t<std::is_enum_v<Enum>, bool> = 0>
+  template <typename Enum,
+            std::enable_if_t<std::is_enum<Enum>::value, bool> = 0>
   static CheckedInt from(Enum FromValue) {
     using type = std::underlying_type_t<Enum>;
     return from<type>(static_cast<type>(FromValue));
@@ -162,7 +163,7 @@ struct CheckedInt {
 
   // Convert to integral, asserts if Value cannot be represented as Integral.
   template <typename Integral,
-            std::enable_if_t<std::is_integral_v<Integral>, bool> = 0>
+            std::enable_if_t<std::is_integral<Integral>::value, bool> = 0>
   Integral to() const {
     if (!canTypeFitValue<Integral>(Value))
       assertOutOfBounds();
@@ -171,7 +172,8 @@ struct CheckedInt {
 
   // Convert to enum, asserts if Value cannot be represented as Enum's
   // underlying type.
-  template <typename Enum, std::enable_if_t<std::is_enum_v<Enum>, bool> = 0>
+  template <typename Enum,
+            std::enable_if_t<std::is_enum<Enum>::value, bool> = 0>
   Enum to() const {
     using type = std::underlying_type_t<Enum>;
     return Enum(to<type>());
@@ -285,9 +287,9 @@ template <typename T> struct iota_range {
   auto rend() const { return const_reverse_iterator(BeginValue - 1); }
 
 private:
-  static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
+  static_assert(std::is_integral<T>::value || std::is_enum<T>::value,
                 "T must be an integral or enum type");
-  static_assert(std::is_same_v<T, std::remove_cv_t<T>>,
+  static_assert(std::is_same<T, std::remove_cv_t<T>>::value,
                 "T must not be const nor volatile");
 
   iterator BeginValue;
@@ -298,8 +300,8 @@ private:
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX] for
 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX] for reverse
 /// iteration).
-template <typename T, typename = std::enable_if_t<std::is_integral_v<T> &&
-                                                  !std::is_enum_v<T>>>
+template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
+                                                  !std::is_enum<T>::value>>
 auto seq(T Begin, T End) {
   return iota_range<T>(Begin, End, false);
 }
@@ -308,8 +310,8 @@ auto seq(T Begin, T End) {
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX - 1]
 /// for forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
-template <typename T, typename = std::enable_if_t<std::is_integral_v<T> &&
-                                                  !std::is_enum_v<T>>>
+template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
+                                                  !std::is_enum<T>::value>>
 auto seq_inclusive(T Begin, T End) {
   return iota_range<T>(Begin, End, true);
 }
@@ -320,7 +322,8 @@ auto seq_inclusive(T Begin, T End) {
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX] for
 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX] for reverse
 /// iteration).
-template <typename EnumT, typename = std::enable_if_t<std::is_enum_v<EnumT>>>
+template <typename EnumT,
+          typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq(EnumT Begin, EnumT End) {
   static_assert(enum_iteration_traits<EnumT>::is_iterable,
                 "Enum type is not marked as iterable.");
@@ -334,7 +337,8 @@ auto enum_seq(EnumT Begin, EnumT End) {
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX] for
 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX] for reverse
 /// iteration).
-template <typename EnumT, typename = std::enable_if_t<std::is_enum_v<EnumT>>>
+template <typename EnumT,
+          typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq(EnumT Begin, EnumT End, force_iteration_on_noniterable_enum_t) {
   return iota_range<EnumT>(Begin, End, false);
 }
@@ -345,7 +349,8 @@ auto enum_seq(EnumT Begin, EnumT End, force_iteration_on_noniterable_enum_t) {
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX - 1]
 /// for forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
-template <typename EnumT, typename = std::enable_if_t<std::is_enum_v<EnumT>>>
+template <typename EnumT,
+          typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq_inclusive(EnumT Begin, EnumT End) {
   static_assert(enum_iteration_traits<EnumT>::is_iterable,
                 "Enum type is not marked as iterable.");
@@ -359,7 +364,8 @@ auto enum_seq_inclusive(EnumT Begin, EnumT End) {
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX - 1]
 /// for forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
-template <typename EnumT, typename = std::enable_if_t<std::is_enum_v<EnumT>>>
+template <typename EnumT,
+          typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq_inclusive(EnumT Begin, EnumT End,
                         force_iteration_on_noniterable_enum_t) {
   return iota_range<EnumT>(Begin, End, true);
diff --git a/llvm/include/llvm/ADT/SmallVector.h b/llvm/include/llvm/ADT/SmallVector.h
index 31ab184..93d9491 100644
--- a/llvm/include/llvm/ADT/SmallVector.h
+++ b/llvm/include/llvm/ADT/SmallVector.h
@@ -37,10 +37,9 @@ template <typename T> class ArrayRef;
 template <typename IteratorT> class iterator_range;
 
 template <class Iterator>
-using EnableIfConvertibleToInputIterator =
-    std::enable_if_t<std::is_convertible_v<
-        typename std::iterator_traits<Iterator>::iterator_category,
-        std::input_iterator_tag>>;
+using EnableIfConvertibleToInputIterator = std::enable_if_t<std::is_convertible<
+    typename std::iterator_traits<Iterator>::iterator_category,
+    std::input_iterator_tag>::value>;
 
 /// This is all the stuff common to all SmallVectors.
 ///
@@ -208,9 +207,10 @@ protected:
     this->assertSafeToReferenceAfterResize(From, 0);
     this->assertSafeToReferenceAfterResize(To - 1, 0);
   }
-  template <class ItTy,
-            std::enable_if_t<!std::is_same_v<std::remove_const_t<ItTy>, T *>,
-                             bool> = false>
+  template <
+      class ItTy,
+      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
+                       bool> = false>
   void assertSafeToReferenceAfterClear(ItTy, ItTy) {}
 
   /// Check whether any part of the range will be invalidated by growing.
@@ -220,9 +220,10 @@ protected:
     this->assertSafeToAdd(From, To - From);
     this->assertSafeToAdd(To - 1, To - From);
   }
-  template <class ItTy,
-            std::enable_if_t<!std::is_same_v<std::remove_const_t<ItTy>, T *>,
-                             bool> = false>
+  template <
+      class ItTy,
+      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
+                       bool> = false>
   void assertSafeToAddRange(ItTy, ItTy) {}
 
   /// Reserve enough space to add one element, and return the updated element
@@ -327,7 +328,7 @@ public:
 /// trivially assignable.
 template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
                              (is_trivially_move_constructible<T>::value) &&
-                             std::is_trivially_destructible_v<T>>
+                             std::is_trivially_destructible<T>::value>
 class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
   friend class SmallVectorTemplateCommon<T>;
 
@@ -513,7 +514,7 @@ protected:
   template <typename T1, typename T2>
   static void uninitialized_copy(
       T1 *I, T1 *E, T2 *Dest,
-      std::enable_if_t<std::is_same_v<std::remove_const_t<T1>, T2>> * =
+      std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
           nullptr) {
     // Use memcpy for PODs iterated by pointers (which includes SmallVector
     // iterators): std::uninitialized_copy optimizes to memmove, but we can
@@ -1231,7 +1232,7 @@ public:
   }
 
   template <typename U,
-            typename = std::enable_if_t<std::is_convertible_v<U, T>>>
+            typename = std::enable_if_t<std::is_convertible<U, T>::value>>
   explicit SmallVector(ArrayRef<U> A) : SmallVectorImpl<T>(N) {
     this->append(A.begin(), A.end());
   }
diff --git a/llvm/include/llvm/ADT/StringRef.h b/llvm/include/llvm/ADT/StringRef.h
index f672784..868722e 100644
--- a/llvm/include/llvm/ADT/StringRef.h
+++ b/llvm/include/llvm/ADT/StringRef.h
@@ -238,7 +238,7 @@ namespace llvm {
     /// The declaration here is extra complicated so that `stringRef = {}`
     /// and `stringRef = "abc"` continue to select the move assignment operator.
     template <typename T>
-    std::enable_if_t<std::is_same_v<T, std::string>, StringRef> &
+    std::enable_if_t<std::is_same<T, std::string>::value, StringRef> &
     operator=(T &&Str) = delete;
 
     /// @}
diff --git a/llvm/include/llvm/ADT/TinyPtrVector.h b/llvm/include/llvm/ADT/TinyPtrVector.h
index 2caa564..aa87fd6 100644
--- a/llvm/include/llvm/ADT/TinyPtrVector.h
+++ b/llvm/include/llvm/ADT/TinyPtrVector.h
@@ -151,9 +151,10 @@ public:
   }
 
   // Implicit conversion to ArrayRef<U> if EltTy* implicitly converts to U*.
-  template <typename U, std::enable_if_t<
-                            std::is_convertible_v<ArrayRef<EltTy>, ArrayRef<U>>,
-                            bool> = false>
+  template <
+      typename U,
+      std::enable_if_t<std::is_convertible<ArrayRef<EltTy>, ArrayRef<U>>::value,
+                       bool> = false>
   operator ArrayRef<U>() const {
     return operator ArrayRef<EltTy>();
   }
diff --git a/llvm/include/llvm/ADT/bit.h b/llvm/include/llvm/ADT/bit.h
index e416e9e..2840c5f 100644
--- a/llvm/include/llvm/ADT/bit.h
+++ b/llvm/include/llvm/ADT/bit.h
@@ -44,11 +44,12 @@ namespace llvm {
 // This implementation of bit_cast is different from the C++20 one in two ways:
 //  - It isn't constexpr because that requires compiler support.
 //  - It requires trivially-constructible To, to avoid UB in the implementation.
-template <typename To, typename From,
-          typename = std::enable_if_t<sizeof(To) == sizeof(From)>,
-          typename = std::enable_if_t<std::is_trivially_constructible_v<To>>,
-          typename = std::enable_if_t<std::is_trivially_copyable_v<To>>,
-          typename = std::enable_if_t<std::is_trivially_copyable_v<From>>>
+template <
+    typename To, typename From,
+    typename = std::enable_if_t<sizeof(To) == sizeof(From)>,
+    typename = std::enable_if_t<std::is_trivially_constructible<To>::value>,
+    typename = std::enable_if_t<std::is_trivially_copyable<To>::value>,
+    typename = std::enable_if_t<std::is_trivially_copyable<From>::value>>
 [[nodiscard]] inline To bit_cast(const From &from) noexcept {
 #if __has_builtin(__builtin_bit_cast)
   return __builtin_bit_cast(To, from);
diff --git a/llvm/include/llvm/ADT/iterator.h b/llvm/include/llvm/ADT/iterator.h
index de826dd..6f0c42f 100644
--- a/llvm/include/llvm/ADT/iterator.h
+++ b/llvm/include/llvm/ADT/iterator.h
@@ -87,10 +87,10 @@ public:
 
 protected:
   enum {
-    IsRandomAccess =
-        std::is_base_of_v<std::random_access_iterator_tag, IteratorCategoryT>,
-    IsBidirectional =
-        std::is_base_of_v<std::bidirectional_iterator_tag, IteratorCategoryT>,
+    IsRandomAccess = std::is_base_of<std::random_access_iterator_tag,
+                                     IteratorCategoryT>::value,
+    IsBidirectional = std::is_base_of<std::bidirectional_iterator_tag,
+                                      IteratorCategoryT>::value,
   };
 
   /// A proxy object for computing a reference via indirecting a copy of an
@@ -225,12 +225,12 @@ template <
     typename DifferenceTypeT =
         typename std::iterator_traits<WrappedIteratorT>::difference_type,
     typename PointerT = std::conditional_t<
-        std::is_same_v<
-            T, typename std::iterator_traits<WrappedIteratorT>::value_type>,
+        std::is_same<T, typename std::iterator_traits<
+                            WrappedIteratorT>::value_type>::value,
         typename std::iterator_traits<WrappedIteratorT>::pointer, T *>,
     typename ReferenceT = std::conditional_t<
-        std::is_same_v<
-            T, typename std::iterator_traits<WrappedIteratorT>::value_type>,
+        std::is_same<T, typename std::iterator_traits<
+                            WrappedIteratorT>::value_type>::value,
         typename std::iterator_traits<WrappedIteratorT>::reference, T &>>
 class iterator_adaptor_base
     : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
-- 
2.7.4