[libc][NFC] Use STL case for limits

[gchatelet]

Summary

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

[gchatelet]

Fix clang-format error and rebase

libc/src/__support/CPP/CMakeLists.txt

add_header_library(
   functional
   HDRS
     Functional.h
 )
 
 add_header_library(
   limits
   HDRS
-    Limits.h
+    limits.h
   DEPENDS
     .uint
 )
 
 add_header_library(
   string_view
   HDRS
     StringView.h

libc/src/__support/CPP/limits.h

 
 #include "UInt.h"
 
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace cpp {
 
-template <class T> class NumericLimits {
+template <class T> class numeric_limits {
 public:
   static constexpr T max();
   static constexpr T min();
 };
 
-// TODO: Add NumericLimits specializations as needed for new types.
+// TODO: Add numeric_limits specializations as needed for new types.
 
-template <> class NumericLimits<int> {
+template <> class numeric_limits<int> {
 public:
   static constexpr int max() { return INT_MAX; }
   static constexpr int min() { return INT_MIN; }
 };
-template <> class NumericLimits<unsigned int> {
+template <> class numeric_limits<unsigned int> {
 public:
   static constexpr unsigned int max() { return UINT_MAX; }
   static constexpr unsigned int min() { return 0; }
 };
-template <> class NumericLimits<long> {
+template <> class numeric_limits<long> {
 public:
   static constexpr long max() { return LONG_MAX; }
   static constexpr long min() { return LONG_MIN; }
 };
-template <> class NumericLimits<unsigned long> {
+template <> class numeric_limits<unsigned long> {
 public:
   static constexpr unsigned long max() { return ULONG_MAX; }
   static constexpr unsigned long min() { return 0; }
 };
-template <> class NumericLimits<long long> {
+template <> class numeric_limits<long long> {
 public:
   static constexpr long long max() { return LLONG_MAX; }
   static constexpr long long min() { return LLONG_MIN; }
 };
-template <> class NumericLimits<unsigned long long> {
+template <> class numeric_limits<unsigned long long> {
 public:
   static constexpr unsigned long long max() { return ULLONG_MAX; }
   static constexpr unsigned long long min() { return 0; }
 };
-template <> class NumericLimits<short> {
+template <> class numeric_limits<short> {
 public:
   static constexpr short max() { return SHRT_MAX; }
   static constexpr short min() { return SHRT_MIN; }
 };
-template <> class NumericLimits<unsigned short> {
+template <> class numeric_limits<unsigned short> {
 public:
   static constexpr unsigned short max() { return USHRT_MAX; }
   static constexpr unsigned short min() { return 0; }
 };
-template <> class NumericLimits<char> {
+template <> class numeric_limits<char> {
 public:
   static constexpr char max() { return CHAR_MAX; }
   static constexpr char min() { return CHAR_MIN; }
 };
-template <> class NumericLimits<unsigned char> {
+template <> class numeric_limits<unsigned char> {
 public:
   static constexpr unsigned char max() { return UCHAR_MAX; }
   static constexpr unsigned char min() { return 0; }
 };
 // This specialization enables two things:
 // 1. On platforms where UInt128 resolves to UInt<128>, this specialization
 //    provides limits of UInt128.
 // 2. On platforms where UInt128 resolves to __uint128_t, this specialization
 //    allows us to unittest UInt<128>.
-template <> class NumericLimits<UInt<128>> {
+template <> class numeric_limits<UInt<128>> {
 public:
   static constexpr UInt<128> max() { return ~UInt<128>(0); }
   static constexpr UInt<128> min() { return 0; }
 };
 #ifdef __SIZEOF_INT128__
 // On platform where UInt128 resolves to __uint128_t, this specialization
 // provides the limits of UInt128.
-template <> class NumericLimits<__uint128_t> {
+template <> class numeric_limits<__uint128_t> {
 public:
   static constexpr __uint128_t max() { return ~__uint128_t(0); }
   static constexpr __uint128_t min() { return 0; }
 };
 #endif
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H

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/limits.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 {

 private:
   using FPB = FPBits<T>;
   using intU_t = typename FPB::UIntType;
 
 public:
   inline constexpr static intU_t execute(int exp_diff, int sides_zeroes_count,
                                          intU_t m_x, intU_t m_y) {
     if (exp_diff > sides_zeroes_count) {
-      intU_t inv_hy = (cpp::NumericLimits<intU_t>::max() / m_y);
+      intU_t inv_hy = (cpp::numeric_limits<intU_t>::max() / m_y);
       while (exp_diff > sides_zeroes_count) {
         exp_diff -= sides_zeroes_count;
         intU_t hd =
             (m_x * inv_hy) >> (FPB::FloatProp::BIT_WIDTH - sides_zeroes_count);
         m_x <<= sides_zeroes_count;
         m_x -= hd * m_y;
         while (unlikely(m_x > m_y))
           m_x -= m_y;

libc/src/__support/str_to_float.h

 //===-- String to float conversion utils ------------------------*- 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 LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 #define LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 
-#include "src/__support/CPP/Limits.h"
+#include "src/__support/CPP/limits.h"
 #include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/detailed_powers_of_ten.h"
 #include "src/__support/high_precision_decimal.h"
 #include "src/__support/str_to_integer.h"
 #include <errno.h>
decimal_string_to_float(const char *__restrict src, const char DECIMAL_POINT,
   BitsType mantissa = 0;
   int32_t exponent = 0;
 
   // The goal for the first step of parsing is to convert the number in src to
   // the format mantissa * (base ^ exponent)
 
   // The loop fills the mantissa with as many digits as it can hold
   const BitsType bitstype_max_div_by_base =
-      __llvm_libc::cpp::NumericLimits<BitsType>::max() / BASE;
+      cpp::numeric_limits<BitsType>::max() / BASE;
   while (true) {
     if (isdigit(*src)) {
       uint32_t digit = *src - '0';
       seen_digit = true;
 
       if (mantissa < bitstype_max_div_by_base) {
         mantissa = (mantissa * BASE) + digit;
         if (after_decimal) {
static inline bool hexadecimal_string_to_float(
   BitsType mantissa = 0;
   int32_t exponent = 0;
 
   // The goal for the first step of parsing is to convert the number in src to
   // the format mantissa * (base ^ exponent)
 
   // The loop fills the mantissa with as many digits as it can hold
   const BitsType bitstype_max_div_by_base =
-      __llvm_libc::cpp::NumericLimits<BitsType>::max() / BASE;
+      cpp::numeric_limits<BitsType>::max() / BASE;
   while (true) {
     if (isalnum(*src)) {
       uint32_t digit = b36_char_to_int(*src);
       if (digit < BASE)
         seen_digit = true;
       else
         break;
 

libc/src/__support/str_to_integer.h

 //===-- String to integer conversion utils ----------------------*- 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 LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 #define LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 
-#include "src/__support/CPP/Limits.h"
+#include "src/__support/CPP/limits.h"
 #include "src/__support/ctype_utils.h"
 #include <errno.h>
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns a pointer to the first character in src that is not a whitespace
static inline T strtointeger(const char *__restrict src,
   }
 
   if (base == 0) {
     base = infer_base(&src);
   } else if (base == 16 && is_hex_start(src)) {
     src = src + 2;
   }
 
-  constexpr bool IS_UNSIGNED = (__llvm_libc::cpp::NumericLimits<T>::min() == 0);
+  constexpr bool IS_UNSIGNED = (cpp::numeric_limits<T>::min() == 0);
   const bool is_positive = (result_sign == '+');
   unsigned long long constexpr NEGATIVE_MAX =
-      !IS_UNSIGNED ? static_cast<unsigned long long>(
-                         __llvm_libc::cpp::NumericLimits<T>::max()) +
-                         1
-                   : __llvm_libc::cpp::NumericLimits<T>::max();
+      !IS_UNSIGNED
+          ? static_cast<unsigned long long>(cpp::numeric_limits<T>::max()) + 1
+          : cpp::numeric_limits<T>::max();
   unsigned long long const abs_max =
-      (is_positive ? __llvm_libc::cpp::NumericLimits<T>::max() : NEGATIVE_MAX);
+      (is_positive ? cpp::numeric_limits<T>::max() : NEGATIVE_MAX);
   unsigned long long const abs_max_div_by_base = abs_max / base;
   while (isalnum(*src)) {
     int cur_digit = b36_char_to_int(*src);
     if (cur_digit >= base)
       break;
 
     is_number = true;
     ++src;
while (isalnum(*src)) {
     }
   }
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(is_number ? src : original_src);
 
   if (result == abs_max) {
     if (is_positive || IS_UNSIGNED)
-      return __llvm_libc::cpp::NumericLimits<T>::max();
+      return cpp::numeric_limits<T>::max();
     else // T is signed and there is a negative overflow
-      return __llvm_libc::cpp::NumericLimits<T>::min();
+      return cpp::numeric_limits<T>::min();
   }
 
   return is_positive ? static_cast<T>(result) : -static_cast<T>(result);
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LIBC_SRC_SUPPORT_STR_TO_INTEGER_H

libc/src/stdio/printf_core/converter_utils.h

 //===-- Shared Converter Utilities for printf -------------------*- 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_STDIO_PRINTF_CORE_CONVERTER_UTILS_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CONVERTER_UTILS_H
 
-#include "src/__support/CPP/Limits.h"
+#include "src/__support/CPP/limits.h"
 #include "src/stdio/printf_core/core_structs.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 inline uintmax_t apply_length_modifier(uintmax_t num, LengthModifier lm) {
   switch (lm) {
   case LengthModifier::none:
-    return num & cpp::NumericLimits<unsigned int>::max();
+    return num & cpp::numeric_limits<unsigned int>::max();
   case LengthModifier::l:
-    return num & cpp::NumericLimits<unsigned long>::max();
+    return num & cpp::numeric_limits<unsigned long>::max();
   case LengthModifier::ll:
   case LengthModifier::L:
-    return num & cpp::NumericLimits<unsigned long long>::max();
+    return num & cpp::numeric_limits<unsigned long long>::max();
   case LengthModifier::h:
-    return num & cpp::NumericLimits<unsigned short>::max();
+    return num & cpp::numeric_limits<unsigned short>::max();
   case LengthModifier::hh:
-    return num & cpp::NumericLimits<unsigned char>::max();
+    return num & cpp::numeric_limits<unsigned char>::max();
   case LengthModifier::z:
-    return num & cpp::NumericLimits<size_t>::max();
+    return num & cpp::numeric_limits<size_t>::max();
   case LengthModifier::t:
     // We don't have unsigned ptrdiff so uintptr_t is used, since we need an
     // unsigned type and ptrdiff is usually the same size as a pointer.
     static_assert(sizeof(ptrdiff_t) == sizeof(uintptr_t));
-    return num & cpp::NumericLimits<uintptr_t>::max();
+    return num & cpp::numeric_limits<uintptr_t>::max();
   case LengthModifier::j:
     return num; // j is intmax, so no mask is necessary.
   }
 }
 
 #define RET_IF_RESULT_NEGATIVE(func)                                           \
   {                                                                            \
     int result = (func);                                                       \
     if (result < 0)                                                            \
       return result;                                                           \
   }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CONVERTER_UTILS_H

libc/src/stdio/printf_core/write_int_converter.h

 //===-- Write integer Converter for printf ----------------------*- 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_STDIO_PRINTF_CORE_WRITE_INT_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_WRITE_INT_CONVERTER_H
 
-#include "src/__support/CPP/Limits.h"
+#include "src/__support/CPP/limits.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {

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

 //===-- Unittests for Limits ----------------------------------------------===//
 //
 // 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/Limits.h"
 #include "src/__support/CPP/UInt.h"
+#include "src/__support/CPP/limits.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 // This just checks against the C spec, almost all implementations will surpass
 // this.
 TEST(LlvmLibcLimitsTest, LimitsFollowSpec) {
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<int>::max(), INT_MAX);
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<int>::min(), INT_MIN);
+  ASSERT_EQ(cpp::numeric_limits<int>::max(), INT_MAX);
+  ASSERT_EQ(cpp::numeric_limits<int>::min(), INT_MIN);
 
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned int>::max(), UINT_MAX);
+  ASSERT_EQ(cpp::numeric_limits<unsigned int>::max(), UINT_MAX);
 
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long>::max(), LONG_MAX);
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long>::min(), LONG_MIN);
+  ASSERT_EQ(cpp::numeric_limits<long>::max(), LONG_MAX);
+  ASSERT_EQ(cpp::numeric_limits<long>::min(), LONG_MIN);
 
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned long>::max(), ULONG_MAX);
+  ASSERT_EQ(cpp::numeric_limits<unsigned long>::max(), ULONG_MAX);
 
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long long>::max(), LLONG_MAX);
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long long>::min(), LLONG_MIN);
+  ASSERT_EQ(cpp::numeric_limits<long long>::max(), LLONG_MAX);
+  ASSERT_EQ(cpp::numeric_limits<long long>::min(), LLONG_MIN);
 
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned long long>::max(),
-            ULLONG_MAX);
+  ASSERT_EQ(cpp::numeric_limits<unsigned long long>::max(), ULLONG_MAX);
 }
 
 TEST(LlvmLibcLimitsTest, UInt128Limits) {
-  auto umax128 =
-      __llvm_libc::cpp::NumericLimits<__llvm_libc::cpp::UInt<128>>::max();
-  auto umax64 = __llvm_libc::cpp::UInt<128>(
-      __llvm_libc::cpp::NumericLimits<uint64_t>::max());
+  auto umax128 = cpp::numeric_limits<__llvm_libc::cpp::UInt<128>>::max();
+  auto umax64 =
+      __llvm_libc::cpp::UInt<128>(cpp::numeric_limits<uint64_t>::max());
   EXPECT_GT(umax128, umax64);
   ASSERT_EQ(~__llvm_libc::cpp::UInt<128>(0), umax128);
 #ifdef __SIZEOF_INT128__
-  ASSERT_EQ(~__uint128_t(0),
-            __llvm_libc::cpp::NumericLimits<__uint128_t>::max());
+  ASSERT_EQ(~__uint128_t(0), cpp::numeric_limits<__uint128_t>::max());
 #endif
 }
+
+} // namespace __llvm_libc

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

 cc_library(
     name = "__support_cpp_functional",
     hdrs = ["src/__support/CPP/Functional.h"],
     deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_cpp_limits",
-    hdrs = ["src/__support/CPP/Limits.h"],
+    hdrs = ["src/__support/CPP/limits.h"],
     deps = [":libc_root", "__support_cpp_uint"],
 )
 
 cc_library(
     name = "__support_cpp_string_view",
     hdrs = ["src/__support/CPP/StringView.h"],
     deps = [":libc_root"],
 )