[libc][NFC] Use STL case for type_traits

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.

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

Author: gchatelet

libc/fuzzing/math/Compare.h

@@ -9,12 +9,11 @@
 #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);
@@ -27,7 +26,7 @@ ValuesEqual(T x1, T x2) {
 }
 
 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;
 }

libc/src/__support/CPP/ArrayRef.h

@@ -10,7 +10,7 @@
 #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.
 
@@ -24,7 +24,7 @@ namespace cpp {
 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 &;
@@ -109,7 +109,7 @@ template <typename QualifiedT> class ArrayRefBase {
 
 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;
@@ -128,7 +128,7 @@ 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;

libc/src/__support/CPP/CMakeLists.txt

@@ -71,7 +71,7 @@ add_header_library(
 add_header_library(
   type_traits
   HDRS
-    TypeTraits.h
+    type_traits.h
   DEPENDS
     .uint
 )

libc/src/__support/CPP/TypeTraits.h

@@ -9,12 +9,12 @@
 #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>;
 };
 

libc/src/__support/CPP/Utility.h

@@ -9,7 +9,7 @@
 #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 {
@@ -25,7 +25,7 @@ enum class MemoryOrder : int {
 
 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

libc/src/__support/CPP/atomic.h

@@ -11,7 +11,7 @@
 
 #include "ArrayRef.h"
 #include "StringView.h"
-#include "TypeTraits.h"
+#include "type_traits.h"
 
 #include "src/__support/integer_to_string.h"
 
@@ -56,17 +56,17 @@ class StringStream {
   }
 
   // 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;
   }