[libc][NFC] Use STL case for type_traits

[gchatelet]

Summary

Migrating all private STL code to the standard STL case but keeping it under the CPP namespace to avoid confusion. Starting with the type_traits header.

[gchatelet]

• Fix one missing Value->value and rename header to type_traits.h

[sivachandra]

libc/src/__support/CPP/type_traits.h

48

Here and in is_floating_point, you have not updated TypeNoCV? May be do it for consistency, and because you are touching, make them private?

[gchatelet]

• Address comments

[gchatelet]

• Also fix clang-format warnings

[gchatelet]

This patch broke the build and needed these three subsequent commits

• https://github.com/llvm/llvm-project/commit/039fb3e5a12fccacd6ee5272e461e7e186397636
• https://github.com/llvm/llvm-project/commit/e5e0e7963cd6d4500bb7c4c4aa2c90bddc8468f8
• https://github.com/llvm/llvm-project/commit/0c3037dfc555887fc7b63069d5bff57e04759f06

Next time I will revert and reland...

libc/fuzzing/math/Compare.h

 //===-- Template functions to compare scalar values -------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_FUZZING_MATH_COMPARE_H
 #define LLVM_LIBC_FUZZING_MATH_COMPARE_H
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FPBits.h"
 
 template <typename T>
-__llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsFloatingPointType<T>::Value,
-                               bool>
+__llvm_libc::cpp::enable_if_t<__llvm_libc::cpp::is_floating_point_v<T>, bool>
 ValuesEqual(T x1, T x2) {
   __llvm_libc::fputil::FPBits<T> bits1(x1);
   __llvm_libc::fputil::FPBits<T> bits2(x2);
   // If either is NaN, we want both to be NaN.
   if (bits1.is_nan() || bits2.is_nan())
     return bits2.is_nan() && bits2.is_nan();
 
   // For all other values, we want the values to be bitwise equal.
   return bits1.uintval() == bits2.uintval();
 }
 
 template <typename T>
-__llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsIntegral<T>::Value, bool>
+__llvm_libc::cpp::enable_if_t<__llvm_libc::cpp::is_integral_v<T>, bool>
 ValuesEqual(T x1, T x2) {
   return x1 == x1;
 }
 
 #endif // LLVM_LIBC_FUZZING_MATH_COMPARE_H

libc/src/__support/CPP/ArrayRef.h

 //===-- Self contained ArrayRef type ----------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_CPP_ARRAYREF_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_ARRAYREF_H
 
 #include "Array.h"
-#include "TypeTraits.h" //RemoveCVType
+#include "type_traits.h" // RemoveCVType
 
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 namespace cpp {
 
 // The implementations of ArrayRef and MutableArrayRef in this file are based
 // on the implementations of the types with the same names in
 // llvm/ADT/ArrayRef.h. The implementations in this file are of a limited
 // functionality, but can be extended in an as needed basis.
 namespace internal {
 template <typename QualifiedT> class ArrayRefBase {
 public:
-  using value_type = RemoveCVType<QualifiedT>;
+  using value_type = remove_cv_t<QualifiedT>;
   using pointer = value_type *;
   using const_pointer = const value_type *;
   using reference = value_type &;
   using const_reference = const value_type &;
   using iterator = const_pointer;
   using const_iterator = const_pointer;
   using size_type = size_t;
   using difference_type = ptrdiff_t;

 private:
   QualifiedT *Data = nullptr;
   size_t Length = 0;
 };
 } // namespace internal
 
 template <typename T> struct ArrayRef : public internal::ArrayRefBase<const T> {
 private:
-  static_assert(IsSameV<T, RemoveCVType<T>>,
+  static_assert(is_same_v<T, remove_cv_t<T>>,
                 "ArrayRef must have a non-const, non-volatile value_type");
   using Impl = internal::ArrayRefBase<const T>;
   using Impl::Impl;
 
 public:
   // Construct an ArrayRef from void * pointer.
   // |Length| is the byte length of the array pointed to by |Data|.
   ArrayRef(const void *Data, size_t Length)
       : Impl(reinterpret_cast<const T *>(Data), Length / sizeof(T)) {}
 
   // From Array.
   template <size_t N> ArrayRef(const Array<T, N> &Arr) : Impl(Arr.Data, N) {}
 };
 
 template <typename T>
 struct MutableArrayRef : public internal::ArrayRefBase<T> {
 private:
   static_assert(
-      IsSameV<T, RemoveCVType<T>>,
+      is_same_v<T, remove_cv_t<T>>,
       "MutableArrayRef must have a non-const, non-volatile value_type");
   using Impl = internal::ArrayRefBase<T>;
   using Impl::Impl;
 
 public:
   // Construct an ArrayRef from void * pointer.
   // |Length| is the byte length of the array pointed to by |Data|.
   MutableArrayRef(void *Data, size_t Length)

libc/src/__support/CPP/CMakeLists.txt

DEPENDS
     .array_ref
     .string_view
     libc.src.__support.integer_to_string
 )
 
 add_header_library(
   type_traits
   HDRS
-    TypeTraits.h
+    type_traits.h
   DEPENDS
     .uint
 )
 
 add_header_library(
   utility
   HDRS
     Utility.h

libc/src/__support/CPP/TypeTraits.h

-//===-- Self contained C++ type traits --------------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
-#define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
-
-#include "UInt.h"
-
-namespace __llvm_libc {
-namespace cpp {
-
-template <bool B, typename T> struct EnableIf;
-template <typename T> struct EnableIf<true, T> {
-  typedef T Type;
-};
-
-template <bool B, typename T>
-using EnableIfType = typename EnableIf<B, T>::Type;
-
-struct TrueValue {
-  static constexpr bool Value = true;
-};
-
-struct FalseValue {
-  static constexpr bool Value = false;
-};
-
-template <typename T> struct TypeIdentity {
-  typedef T Type;
-};
-
-template <typename T1, typename T2> struct IsSame : public FalseValue {};
-template <typename T> struct IsSame<T, T> : public TrueValue {};
-template <typename T1, typename T2>
-static constexpr bool IsSameV = IsSame<T1, T2>::Value;
-
-template <typename T> struct RemoveCV : public TypeIdentity<T> {};
-template <typename T> struct RemoveCV<const T> : public TypeIdentity<T> {};
-template <typename T> struct RemoveCV<volatile T> : public TypeIdentity<T> {};
-template <typename T>
-struct RemoveCV<const volatile T> : public TypeIdentity<T> {};
-
-template <typename T> using RemoveCVType = typename RemoveCV<T>::Type;
-
-template <typename Type> struct IsIntegral {
-  using TypeNoCV = RemoveCVType<Type>;
-  static constexpr bool Value =
-      IsSameV<char, TypeNoCV> || IsSameV<signed char, TypeNoCV> ||
-      IsSameV<unsigned char, TypeNoCV> || IsSameV<short, TypeNoCV> ||
-      IsSameV<unsigned short, TypeNoCV> || IsSameV<int, TypeNoCV> ||
-      IsSameV<unsigned int, TypeNoCV> || IsSameV<long, TypeNoCV> ||
-      IsSameV<unsigned long, TypeNoCV> || IsSameV<long long, TypeNoCV> ||
-      IsSameV<unsigned long long, TypeNoCV> || IsSameV<bool, TypeNoCV> ||
-      // We need to include UInt<128> and __uint128_t when available because
-      // we want to unittest UInt<128>. If we include only UInt128, then on
-      // platform where it resolves to __uint128_t, we cannot unittest
-      // UInt<128>.
-      IsSameV<__llvm_libc::cpp::UInt<128>, TypeNoCV>
-#ifdef __SIZEOF_INT128__
-      || IsSameV<__int128_t, TypeNoCV> || IsSameV<__uint128_t, TypeNoCV>
-#endif
-      ;
-};
-
-template <typename Type> struct IsEnum {
-  static constexpr bool Value = __is_enum(Type);
-};
-
-template <typename T> struct IsPointerTypeNoCV : public FalseValue {};
-template <typename T> struct IsPointerTypeNoCV<T *> : public TrueValue {};
-template <typename T> struct IsPointerType {
-  static constexpr bool Value = IsPointerTypeNoCV<RemoveCVType<T>>::Value;
-};
-
-template <typename Type> struct IsFloatingPointType {
-  using TypeNoCV = RemoveCVType<Type>;
-  static constexpr bool Value = IsSame<float, TypeNoCV>::Value ||
-                                IsSame<double, TypeNoCV>::Value ||
-                                IsSame<long double, TypeNoCV>::Value;
-};
-
-template <typename Type> struct IsArithmetic {
-  static constexpr bool Value =
-      IsIntegral<Type>::Value || IsFloatingPointType<Type>::Value;
-};
-
-template <typename Type> struct IsSigned {
-  static constexpr bool Value =
-      IsArithmetic<Type>::Value && (Type(-1) < Type(0));
-  constexpr operator bool() const { return Value; }
-  constexpr bool operator()() const { return Value; }
-};
-
-template <typename Type> struct MakeUnsigned;
-template <> struct MakeUnsigned<char> {
-  using Type = unsigned char;
-};
-template <> struct MakeUnsigned<signed char> {
-  using Type = unsigned char;
-};
-template <> struct MakeUnsigned<short> {
-  using Type = unsigned short;
-};
-template <> struct MakeUnsigned<int> {
-  using Type = unsigned int;
-};
-template <> struct MakeUnsigned<long> {
-  using Type = unsigned long;
-};
-template <> struct MakeUnsigned<long long> {
-  using Type = unsigned long long;
-};
-template <> struct MakeUnsigned<unsigned char> {
-  using Type = unsigned char;
-};
-template <> struct MakeUnsigned<unsigned short> {
-  using Type = unsigned short;
-};
-template <> struct MakeUnsigned<unsigned int> {
-  using Type = unsigned int;
-};
-template <> struct MakeUnsigned<unsigned long> {
-  using Type = unsigned long;
-};
-template <> struct MakeUnsigned<unsigned long long> {
-  using Type = unsigned long long;
-};
-#ifdef __SIZEOF_INT128__
-template <> struct MakeUnsigned<__int128_t> {
-  using Type = __uint128_t;
-};
-template <> struct MakeUnsigned<__uint128_t> {
-  using Type = __uint128_t;
-};
-#endif
-
-template <typename T> using MakeUnsignedType = typename MakeUnsigned<T>::Type;
-
-// Compile time type selection.
-template <bool _, class TrueT, class FalseT> struct Conditional {
-  using type = TrueT;
-};
-template <class TrueT, class FalseT> struct Conditional<false, TrueT, FalseT> {
-  using type = FalseT;
-};
-template <bool Cond, typename TrueT, typename FalseT>
-using ConditionalType = typename Conditional<Cond, TrueT, FalseT>::type;
-
-} // namespace cpp
-} // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H

libc/src/__support/CPP/Utility.h

 //===-- Analogous to <utility> ----------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc::cpp {
 
 template <typename T, T... Seq> struct IntegerSequence {
-  static_assert(IsIntegral<T>::Value);
+  static_assert(is_integral_v<T>);
   template <T Next> using append = IntegerSequence<T, Seq..., Next>;
 };
 
 namespace internal {
 
 template <typename T, int N> struct MakeIntegerSequence {
   using type = typename MakeIntegerSequence<T, N - 1>::type::template append<N>;
 };

libc/src/__support/CPP/atomic.h

 //===-- A simple equivalent of std::atomic ----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_CPP_ATOMIC_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_ATOMIC_H
 
-#include "TypeTraits.h"
+#include "type_traits.h"
 
 namespace __llvm_libc {
 namespace cpp {
 
 enum class MemoryOrder : int {
   RELAXED = __ATOMIC_RELAXED,
   CONSUME = __ATOMIC_CONSUME,
   ACQUIRE = __ATOMIC_ACQUIRE,
   RELEASE = __ATOMIC_RELEASE,
   ACQ_REL = __ATOMIC_ACQ_REL,
   SEQ_CST = __ATOMIC_SEQ_CST
 };
 
 template <typename T> struct Atomic {
   // For now, we will restrict to only arithmetic types.
-  static_assert(IsArithmetic<T>::Value, "Only arithmetic types can be atomic.");
+  static_assert(is_arithmetic_v<T>, "Only arithmetic types can be atomic.");
 
 private:
   // The value stored should be appropriately aligned so that
   // hardware instructions used to perform atomic operations work
   // correctly.
   static constexpr int ALIGNMENT = sizeof(T) > alignof(T) ? sizeof(T)
                                                           : alignof(T);
 

libc/src/__support/CPP/stringstream.h

 //===-- A simple implementation of string stream class ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_CPP_STRINGSTREAM_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_STRINGSTREAM_H
 
 #include "ArrayRef.h"
 #include "StringView.h"
-#include "TypeTraits.h"
+#include "type_traits.h"
 
 #include "src/__support/integer_to_string.h"
 
 namespace __llvm_libc {
 namespace cpp {
 
 // This class is to be used to write simple strings into a user provided buffer
 // without any dynamic memory allocation. There is no requirement to mimic the
public:
 
   // Write the characters from |str| to the stream.
   StringStream &operator<<(StringView str) {
     write(str.data(), str.size());
     return *this;
   }
 
   // Write the |val| as string.
-  template <typename T, EnableIfType<IsIntegral<T>::Value, int> = 0>
+  template <typename T, enable_if_t<is_integral_v<T>, int> = 0>
   StringStream &operator<<(T val) {
     const auto int_to_str = integer_to_string(val);
     return operator<<(int_to_str.str());
   }
 
-  template <typename T, EnableIfType<IsFloatingPointType<T>::Value, int> = 0>
+  template <typename T, enable_if_t<is_floating_point_v<T>, int> = 0>
   StringStream &operator<<(T val) {
     // If this specialization gets activated, then the static_assert will
     // trigger a compile error about missing floating point number support.
-    static_assert(!IsFloatingPointType<T>::Value,
+    static_assert(!is_floating_point_v<T>,
                   "Writing floating point numbers is not yet supported");
     return *this;
   }
 
   // Write a null-terminated string. The terminating null character is not
   // written to allow stremaing to continue.
   StringStream &operator<<(const char *str) {
     return operator<<(StringView(str));

libc/src/__support/CPP/type_traits.h

+//===-- Self contained C++ type traits --------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
+
+#include "UInt.h"
+
+namespace __llvm_libc {
+namespace cpp {
+
+template <bool B, typename T> struct enable_if;
+template <typename T> struct enable_if<true, T> {
+  using type = T;
+};
+template <bool B, typename T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+
+template <typename T, T v> struct integral_constant {
+  using value_type = T;
+  static constexpr T value = v;
+};
+using true_type = cpp::integral_constant<bool, true>;
+using false_type = cpp::integral_constant<bool, false>;
+
+template <typename T> struct type_identity {
+  using type = T;
+};
+
+template <typename T, typename U> struct is_same : cpp::false_type {};
+template <typename T> struct is_same<T, T> : cpp::true_type {};
+template <typename T, typename U>
+inline constexpr bool is_same_v = is_same<T, U>::value;
+
+template <typename T> struct remove_cv : public type_identity<T> {};
+template <typename T> struct remove_cv<const T> : public type_identity<T> {};
+template <typename T> struct remove_cv<volatile T> : public type_identity<T> {};
+template <typename T>
+struct remove_cv<const volatile T> : public type_identity<T> {};
+template <typename T> using remove_cv_t = typename remove_cv<T>::type;
+
+template <typename T> struct is_integral {
+  using TypeNoCV = remove_cv_t<T>;
+  static constexpr bool value =
+      is_same_v<char, TypeNoCV> || is_same_v<signed char, TypeNoCV> ||
+      is_same_v<unsigned char, TypeNoCV> || is_same_v<short, TypeNoCV> ||
+      is_same_v<unsigned short, TypeNoCV> || is_same_v<int, TypeNoCV> ||
+      is_same_v<unsigned int, TypeNoCV> || is_same_v<long, TypeNoCV> ||
+      is_same_v<unsigned long, TypeNoCV> || is_same_v<long long, TypeNoCV> ||
+      is_same_v<unsigned long long, TypeNoCV> || is_same_v<bool, TypeNoCV> ||
+      // We need to include UInt<128> and __uint128_t when available because
+      // we want to unittest UInt<128>. If we include only UInt128, then on
+      // platform where it resolves to __uint128_t, we cannot unittest
+      // UInt<128>.
+      is_same_v<__llvm_libc::cpp::UInt<128>, TypeNoCV>
+#ifdef __SIZEOF_INT128__
+      || is_same_v<__int128_t, TypeNoCV> || is_same_v<__uint128_t, TypeNoCV>
+#endif
+      ;
+};
+template <typename T>
+inline constexpr bool is_integral_v = is_integral<T>::value;
+
+template <typename T> struct is_enum {
+  static constexpr bool value = __is_enum(T);
+};
+
+template <typename T> struct is_pointer : cpp::false_type {};
+template <typename T> struct is_pointer<T *> : cpp::true_type {};
+template <typename T> struct is_pointer<T *const> : cpp::true_type {};
+template <typename T> struct is_pointer<T *volatile> : cpp::true_type {};
+template <typename T> struct is_pointer<T *const volatile> : cpp::true_type {};
+template <typename T> inline constexpr bool is_pointer_v = is_pointer<T>::value;
+
+template <typename T> struct is_floating_point {
+  using TypeNoCV = remove_cv_t<T>;
+  static constexpr bool value = is_same_v<float, TypeNoCV> ||
+                                is_same_v<double, TypeNoCV> ||
+                                is_same_v<long double, TypeNoCV>;
+};
+template <typename T>
+inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
+
+template <typename T> struct is_arithmetic {
+  static constexpr bool value =
+      is_integral<T>::value || is_floating_point<T>::value;
+};
+template <typename T>
+inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
+
+template <typename T> struct is_signed {
+  static constexpr bool value = is_arithmetic<T>::value && (T(-1) < T(0));
+  constexpr operator bool() const { return value; }
+  constexpr bool operator()() const { return value; }
+};
+template <typename T> inline constexpr bool is_signed_v = is_signed<T>::value;
+
+template <typename T> struct make_unsigned;
+template <> struct make_unsigned<char> {
+  using type = unsigned char;
+};
+template <> struct make_unsigned<signed char> {
+  using type = unsigned char;
+};
+template <> struct make_unsigned<short> {
+  using type = unsigned short;
+};
+template <> struct make_unsigned<int> {
+  using type = unsigned int;
+};
+template <> struct make_unsigned<long> {
+  using type = unsigned long;
+};
+template <> struct make_unsigned<long long> {
+  using type = unsigned long long;
+};
+template <> struct make_unsigned<unsigned char> {
+  using type = unsigned char;
+};
+template <> struct make_unsigned<unsigned short> {
+  using type = unsigned short;
+};
+template <> struct make_unsigned<unsigned int> {
+  using type = unsigned int;
+};
+template <> struct make_unsigned<unsigned long> {
+  using type = unsigned long;
+};
+template <> struct make_unsigned<unsigned long long> {
+  using type = unsigned long long;
+};
+#ifdef __SIZEOF_INT128__
+template <> struct make_unsigned<__int128_t> {
+  using type = __uint128_t;
+};
+template <> struct make_unsigned<__uint128_t> {
+  using type = __uint128_t;
+};
+#endif
+template <typename T> using make_unsigned_t = typename make_unsigned<T>::type;
+
+// Compile time type selection.
+template <bool B, typename T, typename F> struct conditional {
+  using type = T;
+};
+template <typename T, typename F> struct conditional<false, T, F> {
+  using type = F;
+};
+template <bool B, typename T, typename F>
+using conditional_t = typename conditional<B, T, F>::type;
+
+} // namespace cpp
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H

libc/src/__support/FPUtil/BasicOperations.h

 //===-- Basic operations on floating point numbers --------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H
 
 #include "FPBits.h"
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T abs(T x) {
   FPBits<T> bits(x);
   bits.set_sign(0);
   return T(bits);
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T fmin(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.is_nan()) {
     return y;
   } else if (bity.is_nan()) {
     return x;
   } else if (bitx.get_sign() != bity.get_sign()) {
     // To make sure that fmin(+0, -0) == -0 == fmin(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with negative sign.
     return (bitx.get_sign() ? x : y);
   } else {
     return (x < y ? x : y);
   }
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T fmax(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.is_nan()) {
     return y;
   } else if (bity.is_nan()) {
     return x;
   } else if (bitx.get_sign() != bity.get_sign()) {
     // To make sure that fmax(+0, -0) == +0 == fmax(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with positive sign.
     return (bitx.get_sign() ? y : x);
   } else {
     return (x > y ? x : y);
   }
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T fdim(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.is_nan()) {
     return x;
   }
 
   if (bity.is_nan()) {

libc/src/__support/FPUtil/DivisionAndRemainderOperations.h

 //===-- Floating point divsion and remainder operations ---------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H
 
 #include "FPBits.h"
 #include "ManipulationFunctions.h"
 #include "NormalFloat.h"
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 static constexpr int QUOTIENT_LSB_BITS = 3;
 
 // The implementation is a bit-by-bit algorithm which uses integer division
 // to evaluate the quotient and remainder.
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T remquo(T x, T y, int &q) {
   FPBits<T> xbits(x), ybits(y);
   if (xbits.is_nan())
     return x;
   if (ybits.is_nan())
     return y;
   if (xbits.is_inf() || ybits.is_zero())
     return FPBits<T>::build_nan(1);

libc/src/__support/FPUtil/FMA.h

 #include "x86_64/FMA.h"
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
 #include "aarch64/FMA.h"
 #endif
 
 #else
 // FMA instructions are not available
 #include "generic/FMA.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> static inline T fma(T x, T y, T z) {
   return generic::fma(x, y, z);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H

libc/src/__support/FPUtil/FPBits.h

 //===-- Abstract class for bit manipulation of float numbers. ---*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
 
 #include "PlatformDefs.h"
 
 #include "src/__support/CPP/Bit.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/common.h"
 
 #include "FloatProperties.h"
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {

 // precision IEEE 754 floating point formats.
 // On most platforms, the 'float' type corresponds to single precision floating
 // point numbers, the 'double' type corresponds to double precision floating
 // point numers, and the 'long double' type corresponds to the quad precision
 // floating numbers. On x86 platforms however, the 'long double' type maps to
 // an x87 floating point format. This format is an IEEE 754 extension format.
 // It is handled as an explicit specialization of this class.
 template <typename T> struct FPBits {
-  static_assert(cpp::IsFloatingPointType<T>::Value,
+  static_assert(cpp::is_floating_point_v<T>,
                 "FPBits instantiated with invalid type.");
 
   // Reinterpreting bits as an integer value and interpreting the bits of an
   // integer value as a floating point value is used in tests. So, a convenient
   // type is provided for such reinterpretations.
   using FloatProp = FloatProperties<T>;
   // TODO: Change UintType name to BitsType for consistency.
   using UIntType = typename FloatProp::BitsType;
static constexpr UIntType MAX_SUBNORMAL =
       (UIntType(1) << MantissaWidth<T>::VALUE) - 1;
   static constexpr UIntType MIN_NORMAL =
       (UIntType(1) << MantissaWidth<T>::VALUE);
   static constexpr UIntType MAX_NORMAL =
       ((UIntType(MAX_EXPONENT) - 1) << MantissaWidth<T>::VALUE) | MAX_SUBNORMAL;
 
   // We don't want accidental type promotions/conversions, so we require exact
   // type match.
-  template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<T, XType>::Value, int> = 0>
+  template <typename XType, cpp::enable_if_t<cpp::is_same_v<T, XType>, int> = 0>
   constexpr explicit FPBits(XType x)
       : bits(__llvm_libc::bit_cast<UIntType>(x)) {}
 
   template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_same_v<XType, UIntType>, int> = 0>
   constexpr explicit FPBits(XType x) : bits(x) {}
 
   FPBits() : bits(0) {}
 
   T get_val() const { return __llvm_libc::bit_cast<T>(bits); }
 
   void set_val(T value) { bits = __llvm_libc::bit_cast<UIntType>(value); }
 

libc/src/__support/FPUtil/Hypot.h

 //===-- Implementation of hypotf function ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H
 
 #include "BasicOperations.h"
 #include "FEnvImpl.h"
 #include "FPBits.h"
 #include "builtin_wrappers.h"
 #include "src/__support/CPP/Bit.h"
-#include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/CPP/UInt128.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T>
 static inline T find_leading_one(T mant, int &shift_length) {

 //   -  Then we can feed this sum into the digit-by-digit algorithm for SQRT(Z)
 //      described above.
 //
 //
 // Special cases:
 //   - HYPOT(x, y) is +Inf if x or y is +Inf or -Inf; else
 //   - HYPOT(x, y) is NaN if x or y is NaN.
 //
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T hypot(T x, T y) {
   using FPBits_t = FPBits<T>;
   using UIntType = typename FPBits<T>::UIntType;
   using DUIntType = typename DoubleLength<UIntType>::Type;
 
   FPBits_t x_bits(x), y_bits(y);
 
   if (x_bits.is_inf() || y_bits.is_inf()) {

libc/src/__support/FPUtil/ManipulationFunctions.h

 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H
 
 #include "FPBits.h"
 #include "NearestIntegerOperations.h"
 #include "NormalFloat.h"
 #include "PlatformDefs.h"
 
 #include "src/__support/CPP/Bit.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 #include <limits.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T frexp(T x, int &exp) {
   FPBits<T> bits(x);
   if (bits.is_inf_or_nan())
     return x;
   if (bits.is_zero()) {
     exp = 0;
     return x;
   }
 
   NormalFloat<T> normal(bits);
   exp = normal.exponent + 1;
   normal.exponent = -1;
   return normal;
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T modf(T x, T &iptr) {
   FPBits<T> bits(x);
   if (bits.is_zero() || bits.is_nan()) {
     iptr = x;
     return x;
   } else if (bits.is_inf()) {
     iptr = x;
     return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
   } else {
     iptr = trunc(x);
     if (x == iptr) {
       // If x is already an integer value, then return zero with the right
       // sign.
       return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
     } else {
       return x - iptr;
     }
   }
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T copysign(T x, T y) {
   FPBits<T> xbits(x);
   xbits.set_sign(FPBits<T>(y).get_sign());
   return T(xbits);
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline int ilogb(T x) {
   // TODO: Raise appropriate floating point exceptions and set errno to the
   // an appropriate error value wherever relevant.
   FPBits<T> bits(x);
   if (bits.is_zero()) {
     return FP_ILOGB0;
   } else if (bits.is_nan()) {
     return FP_ILOGBNAN;
static inline int ilogb(T x) {
   if (normal.exponent > INT_MAX)
     return INT_MAX;
   else if (normal.exponent < INT_MIN)
     return INT_MIN;
   else
     return normal.exponent;
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T logb(T x) {
   FPBits<T> bits(x);
   if (bits.is_zero()) {
     // TODO(Floating point exception): Raise div-by-zero exception.
     // TODO(errno): POSIX requires setting errno to ERANGE.
     return T(FPBits<T>::neg_inf());
   } else if (bits.is_nan()) {
     return x;
   } else if (bits.is_inf()) {
     // Return positive infinity.
     return T(FPBits<T>::inf());
   }
 
   NormalFloat<T> normal(bits);
   return normal.exponent;
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T ldexp(T x, int exp) {
   FPBits<T> bits(x);
   if (bits.is_zero() || bits.is_inf_or_nan() || exp == 0)
     return x;
 
   // NormalFloat uses int32_t to store the true exponent value. We should ensure
   // that adding |exp| to it does not lead to integer rollover. But, if |exp|
   // value is larger the exponent range for type T, then we can return infinity
if (exp < -exp_limit)
     return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
 
   // For all other values, NormalFloat to T conversion handles it the right way.
   NormalFloat<T> normal(bits);
   normal.exponent += exp;
   return normal;
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T nextafter(T from, T to) {
   FPBits<T> from_bits(from);
   if (from_bits.is_nan())
     return from;
 
   FPBits<T> to_bits(to);
   if (to_bits.is_nan())
     return to;

libc/src/__support/FPUtil/NearestIntegerOperations.h

 //===-- Nearest integer floating-point operations ---------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 
 #include "FEnvImpl.h"
 #include "FPBits.h"
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 #include <errno.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T trunc(T x) {
   FPBits<T> bits(x);
 
   // If x is infinity or NaN, return it.
   // If it is zero also we should return it as is, but the logic
   // later in this function takes care of it. But not doing a zero
   // check, we improve the run time of non-zero values.
   if (bits.is_inf_or_nan())
else
       return T(0.0);
   }
 
   int trim_size = MantissaWidth<T>::VALUE - exponent;
   bits.set_mantissa((bits.get_mantissa() >> trim_size) << trim_size);
   return T(bits);
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T ceil(T x) {
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
   bool is_neg = bits.get_sign();
static inline T ceil(T x) {
 
   // If x is negative, the ceil operation is equivalent to the trunc operation.
   if (is_neg)
     return trunc_value;
 
   return trunc_value + T(1.0);
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T floor(T x) {
   FPBits<T> bits(x);
   if (bits.get_sign()) {
     return -ceil(-x);
   } else {
     return trunc(x);
   }
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T round(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
if (!half_bit_set) {
     // Franctional part is less than 0.5 so round value is the
     // same as the trunc value.
     return trunc_value;
   } else {
     return is_neg ? trunc_value - T(1.0) : trunc_value + T(1.0);
   }
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T round_using_current_rounding_mode(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
static inline T round_using_current_rounding_mode(T x) {
   default:
     __builtin_unreachable();
   }
 }
 
 namespace internal {
 
 template <typename F, typename I,
-          cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
-                                cpp::IsIntegral<I>::Value,
-                            int> = 0>
+          cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
 static inline I rounded_float_to_signed_integer(F x) {
   constexpr I INTEGER_MIN = (I(1) << (sizeof(I) * 8 - 1));
   constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
   FPBits<F> bits(x);
   auto set_domain_error_and_raise_invalid = []() {
     if (math_errhandling & MATH_ERRNO)
       errno = EDOM;
     if (math_errhandling & MATH_ERREXCEPT)
static inline I rounded_float_to_signed_integer(F x) {
   // we just return `x`. Implicit conversion will convert the
   // floating point value to the exact integer value.
   return x;
 }
 
 } // namespace internal
 
 template <typename F, typename I,
-          cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
-                                cpp::IsIntegral<I>::Value,
-                            int> = 0>
+          cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
 static inline I round_to_signed_integer(F x) {
   return internal::rounded_float_to_signed_integer<F, I>(round(x));
 }
 
 template <typename F, typename I,
-          cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
-                                cpp::IsIntegral<I>::Value,
-                            int> = 0>
+          cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
 static inline I round_to_signed_integer_using_current_rounding_mode(F x) {
   return internal::rounded_float_to_signed_integer<F, I>(
       round_using_current_rounding_mode(x));
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H

libc/src/__support/FPUtil/NormalFloat.h

 //===-- A class to store a normalized floating point number -----*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H
 
 #include "FPBits.h"
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // A class which stores the normalized form of a floating point value.
 // The special IEEE-754 bits patterns of Zero, infinity and NaNs are
 // are not handled by this class.
 //
 // A normalized floating point number is of this form:
 //    (-1)*sign * 2^exponent * <mantissa>
 // where <mantissa> is of the form 1.<...>.
 template <typename T> struct NormalFloat {
   static_assert(
-      cpp::IsFloatingPointType<T>::Value,
+      cpp::is_floating_point_v<T>,
       "NormalFloat template parameter has to be a floating point type.");
 
   using UIntType = typename FPBits<T>::UIntType;
   static constexpr UIntType ONE = (UIntType(1) << MantissaWidth<T>::VALUE);
 
   // Unbiased exponent value.
   int32_t exponent;
 

libc/src/__support/FPUtil/aarch64/FMA.h

 #if !defined(LLVM_LIBC_ARCH_AARCH64)
 #error "Invalid include"
 #endif
 
 #if !defined(LIBC_TARGET_HAS_FMA)
 #error "FMA instructions are not supported"
 #endif
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T>
-cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y, T z) {
+cpp::enable_if_t<cpp::is_same_v<T, float>, T> fma(T x, T y, T z) {
   float result;
   __asm__ __volatile__("fmadd %s0, %s1, %s2, %s3\n\t"
                        : "=w"(result)
                        : "w"(x), "w"(y), "w"(z));
   return result;
 }
 
 template <typename T>
-cpp::EnableIfType<cpp::IsSame<T, double>::Value, T> fma(T x, T y, T z) {
+cpp::enable_if_t<cpp::is_same_v<T, double> :, T> fma(T x, T y, T z) {
   double result;
   __asm__ __volatile__("fmadd %d0, %d1, %d2, %d3\n\t"
                        : "=w"(result)
                        : "w"(x), "w"(y), "w"(z));
   return result;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FMA_H

libc/src/__support/FPUtil/generic/FMA.h

 //===-- Common header for FMA implementations -------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H
 
 #include "src/__support/CPP/Bit.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/FloatProperties.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {

libc/src/__support/FPUtil/generic/FMod.h

 //===-- Common header for fmod implementations ------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMOD_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMOD_H
 
 #include "src/__support/CPP/Limits.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/common.h"
 #include "src/math/generic/math_utils.h"
 
 namespace __llvm_libc {
 namespace fputil {

 // and POSIX standard described in Linux man
 //   https://man7.org/linux/man-pages/man3/fmod.3p.html
 // C standard for the function is not full, so not by default (although it can
 // be implemented in another handler.
 // Signaling NaN converted to quiet NaN with FE_INVALID exception.
 //    https://www.open-std.org/JTC1/SC22/WG14/www/docs/n1011.htm
 template <typename T> struct FModExceptionalInputHandler {
 
-  static_assert(cpp::IsFloatingPointType<T>::Value,
+  static_assert(cpp::is_floating_point_v<T>,
                 "FModCStandardWrapper instantiated with invalid type.");
 
   static bool PreCheck(T x, T y, T &out) {
     using FPB = fputil::FPBits<T>;
     const T quiet_NaN = FPB::build_nan(FPB::FloatProp::QUIET_NAN_MASK);
     FPB sx(x), sy(y);
     if (likely(!sy.is_zero() && !sy.is_inf_or_nan() && !sx.is_inf_or_nan())) {
       return false;
static bool PreCheck(T x, T y, T &out) {
     // case where x == 0
     out = x;
     return true;
   }
 };
 
 template <typename T> struct FModFastMathWrapper {
 
-  static_assert(cpp::IsFloatingPointType<T>::Value,
+  static_assert(cpp::is_floating_point_v<T>,
                 "FModFastMathWrapper instantiated with invalid type.");
 
   static bool PreCheck(T, T, T &) { return false; }
 };
 
 template <typename T> class FModDivisionSimpleHelper {
 private:
   using intU_t = typename FPBits<T>::UIntType;
inline constexpr static intU_t execute(int exp_diff, int sides_zeroes_count,
     }
     return m_x;
   }
 };
 
 template <typename T, class Wrapper = FModExceptionalInputHandler<T>,
           class DivisionHelper = FModDivisionSimpleHelper<T>>
 class FMod {
-  static_assert(cpp::IsFloatingPointType<T>::Value,
+  static_assert(cpp::is_floating_point_v<T>,
                 "FMod instantiated with invalid type.");
 
 private:
   using FPB = FPBits<T>;
   using intU_t = typename FPB::UIntType;
 
   inline static constexpr FPB eval_internal(FPB sx, FPB sy) {
 

libc/src/__support/FPUtil/generic/sqrt.h

 //===-- Square root of IEEE 754 floating point numbers ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_H
 
 #include "sqrt_80_bit_long_double.h"
 #include "src/__support/CPP/Bit.h"
-#include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/CPP/UInt128.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 
 namespace __llvm_libc {
 namespace fputil {
 

 }
 #endif
 
 } // namespace internal
 
 // Correctly rounded IEEE 754 SQRT for all rounding modes.
 // Shift-and-add algorithm.
 template <typename T>
-static inline cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, T>
-sqrt(T x) {
+static inline cpp::enable_if_t<cpp::is_floating_point_v<T>, T> sqrt(T x) {
 
   if constexpr (internal::SpecialLongDouble<T>::VALUE) {
     // Special 80-bit long double.
     return x86::sqrt(x);
   } else {
     // IEEE floating points formats.
     using UIntType = typename FPBits<T>::UIntType;
     constexpr UIntType ONE = UIntType(1) << MantissaWidth<T>::VALUE;

libc/src/__support/FPUtil/x86_64/FMA.h

 #if !defined(LLVM_LIBC_ARCH_X86_64)
 #error "Invalid include"
 #endif
 
 #if !defined(LIBC_TARGET_HAS_FMA)
 #error "FMA instructions are not supported"
 #endif
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include <immintrin.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T>
-static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
-                                                                     T z) {
+static inline cpp::enable_if_t<cpp::is_same_v<T, float>, T> fma(T x, T y, T z) {
   float result;
   __m128 xmm = _mm_load_ss(&x);           // NOLINT
   __m128 ymm = _mm_load_ss(&y);           // NOLINT
   __m128 zmm = _mm_load_ss(&z);           // NOLINT
   __m128 r = _mm_fmadd_ss(xmm, ymm, zmm); // NOLINT
   _mm_store_ss(&result, r);               // NOLINT
   return result;
 }
 
 template <typename T>
-static inline cpp::EnableIfType<cpp::IsSame<T, double>::Value, T> fma(T x, T y,
-                                                                      T z) {
+static inline cpp::enable_if_t<cpp::is_same_v<T, double>, T> fma(T x, T y,
   double result;
   __m128d xmm = _mm_load_sd(&x);           // NOLINT
   __m128d ymm = _mm_load_sd(&y);           // NOLINT
   __m128d zmm = _mm_load_sd(&z);           // NOLINT
   __m128d r = _mm_fmadd_sd(xmm, ymm, zmm); // NOLINT
   _mm_store_sd(&result, r);                // NOLINT
   return result;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

template <> struct FPBits<long double> {
 
   bool get_sign() const {
     return ((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
   }
 
   FPBits() : bits(0) {}
 
   template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_same_v<long double, XType>, int> = 0>
   explicit FPBits(XType x) : bits(__llvm_libc::bit_cast<UIntType>(x)) {
     // bits starts uninitialized, and setting it to a long double only
     // overwrites the first 80 bits. This clears those upper bits.
     bits = bits & ((UIntType(1) << 80) - 1);
   }
 
   template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_same_v<XType, UIntType>, int> = 0>
   explicit FPBits(XType x) : bits(x) {}
 
   operator long double() { return __llvm_libc::bit_cast<long double>(bits); }
 
   UIntType uintval() {
     // We zero the padding bits as they can contain garbage.
     static constexpr UIntType MASK =
         (UIntType(1) << (sizeof(long double) * 8 -

libc/src/__support/integer_operations.h

 //===-- Utils for abs and friends -------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STDLIB_ABS_UTILS_H
 #define LLVM_LIBC_SRC_STDLIB_ABS_UTILS_H
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 
 template <typename T>
-static constexpr cpp::EnableIfType<cpp::IsIntegral<T>::Value, T>
-integer_abs(T n) {
+static constexpr cpp::enable_if_t<cpp::is_integral_v<T>, T> integer_abs(T n) {
   return (n < 0) ? -n : n;
 }
 
 template <typename T>
-static constexpr cpp::EnableIfType<cpp::IsIntegral<T>::Value, void>
+static constexpr cpp::enable_if_t<cpp::is_integral_v<T>, void>
 integer_rem_quo(T x, T y, T &quot, T &rem) {
   quot = x / y;
   rem = x % y;
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDLIB_ABS_UTILS_H

libc/src/__support/integer_to_string.h

 //===-- Utilities to convert integral values to string ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H
 #define LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H
 
 #include "src/__support/CPP/StringView.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 
 template <typename T> class IntegerToString {
-  static_assert(cpp::IsIntegral<T>::Value,
+  static_assert(cpp::is_integral_v<T>,
                 "IntegerToString can only be used with integral types.");
 
-  using UnsignedType = cpp::MakeUnsignedType<T>;
+  using UnsignedType = cpp::make_unsigned_t<T>;
 
   // We size the string buffer using an approximation algorithm:
   //
   //   size = ceil(sizeof(T) * 5 / 2)
   //
   // If sizeof(T) is 1, then size is 3 (actually 3)
   // If sizeof(T) is 2, then size is 5 (actually need 5)
   // If sizeof(T) is 4, then size is 10 (actually need 10)
   // If sizeof(T) is 8, then size is 20 (actually need 20)
   // If sizeof(T) is 16, then size is 40 (actually need 39)
   //
   // NOTE: The ceil operation is actually implemented as
   //     floor(((sizeof(T) * 5) + 1)/2)
   // where floor operation is just integer division.
   //
   // This estimation grows slightly faster than the actual value, but the
   // overhead is small enough to tolerate. In the actual formula below, we
   // add an additional byte to accommodate the '-' sign in case of signed
   // integers.
   static constexpr size_t BUFSIZE =
-      (sizeof(T) * 5 + 1) / 2 + (cpp::IsSigned<T>() ? 1 : 0);
+      (sizeof(T) * 5 + 1) / 2 + (cpp::is_signed<T>() ? 1 : 0);
   char strbuf[BUFSIZE] = {'\0'};
   size_t len = 0;
 
   constexpr void convert(UnsignedType val) {
     size_t buffptr = BUFSIZE;
     if (val == 0) {
       strbuf[buffptr - 1] = '0';
       --buffptr;

libc/src/math/generic/math_utils.h

 //===-- Collection of utils for implementing math functions -----*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_MATH_MATH_UTILS_H
 #define LLVM_LIBC_SRC_MATH_MATH_UTILS_H
 
 #include "src/__support/CPP/Bit.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/common.h"
 #include <errno.h>
 #include <math.h>
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 

 template <typename T> static inline T opt_barrier(T x) {
   volatile T y = x;
   return y;
 }
 
 template <typename T> struct IsFloatOrDouble {
   static constexpr bool
       Value = // NOLINT so that this Value can match the ones for IsSame
-      cpp::IsSame<T, float>::Value || cpp::IsSame<T, double>::Value;
+      cpp::is_same_v<T, float> || cpp::is_same_v<T, double>;
 };
 
 template <typename T>
-using EnableIfFloatOrDouble = cpp::EnableIfType<IsFloatOrDouble<T>::Value, int>;
+using EnableIfFloatOrDouble = cpp::enable_if_t<IsFloatOrDouble<T>::Value, int>;
 
 template <typename T, EnableIfFloatOrDouble<T> = 0>
 T xflow(uint32_t sign, T y) {
   // Underflow happens when two extremely small values are multiplied.
   // Likewise, overflow happens when two large values are multiplied.
   y = opt_barrier(sign ? -y : y) * y;
   return with_errno(y, ERANGE);
 }

libc/src/string/memory_utils/address.h

 //===-- Strongly typed address with alignment and access semantics --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_COMMON_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_COMMON_H
 
-#include "src/__support/CPP/TypeTraits.h"  // cpp::ConditionalType
+#include "src/__support/CPP/type_traits.h" // cpp::ConditionalType
 #include "src/string/memory_utils/utils.h" // is_power2
 #include <stddef.h>                        // size_t
 #include <stdint.h> // uint8_t, uint16_t, uint32_t, uint64_t
 
 namespace __llvm_libc {
 
 // Utility to enable static_assert(false) in templates.
 template <bool flag = false> static void DeferredStaticAssert(const char *msg) {

 // temporal/non-temporal).
 template <size_t Alignment, Permission P, Temporality TS> struct Address {
   static_assert(is_power2(Alignment));
   static constexpr size_t ALIGNMENT = Alignment;
   static constexpr Permission PERMISSION = P;
   static constexpr Temporality TEMPORALITY = TS;
   static constexpr bool IS_READ = P == Permission::Read;
   static constexpr bool IS_WRITE = P == Permission::Write;
-  using PointeeType = cpp::ConditionalType<!IS_WRITE, const ubyte, ubyte>;
-  using VoidType = cpp::ConditionalType<!IS_WRITE, const void, void>;
+  using PointeeType = cpp::conditional_t<!IS_WRITE, const ubyte, ubyte>;
+  using VoidType = cpp::conditional_t<!IS_WRITE, const void, void>;
 
   Address(VoidType *ptr) : ptr_(reinterpret_cast<PointeeType *>(ptr)) {}
 
   PointeeType *ptr() const {
     return reinterpret_cast<PointeeType *>(
         __builtin_assume_aligned(ptr_, ALIGNMENT));
   }
 
template <size_t ByteOffset> static constexpr size_t commonAlign() {
     constexpr size_t GCD = gcd(ByteOffset, ALIGNMENT);
     if constexpr (is_power2(GCD))
       return GCD;
     else
       return 1;
   }
 };
 
-template <typename T> struct IsAddressType : public cpp::FalseValue {};
+template <typename T> struct IsAddressType : public cpp::false_type {};
 template <size_t Alignment, Permission P, Temporality TS>
-struct IsAddressType<Address<Alignment, P, TS>> : public cpp::TrueValue {};
+struct IsAddressType<Address<Alignment, P, TS>> : public cpp::true_type {};
 
 // Reinterpret the address as a pointer to T.
 // This is not UB since the underlying pointer always refers to a `char` in a
 // buffer of raw data.
 template <typename T, typename AddrT> static T *as(AddrT addr) {
-  static_assert(IsAddressType<AddrT>::Value);
+  static_assert(IsAddressType<AddrT>::value);
   return reinterpret_cast<T *>(addr.ptr());
 }
 
 // Offsets the address by a compile time amount, this allows propagating
 // alignment whenever possible.
 template <size_t ByteOffset, typename AddrT>
 static auto offsetAddr(AddrT addr) {
-  static_assert(IsAddressType<AddrT>::Value);
+  static_assert(IsAddressType<AddrT>::value);
   return addr.template offset<ByteOffset>(ByteOffset);
 }
 
 // Offsets the address by a runtime amount but assuming that the resulting
 // address will be Alignment aligned.
 template <size_t Alignment, typename AddrT>
 static auto offsetAddrAssumeAligned(AddrT addr, size_t byte_offset) {
-  static_assert(IsAddressType<AddrT>::Value);
+  static_assert(IsAddressType<AddrT>::value);
   return Address<Alignment, AddrT::PERMISSION, AddrT::TEMPORALITY>(addr.ptr_ +
                                                                    byte_offset);
 }
 
 // Offsets the address by a runtime amount that is assumed to be a multiple of
 // ByteOffset. This allows to propagate the address alignment whenever possible.
 template <size_t ByteOffset, typename AddrT>
 static auto offsetAddrMultiplesOf(AddrT addr, ptrdiff_t byte_offset) {
-  static_assert(IsAddressType<AddrT>::Value);
+  static_assert(IsAddressType<AddrT>::value);
   return addr.template offset<ByteOffset>(byte_offset);
 }
 
 // User friendly aliases for common address types.
 template <size_t Alignment>
 using SrcAddr = Address<Alignment, Permission::Read, Temporality::TEMPORAL>;
 template <size_t Alignment>
 using DstAddr = Address<Alignment, Permission::Write, Temporality::TEMPORAL>;

libc/src/string/memory_utils/algorithm.h

template <typename NextT> struct Then {
     }
   };
 };
 
 // Compute the address of a tail operation.
 // Because of the runtime size, we loose the alignment information.
 template <size_t Size, typename AddrT>
 static auto tailAddr(AddrT addr, size_t runtime_size) {
-  static_assert(IsAddressType<AddrT>::Value);
+  static_assert(IsAddressType<AddrT>::value);
   return offsetAddrAssumeAligned<1>(addr, runtime_size - Size);
 }
 
 // Perform the operation on the last 'Size' bytes of the buffer.
 //
 // e.g. with
 // [1234567812345678123]
 // [__XXXXXXXXXXXXXX___]
private:
 
   template <typename Arg1AddrT, typename Arg2AddrT>
   static auto makeAligned(Arg1AddrT arg1, Arg2AddrT arg2, size_t size) {
     return Aligned<Arg1AddrT, Arg2AddrT>{arg1, arg2, size};
   }
 
   template <typename Arg1AddrT, typename Arg2AddrT>
   static auto align(Arg1AddrT arg1, Arg2AddrT arg2, size_t runtime_size) {
-    static_assert(IsAddressType<Arg1AddrT>::Value);
-    static_assert(IsAddressType<Arg2AddrT>::Value);
+    static_assert(IsAddressType<Arg1AddrT>::value);
+    static_assert(IsAddressType<Arg2AddrT>::value);
     if constexpr (AlignOn == Arg::_1) {
       auto offset = offset_to_next_aligned<ALIGN_OP_SIZE>(arg1.ptr_);
       return makeAligned(offsetAddrAssumeAligned<ALIGN_OP_SIZE>(arg1, offset),
                          offsetAddrAssumeAligned<1>(arg2, offset),
                          runtime_size - offset);
     } else if constexpr (AlignOn == Arg::_2) {
       auto offset = offset_to_next_aligned<ALIGN_OP_SIZE>(arg2.ptr_);
       return makeAligned(offsetAddrAssumeAligned<1>(arg1, offset),

libc/src/string/memory_utils/backend_aarch64.h

 #endif
 
 namespace __llvm_libc {
 
 struct Aarch64Backend : public Scalar64BitBackend {
   static constexpr bool IS_BACKEND_TYPE = true;
 
   template <typename T, Temporality TS, Aligned AS,
-            cpp::EnableIfType<Scalar64BitBackend::IsScalarType<T>, bool> = true>
+            cpp::enable_if_t<Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline T load(const T *src) {
     return Scalar64BitBackend::template load<T, TS, AS>(src);
   }
 };
 
 // Implementation of the SizedOp abstraction for the set operation.
 struct Zva64 {
   static constexpr size_t SIZE = 64;

libc/src/string/memory_utils/backend_scalar.h

 //===-- Elementary operations for native scalar types ---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BACKEND_SCALAR_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BACKEND_SCALAR_H
 
-#include "src/__support/CPP/TypeTraits.h" // ConditionalType, EnableIfType
+#include "src/__support/CPP/type_traits.h" // ConditionalType, enable_if_t
 #include "src/__support/endian.h"
 
 namespace __llvm_libc {
 
 struct Scalar64BitBackend {
   static constexpr bool IS_BACKEND_TYPE = true;
 
   template <typename T>
   static constexpr bool IsScalarType =
-      cpp::IsSameV<T, uint8_t> || cpp::IsSameV<T, uint16_t> ||
-      cpp::IsSameV<T, uint32_t> || cpp::IsSameV<T, uint64_t>;
+      cpp::is_same_v<T, uint8_t> || cpp::is_same_v<T, uint16_t> ||
+      cpp::is_same_v<T, uint32_t> || cpp::is_same_v<T, uint64_t>;
 
   template <typename T, Temporality TS, Aligned AS>
   static inline T load(const T *src) {
     static_assert(IsScalarType<T>);
     static_assert(TS == Temporality::TEMPORAL,
                   "Scalar load does not support non-temporal access");
     return *src;
   }
struct Scalar64BitBackend {
   }
 
   template <typename T> static inline int32_t threeWayCmp(T v1, T v2) {
     DeferredStaticAssert("not implemented");
   }
 
   // Returns the type to use to consume Size bytes.
   template <size_t Size>
-  using getNextType = cpp::ConditionalType<
+  using getNextType = cpp::conditional_t<
       Size >= 8, uint64_t,
-      cpp::ConditionalType<Size >= 4, uint32_t,
-                           cpp::ConditionalType<Size >= 2, uint16_t, uint8_t>>>;
+      cpp::conditional_t<Size >= 4, uint32_t,
+                         cpp::conditional_t<Size >= 2, uint16_t, uint8_t>>>;
 };
 
 template <>
 int32_t inline Scalar64BitBackend::threeWayCmp<uint8_t>(uint8_t a, uint8_t b) {
   const int16_t la = Endian::to_big_endian(a);
   const int16_t lb = Endian::to_big_endian(b);
   return la - lb;
 }

libc/src/string/memory_utils/backend_x86.h

 //===-- Elementary operations for x86 -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BACKEND_X86_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BACKEND_X86_H
 
 #if defined(LLVM_LIBC_ARCH_X86)
-#include "src/__support/CPP/TypeTraits.h" // ConditionalType, EnableIfType
+#include "src/__support/CPP/type_traits.h" // ConditionalType, enable_if_t
 #include "src/string/memory_utils/backend_scalar.h"
 
 #ifdef __SSE2__
 #include <immintrin.h>
 #endif //  __SSE2__
 
 #if defined(__SSE2__)
 #define HAS_M128 true

 #endif
 
 namespace __llvm_libc {
 struct X86Backend : public Scalar64BitBackend {
   static constexpr bool IS_BACKEND_TYPE = true;
 
   // Scalar types use base class implementations.
   template <typename T, Temporality TS, Aligned AS,
-            cpp::EnableIfType<Scalar64BitBackend::IsScalarType<T>, bool> = true>
+            cpp::enable_if_t<Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline T load(const T *src) {
     return Scalar64BitBackend::template load<T, TS, AS>(src);
   }
 
   // Scalar types use base class implementations.
   template <typename T, Temporality TS, Aligned AS,
-            cpp::EnableIfType<Scalar64BitBackend::IsScalarType<T>, bool> = true>
+            cpp::enable_if_t<Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline void store(T *dst, T value) {
     Scalar64BitBackend::template store<T, TS, AS>(dst, value);
   }
 
   // Scalar types use base class implementations.
   template <typename T,
-            cpp::EnableIfType<Scalar64BitBackend::IsScalarType<T>, bool> = true>
+            cpp::enable_if_t<Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline uint64_t notEquals(T v1, T v2) {
     return Scalar64BitBackend::template notEquals<T>(v1, v2);
   }
 
   // Scalar types use base class implementations.
   template <typename T,
-            cpp::EnableIfType<Scalar64BitBackend::IsScalarType<T>, bool> = true>
+            cpp::enable_if_t<Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline T splat(ubyte value) {
     return Scalar64BitBackend::template splat<T>(value);
   }
 
   // Scalar types use base class implementations.
   template <typename T,
-            cpp::EnableIfType<Scalar64BitBackend::IsScalarType<T>, bool> = true>
+            cpp::enable_if_t<Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline int32_t threeWayCmp(T v1, T v2) {
     return Scalar64BitBackend::template threeWayCmp<T>(v1, v2);
   }
 
   // X86 types are specialized below.
-  template <
-      typename T, Temporality TS, Aligned AS,
-      cpp::EnableIfType<!Scalar64BitBackend::IsScalarType<T>, bool> = true>
+  template <typename T, Temporality TS, Aligned AS,
+            cpp::enable_if_t<!Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline T load(const T *src);
 
   // X86 types are specialized below.
-  template <
-      typename T, Temporality TS, Aligned AS,
-      cpp::EnableIfType<!Scalar64BitBackend::IsScalarType<T>, bool> = true>
+  template <typename T, Temporality TS, Aligned AS,
+            cpp::enable_if_t<!Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline void store(T *dst, T value);
 
   // X86 types are specialized below.
-  template <typename T, cpp::EnableIfType<!Scalar64BitBackend::IsScalarType<T>,
-                                          bool> = true>
+  template <typename T,
+            cpp::enable_if_t<!Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline T splat(ubyte value);
 
   // X86 types are specialized below.
-  template <typename T, cpp::EnableIfType<!Scalar64BitBackend::IsScalarType<T>,
-                                          bool> = true>
+  template <typename T,
+            cpp::enable_if_t<!Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline uint64_t notEquals(T v1, T v2);
 
-  template <typename T, cpp::EnableIfType<!Scalar64BitBackend::IsScalarType<T>,
-                                          bool> = true>
+  template <typename T,
+            cpp::enable_if_t<!Scalar64BitBackend::IsScalarType<T>, bool> = true>
   static inline int32_t threeWayCmp(T v1, T v2) {
     return char_diff(reinterpret_cast<char *>(&v1),
                      reinterpret_cast<char *>(&v2), notEquals(v1, v2));
   }
 
   // Returns the type to use to consume Size bytes.
   template <size_t Size>
-  using getNextType = cpp::ConditionalType<
+  using getNextType = cpp::conditional_t<
       (HAS_M512 && Size >= 64), __m512i,
-      cpp::ConditionalType<
+      cpp::conditional_t<
           (HAS_M256 && Size >= 32), __m256i,
-          cpp::ConditionalType<(HAS_M128 && Size >= 16), __m128i,
-                               Scalar64BitBackend::getNextType<Size>>>>;
+          cpp::conditional_t<(HAS_M128 && Size >= 16), __m128i,
 
 private:
   static inline int32_t char_diff(const char *a, const char *b, uint64_t mask) {
     const size_t diff_index = mask == 0 ? 0 : __builtin_ctzll(mask);
     const int16_t ca = (unsigned char)a[diff_index];
     const int16_t cb = (unsigned char)b[diff_index];
     return ca - cb;
   }

libc/src/string/memory_utils/sized_op.h

private:
   static_assert(SIZE >= TYPE_SIZE);
   static constexpr size_t NEXT_SIZE = Size - TYPE_SIZE;
   using NextBlock = SizedOp<Backend, NEXT_SIZE>;
 
   // Returns whether we can use an aligned operations.
   // This is possible because the address type carries known compile-time
   // alignment informations.
   template <typename T, typename AddrT> static constexpr Aligned isAligned() {
-    static_assert(IsAddressType<AddrT>::Value);
+    static_assert(IsAddressType<AddrT>::value);
     return AddrT::ALIGNMENT > 1 && AddrT::ALIGNMENT >= sizeof(T) ? Aligned::YES
                                                                  : Aligned::NO;
   }
 
   // Loads a value of the current `type` from `src`.
   // This function is responsible for extracting Temporality and Alignment from
   // the Address type.
   template <typename SrcAddrT> static inline auto nativeLoad(SrcAddrT src) {
-    static_assert(IsAddressType<SrcAddrT>::Value && SrcAddrT::IS_READ);
+    static_assert(IsAddressType<SrcAddrT>::value && SrcAddrT::IS_READ);
     constexpr auto AS = isAligned<type, SrcAddrT>();
     constexpr auto TS = SrcAddrT::TEMPORALITY;
     return Backend::template load<type, TS, AS>(as<const type>(src));
   }
 
   // Stores a value of the current `type` to `dst`.
   // This function is responsible for extracting Temporality and Alignment from
   // the Address type.
   template <typename DstAddrT>
   static inline void nativeStore(type value, DstAddrT dst) {
-    static_assert(IsAddressType<DstAddrT>::Value && DstAddrT::IS_WRITE);
+    static_assert(IsAddressType<DstAddrT>::value && DstAddrT::IS_WRITE);
     constexpr auto AS = isAligned<type, DstAddrT>();
     constexpr auto TS = DstAddrT::TEMPORALITY;
     return Backend::template store<type, TS, AS>(as<type>(dst), value);
   }
 
   // A well aligned POD structure to store Size bytes.
   // This is used to implement the move operations.
   struct Value {
     alignas(alignof(type)) ubyte payload[Size];
   };
 
 public:
   template <typename DstAddrT, typename SrcAddrT>
   static inline void copy(DstAddrT dst, SrcAddrT src) {
-    static_assert(IsAddressType<DstAddrT>::Value && DstAddrT::IS_WRITE);
-    static_assert(IsAddressType<SrcAddrT>::Value && SrcAddrT::IS_READ);
+    static_assert(IsAddressType<DstAddrT>::value && DstAddrT::IS_WRITE);
+    static_assert(IsAddressType<SrcAddrT>::value && SrcAddrT::IS_READ);
     if constexpr (LLVM_LIBC_USE_BUILTIN_MEMCPY_INLINE &&
                   DstAddrT::TEMPORALITY == Temporality::TEMPORAL &&
                   SrcAddrT::TEMPORALITY == Temporality::TEMPORAL) {
       // delegate optimized copy to compiler.
       __builtin_memcpy_inline(dst.ptr(), src.ptr(), Size);
       return;
     }
     nativeStore(nativeLoad(src), dst);

libc/test/src/__support/CPP/integer_sequence_test.cpp

 //===-- Unittests for IntegerSequence -------------------------------------===//
 //
 // 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 "src/__support/CPP/Utility.h"
 #include "utils/UnitTest/Test.h"
 
 using namespace __llvm_libc::cpp;
 
 TEST(LlvmLibcIntegerSequencetTest, Basic) {
-  EXPECT_TRUE((IsSameV<IntegerSequence<int>, MakeIntegerSequence<int, 0>>));
+  EXPECT_TRUE((is_same_v<IntegerSequence<int>, MakeIntegerSequence<int, 0>>));
   using ISeq = IntegerSequence<int, 0, 1, 2, 3>;
-  EXPECT_TRUE((IsSameV<ISeq, MakeIntegerSequence<int, 4>>));
+  EXPECT_TRUE((is_same_v<ISeq, MakeIntegerSequence<int, 4>>));
   using LSeq = IntegerSequence<long, 0, 1, 2, 3>;
-  EXPECT_TRUE((IsSameV<LSeq, MakeIntegerSequence<long, 4>>));
+  EXPECT_TRUE((is_same_v<LSeq, MakeIntegerSequence<long, 4>>));
   using ULLSeq = IntegerSequence<unsigned long long, 0ull, 1ull, 2ull, 3ull>;
-  EXPECT_TRUE((IsSameV<ULLSeq, MakeIntegerSequence<unsigned long long, 4>>));
+  EXPECT_TRUE((is_same_v<ULLSeq, MakeIntegerSequence<unsigned long long, 4>>));
 }
 
 template <typename T, T... Ts>
 bool checkArray(IntegerSequence<T, Ts...> seq) {
   T arr[sizeof...(Ts)]{Ts...};
 
   for (T i = 0; i < static_cast<T>(sizeof...(Ts)); i++)
     if (arr[i] != i)
       return false;
 
   return true;
 }
 
 TEST(LlvmLibcIntegerSequencetTest, Many) {
   EXPECT_TRUE(checkArray(MakeIntegerSequence<int, 100>{}));
 }

libc/test/src/math/NextAfterTest.h

 //===-- Utility class to test different flavors of nextafter ----*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H
 #define LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H
 
 #include "src/__support/CPP/Bit.h"
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/BasicOperations.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 
 template <typename T>
 class NextAfterTestTemplate : public __llvm_libc::testing::Test {

libc/test/src/math/exhaustive/exhaustive_test.h

 //===-- Exhaustive test template for math functions -------------*- 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 "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 
 // To test exhaustively for inputs in the range [start, stop) in parallel:
 // 1. Inherit from LlvmLibcExhaustiveTest class
 // 2. Overide the test method: void check(T, T, RoundingMode)
 // 4. Call: test_full_range(start, stop, nthreads, rounding)
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T, typename FloatType = float>
 struct LlvmLibcExhaustiveTest : public __llvm_libc::testing::Test {
   static constexpr T increment = (1 << 20);
   static_assert(
-      __llvm_libc::cpp::IsSameV<
+      __llvm_libc::cpp::is_same_v<
           T, typename __llvm_libc::fputil::FPBits<FloatType>::UIntType>,
       "Types are not consistent");
   // Break [start, stop) into `nthreads` subintervals and apply *check to each
   // subinterval in parallel.
   void test_full_range(T start, T stop, mpfr::RoundingMode rounding);
 
   virtual bool check(T start, T stop, mpfr::RoundingMode rounding) = 0;
 };

libc/test/src/math/exhaustive/fmod_generic_impl_test.cpp

 //===-- Utility class to test FMod generic implementation -------*- 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 "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/generic/FMod.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 #include <array>
 #include <limits>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T, bool InverseMultiplication>
 class LlvmLibcFModTest : public __llvm_libc::testing::Test {
 
-  using DivisionHelper = __llvm_libc::cpp::ConditionalType<
+  using DivisionHelper = __llvm_libc::cpp::conditional_t<
       InverseMultiplication,
       __llvm_libc::fputil::generic::FModDivisionInvMultHelper<T>,
       __llvm_libc::fputil::generic::FModDivisionSimpleHelper<T>>;
 
   static constexpr std::array<T, 11> test_bases = {
       T(0.0),
       T(1.0),
       T(3.0),

libc/test/src/string/memory_utils/address_test.cpp

 #include "utils/UnitTest/Test.h"
 #include <src/string/memory_utils/address.h>
 
 namespace __llvm_libc {
 
 TEST(LlvmLibcAddress, AliasAreAddresses) {
-  ASSERT_TRUE(IsAddressType<SrcAddr<1>>::Value);
-  ASSERT_TRUE(IsAddressType<DstAddr<1>>::Value);
-  ASSERT_TRUE(IsAddressType<NtSrcAddr<1>>::Value);
-  ASSERT_TRUE(IsAddressType<NtDstAddr<1>>::Value);
+  ASSERT_TRUE(IsAddressType<SrcAddr<1>>::value);
+  ASSERT_TRUE(IsAddressType<DstAddr<1>>::value);
+  ASSERT_TRUE(IsAddressType<NtSrcAddr<1>>::value);
+  ASSERT_TRUE(IsAddressType<NtDstAddr<1>>::value);
 }
 
 TEST(LlvmLibcAddress, AliasHaveRightPermissions) {
   ASSERT_TRUE(SrcAddr<1>::IS_READ);
   ASSERT_TRUE(NtSrcAddr<1>::IS_READ);
   ASSERT_TRUE(DstAddr<1>::IS_WRITE);
   ASSERT_TRUE(NtDstAddr<1>::IS_WRITE);
 }

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

for (const auto &entrypoint : EntrypointNamesOption) {
     llvm::Record *retValSpec = functionSpec->getValueAsDef("Return");
     std::string returnType =
         G.getTypeAsString(retValSpec->getValueAsDef("ReturnType"));
     // _Noreturn is an indication for the compiler that a function
     // doesn't return, and isn't a type understood by c++ templates.
     if (llvm::StringRef(returnType).contains("_Noreturn"))
       returnType = "void";
 
-    OS << "  static_assert(__llvm_libc::cpp::IsSame<" << returnType << '(';
+    OS << "  static_assert(__llvm_libc::cpp::is_same_v<" << returnType << '(';
     auto args = functionSpec->getValueAsListOfDefs("Args");
     for (size_t i = 0, size = args.size(); i < size; ++i) {
       llvm::Record *argType = args[i]->getValueAsDef("ArgType");
       OS << G.getTypeAsString(argType);
       if (i < size - 1)
         OS << ", ";
     }
     OS << "), decltype(" << entrypoint << ")>::Value, ";

libc/utils/MPFRWrapper/MPFRUtils.h

 //===-- MPFRUtils.h ---------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H
 #define LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "utils/UnitTest/Test.h"
 #include "utils/testutils/RoundingModeUtils.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
enum class Operation : int {
   EndTernaryOperationsSingleOutput,
 };
 
 using __llvm_libc::testutils::ForceRoundingMode;
 using __llvm_libc::testutils::RoundingMode;
 
 template <typename T> struct BinaryInput {
   static_assert(
-      __llvm_libc::cpp::IsFloatingPointType<T>::Value,
+      __llvm_libc::cpp::is_floating_point_v<T>,
       "Template parameter of BinaryInput must be a floating point type.");
 
   using Type = T;
   T x, y;
 };
 
 template <typename T> struct TernaryInput {
   static_assert(
-      __llvm_libc::cpp::IsFloatingPointType<T>::Value,
+      __llvm_libc::cpp::is_floating_point_v<T>,
       "Template parameter of TernaryInput must be a floating point type.");
 
   using Type = T;
   T x, y, z;
 };
 
 template <typename T> struct BinaryOutput {
   T f;
   int i;
 };
 
 namespace internal {
 
 template <typename T1, typename T2>
 struct AreMatchingBinaryInputAndBinaryOutput {
   static constexpr bool VALUE = false;
 };
 
 template <typename T>
 struct AreMatchingBinaryInputAndBinaryOutput<BinaryInput<T>, BinaryOutput<T>> {
-  static constexpr bool VALUE = cpp::IsFloatingPointType<T>::Value;
+  static constexpr bool VALUE = cpp::is_floating_point_v<T>;
 };
 
 template <typename T>
 bool compare_unary_operation_single_output(Operation op, T input, T libc_output,
                                            double ulp_tolerance,
                                            RoundingMode rounding);
 template <typename T>
 bool compare_unary_operation_two_outputs(Operation op, T input,

 } // namespace internal
 
 // Return true if the input and ouput types for the operation op are valid
 // types.
 template <Operation op, typename InputType, typename OutputType>
 constexpr bool is_valid_operation() {
   return (Operation::BeginUnaryOperationsSingleOutput < op &&
           op < Operation::EndUnaryOperationsSingleOutput &&
-          cpp::IsSame<InputType, OutputType>::Value &&
-          cpp::IsFloatingPointType<InputType>::Value) ||
+          cpp::is_same_v<InputType, OutputType> &&
+          cpp::is_floating_point_v<InputType>) ||
          (Operation::BeginUnaryOperationsTwoOutputs < op &&
           op < Operation::EndUnaryOperationsTwoOutputs &&
-          cpp::IsFloatingPointType<InputType>::Value &&
-          cpp::IsSame<OutputType, BinaryOutput<InputType>>::Value) ||
+          cpp::is_floating_point_v<InputType> &&
+          cpp::is_same_v<OutputType, BinaryOutput<InputType>>) ||
          (Operation::BeginBinaryOperationsSingleOutput < op &&
           op < Operation::EndBinaryOperationsSingleOutput &&
-          cpp::IsFloatingPointType<OutputType>::Value &&
-          cpp::IsSame<InputType, BinaryInput<OutputType>>::Value) ||
+          cpp::is_floating_point_v<OutputType> &&
+          cpp::is_same_v<InputType, BinaryInput<OutputType>>) ||
          (Operation::BeginBinaryOperationsTwoOutputs < op &&
           op < Operation::EndBinaryOperationsTwoOutputs &&
           internal::AreMatchingBinaryInputAndBinaryOutput<InputType,
                                                           OutputType>::VALUE) ||
          (Operation::BeginTernaryOperationsSingleOuput < op &&
           op < Operation::EndTernaryOperationsSingleOutput &&
-          cpp::IsFloatingPointType<OutputType>::Value &&
-          cpp::IsSame<InputType, TernaryInput<OutputType>>::Value);
+          cpp::is_floating_point_v<OutputType> &&
+          cpp::is_same_v<InputType, TernaryInput<OutputType>>);
 }
 
 template <Operation op, typename InputType, typename OutputType>
 __attribute__((no_sanitize("address")))
-cpp::EnableIfType<is_valid_operation<op, InputType, OutputType>(),
+cpp::enable_if_t<is_valid_operation<op, InputType, OutputType>(),
                   internal::MPFRMatcher<op, InputType, OutputType>>
 get_mpfr_matcher(InputType input, OutputType output_unused,
                  double ulp_tolerance, RoundingMode rounding) {
   return internal::MPFRMatcher<op, InputType, OutputType>(input, ulp_tolerance,
                                                           rounding);
 }
 
 template <typename T> T round(T x, RoundingMode mode);

libc/utils/MPFRWrapper/MPFRUtils.cpp

public:
   MPFRNumber() : mpfr_precision(256), mpfr_rounding(MPFR_RNDN) {
     mpfr_init2(value, mpfr_precision);
   }
 
   // We use explicit EnableIf specializations to disallow implicit
   // conversions. Implicit conversions can potentially lead to loss of
   // precision.
   template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<float, XType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_same_v<float, XType>, int> = 0>
   explicit MPFRNumber(XType x, int precision = ExtraPrecision<XType>::VALUE,
                       RoundingMode rounding = RoundingMode::Nearest)
       : mpfr_precision(precision),
         mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
     mpfr_set_flt(value, x, mpfr_rounding);
   }
 
   template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<double, XType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_same_v<double, XType>, int> = 0>
   explicit MPFRNumber(XType x, int precision = ExtraPrecision<XType>::VALUE,
                       RoundingMode rounding = RoundingMode::Nearest)
       : mpfr_precision(precision),
         mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
     mpfr_set_d(value, x, mpfr_rounding);
   }
 
   template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_same_v<long double, XType>, int> = 0>
   explicit MPFRNumber(XType x, int precision = ExtraPrecision<XType>::VALUE,
                       RoundingMode rounding = RoundingMode::Nearest)
       : mpfr_precision(precision),
         mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
     mpfr_set_ld(value, x, mpfr_rounding);
   }
 
   template <typename XType,
-            cpp::EnableIfType<cpp::IsIntegral<XType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_integral_v<XType>, int> = 0>
   explicit MPFRNumber(XType x, int precision = ExtraPrecision<float>::VALUE,
                       RoundingMode rounding = RoundingMode::Nearest)
       : mpfr_precision(precision),
         mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
     mpfr_set_sj(value, x, mpfr_rounding);
   }
 
public:
   //    of ULP value for testing.  Morever, most of the fractional parts of
   //    ULP value do not matter much, so using double as the return type
   //    should be good enough.
   // 3. For close enough values (values which don't diff in their exponent by
   //    not more than 1), a ULP difference of N indicates a bit distance
   //    of N between this number and [input].
   // 4. A values of +0.0 and -0.0 are treated as equal.
   template <typename T>
-  cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, double> ulp(T input) {
+  cpp::enable_if_t<cpp::is_floating_point_v<T>, double> ulp(T input) {
     T thisAsT = as<T>();
     if (thisAsT == input)
       return T(0.0);
 
     int thisExponent = fputil::FPBits<T>(thisAsT).get_exponent();
     int inputExponent = fputil::FPBits<T>(input).get_exponent();
     // Adjust the exponents for denormal numbers.
     if (fputil::FPBits<T>(thisAsT).get_unbiased_exponent() == 0)

 
 template <> long double MPFRNumber::as<long double>() const {
   return mpfr_get_ld(value, mpfr_rounding);
 }
 
 namespace internal {
 
 template <typename InputType>
-cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
+cpp::enable_if_t<cpp::is_floating_point_v<InputType>, MPFRNumber>
 unary_operation(Operation op, InputType input, unsigned int precision,
                 RoundingMode rounding) {
   MPFRNumber mpfrInput(input, precision, rounding);
   switch (op) {
   case Operation::Abs:
     return mpfrInput.abs();
   case Operation::Ceil:
     return mpfrInput.ceil();
unary_operation(Operation op, InputType input, unsigned int precision,
   case Operation::Trunc:
     return mpfrInput.trunc();
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
-cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
+cpp::enable_if_t<cpp::is_floating_point_v<InputType>, MPFRNumber>
 unary_operation_two_outputs(Operation op, InputType input, int &output,
                             unsigned int precision, RoundingMode rounding) {
   MPFRNumber mpfrInput(input, precision, rounding);
   switch (op) {
   case Operation::Frexp:
     return mpfrInput.frexp(output);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
-cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
+cpp::enable_if_t<cpp::is_floating_point_v<InputType>, MPFRNumber>
 binary_operation_one_output(Operation op, InputType x, InputType y,
                             unsigned int precision, RoundingMode rounding) {
   MPFRNumber inputX(x, precision, rounding);
   MPFRNumber inputY(y, precision, rounding);
   switch (op) {
   case Operation::Fmod:
     return inputX.fmod(inputY);
   case Operation::Hypot:
     return inputX.hypot(inputY);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
-cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
+cpp::enable_if_t<cpp::is_floating_point_v<InputType>, MPFRNumber>
 binary_operation_two_outputs(Operation op, InputType x, InputType y,
                              int &output, unsigned int precision,
                              RoundingMode rounding) {
   MPFRNumber inputX(x, precision, rounding);
   MPFRNumber inputY(y, precision, rounding);
   switch (op) {
   case Operation::RemQuo:
     return inputX.remquo(inputY, output);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
-cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
+cpp::enable_if_t<cpp::is_floating_point_v<InputType>, MPFRNumber>
 ternary_operation_one_output(Operation op, InputType x, InputType y,
                              InputType z, unsigned int precision,
                              RoundingMode rounding) {
   // For FMA function, we just need to compare with the mpfr_fma with the same
   // precision as InputType.  Using higher precision as the intermediate results
   // to compare might incorrectly fail due to double-rounding errors.
   MPFRNumber inputX(x, precision, rounding);
   MPFRNumber inputY(y, precision, rounding);

libc/utils/UnitTest/FPMatcher.h

 #include <errno.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 template <typename ValType, typename StreamType>
-cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
+cpp::enable_if_t<cpp::is_floating_point_v<ValType>, void>
 describeValue(const char *label, ValType value, StreamType &stream);
 
 template <typename T, __llvm_libc::testing::TestCondition Condition>
 class FPMatcher : public __llvm_libc::testing::Matcher<T> {
-  static_assert(__llvm_libc::cpp::IsFloatingPointType<T>::Value,
+  static_assert(__llvm_libc::cpp::is_floating_point_v<T>,
                 "FPMatcher can only be used with floating point values.");
   static_assert(Condition == __llvm_libc::testing::Cond_EQ ||
                     Condition == __llvm_libc::testing::Cond_NE,
                 "Unsupported FPMathcer test condition.");
 
   T expected;
   T actual;
 

libc/utils/UnitTest/FPMatcher.cpp

 #include <sstream>
 #include <string>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 template <typename ValType, typename StreamType>
-cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
+cpp::enable_if_t<cpp::is_floating_point_v<ValType>, void>
 describeValue(const char *label, ValType value, StreamType &stream) {
   stream << label;
 
   FPBits<ValType> bits(value);
   if (bits.is_nan()) {
     stream << "(NaN)";
   } else if (bits.is_inf()) {
     if (bits.get_sign())

libc/utils/UnitTest/LibcTest.h

 //===-- Base class for libc unittests ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H
 #define LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H
 
 // This file can only include headers from src/__support/CPP/ or
 // utils/testutils. No other headers should be included.
 
 #include "PlatformDefs.h"
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 #include "utils/testutils/ExecuteFunction.h"
 #include "utils/testutils/StreamWrapper.h"
 
 namespace __llvm_libc {
 namespace testing {
 
 class RunContext;
 
protected:
   // We make use of a template function, with |LHS| and |RHS| as explicit
   // parameters, for enhanced type checking. Other gtest like unittest
   // frameworks have a similar function which takes a boolean argument
   // instead of the explicit |LHS| and |RHS| arguments. This boolean argument
   // is the result of the |Cond| operation on |LHS| and |RHS|. Though not bad,
   // |Cond| on mismatched |LHS| and |RHS| types can potentially succeed because
   // of type promotion.
   template <typename ValType,
-            cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_integral_v<ValType>, int> = 0>
   bool test(TestCondition Cond, ValType LHS, ValType RHS, const char *LHSStr,
             const char *RHSStr, const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
   }
 
   template <typename ValType,
-            cpp::EnableIfType<cpp::IsEnum<ValType>::Value, int> = 0>
+            cpp::enable_if_t<cpp::is_enum<ValType>::value, int> = 0>
   bool test(TestCondition Cond, ValType LHS, ValType RHS, const char *LHSStr,
             const char *RHSStr, const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, (long long)LHS, (long long)RHS, LHSStr,
                           RHSStr, File, Line);
   }
 
-  template <
-      typename ValType,
-      cpp::EnableIfType<cpp::IsPointerType<ValType>::Value, ValType> = nullptr>
+  template <typename ValType,
+            cpp::enable_if_t<cpp::is_pointer_v<ValType>, ValType> = nullptr>
   bool test(TestCondition Cond, ValType LHS, ValType RHS, const char *LHSStr,
             const char *RHSStr, const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, (unsigned long long)LHS,
                           (unsigned long long)RHS, LHSStr, RHSStr, File, Line);
   }
 
   bool testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
                  const char *RHSStr, const char *File, unsigned long Line);

libc/utils/UnitTest/LibcTest.cpp

 private:
   RunResult Status = Result_Pass;
 };
 
 namespace internal {
 
 // When the value is of integral type, just display it as normal.
 template <typename ValType>
-cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, std::string>
+cpp::enable_if_t<cpp::is_integral_v<ValType>, std::string>
 describeValue(ValType Value) {
   return std::to_string(Value);
 }
 
 std::string describeValue(std::string Value) { return std::string(Value); }
 
 // When the value is UInt128 or __uint128_t, show its hexadecimal digits.
 // We cannot just use a UInt128 specialization as that resolves to only

libc/utils/UnitTest/StringUtils.h

 //===-- String utils for matchers -------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
 #define LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
 
-#include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/type_traits.h"
 
 #include <string>
 
 namespace __llvm_libc {
 
 // Return the first N hex digits of an integer as a string in upper case.
 template <typename T>
-cpp::EnableIfType<cpp::IsIntegral<T>::Value, std::string>
+cpp::enable_if_t<cpp::is_integral_v<T>, std::string>
 int_to_hex(T X, size_t Length = sizeof(T) * 2) {
   std::string s(Length, '0');
 
   for (auto it = s.rbegin(), end = s.rend(); it != end; ++it, X >>= 4) {
     unsigned char Mod = static_cast<unsigned char>(X) & 15;
     *it = (Mod < 10 ? '0' + Mod : 'a' + Mod - 10);
   }
 
   return s;
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

hdrs = [
         "src/__support/CPP/UInt128.h",
     ],
     deps = [":libc_root",":__support_cpp_uint"],
 )
 
 cc_library(
     name = "__support_cpp_type_traits",
     hdrs = [
-        "src/__support/CPP/TypeTraits.h",
+        "src/__support/CPP/type_traits.h",
     ],
     deps = [":libc_root","__support_cpp_uint"],
 )
 
 cc_library(
     name = "__support_cpp_utility",
     hdrs = ["src/__support/CPP/Utility.h"],
     deps = [