[libc][NFC] Use STL case for utility

[gchatelet]

Summary

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

libc/src/__support/CPP/CMakeLists.txt

HDRS
     type_traits.h
   DEPENDS
     .uint
 )
 
 add_header_library(
   utility
   HDRS
-    Utility.h
+    utility.h
 )
 
 add_header_library(
   vector
   HDRS
     vector.h
   DEPENDS
     libc.include.stdlib

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/type_traits.h"
 
 namespace __llvm_libc::cpp {
 
-template <typename T, T... Seq> struct IntegerSequence {
+template <typename T, T... Ints> struct integer_sequence {
   static_assert(is_integral_v<T>);
-  template <T Next> using append = IntegerSequence<T, Seq..., Next>;
+  template <T Next> using append = integer_sequence<T, Ints..., Next>;
 };
 
 namespace internal {
 
-template <typename T, int N> struct MakeIntegerSequence {
-  using type = typename MakeIntegerSequence<T, N - 1>::type::template append<N>;
+template <typename T, int N> struct make_integer_sequence {
+  using type =
+      typename make_integer_sequence<T, N - 1>::type::template append<N>;
 };
 
-template <typename T> struct MakeIntegerSequence<T, -1> {
-  using type = IntegerSequence<T>;
+template <typename T> struct make_integer_sequence<T, -1> {
+  using type = integer_sequence<T>;
 };
 
 } // namespace internal
 
 template <typename T, int N>
-using MakeIntegerSequence =
-    typename internal::MakeIntegerSequence<T, N - 1>::type;
+using make_integer_sequence =
+    typename internal::make_integer_sequence<T, N - 1>::type;
 
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H

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 "src/__support/CPP/utility.h"
 #include "utils/UnitTest/Test.h"
 
 using namespace __llvm_libc::cpp;
 
 TEST(LlvmLibcIntegerSequencetTest, Basic) {
-  EXPECT_TRUE((is_same_v<IntegerSequence<int>, MakeIntegerSequence<int, 0>>));
-  using ISeq = IntegerSequence<int, 0, 1, 2, 3>;
-  EXPECT_TRUE((is_same_v<ISeq, MakeIntegerSequence<int, 4>>));
-  using LSeq = IntegerSequence<long, 0, 1, 2, 3>;
-  EXPECT_TRUE((is_same_v<LSeq, MakeIntegerSequence<long, 4>>));
-  using ULLSeq = IntegerSequence<unsigned long long, 0ull, 1ull, 2ull, 3ull>;
-  EXPECT_TRUE((is_same_v<ULLSeq, MakeIntegerSequence<unsigned long long, 4>>));
+  EXPECT_TRUE(
+      (is_same_v<integer_sequence<int>, make_integer_sequence<int, 0>>));
+  using ISeq = integer_sequence<int, 0, 1, 2, 3>;
+  EXPECT_TRUE((is_same_v<ISeq, make_integer_sequence<int, 4>>));
+  using LSeq = integer_sequence<long, 0, 1, 2, 3>;
+  EXPECT_TRUE((is_same_v<LSeq, make_integer_sequence<long, 4>>));
+  using ULLSeq = integer_sequence<unsigned long long, 0ull, 1ull, 2ull, 3ull>;
+  EXPECT_TRUE(
+      (is_same_v<ULLSeq, make_integer_sequence<unsigned long long, 4>>));
 }
 
-template <typename T, T... Ts>
-bool checkArray(IntegerSequence<T, Ts...> seq) {
+template <typename T, T... Ts> bool checkArray(integer_sequence<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>{}));
+  EXPECT_TRUE(checkArray(make_integer_sequence<int, 100>{}));
 }

libc/test/src/stdlib/atexit_test.cpp

 //===-- Unittests for atexit ----------------------------------------------===//
 //
 // 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/Array.h"
-#include "src/__support/CPP/Utility.h"
+#include "src/__support/CPP/utility.h"
 #include "src/stdlib/atexit.h"
 #include "src/stdlib/exit.h"
 #include "utils/UnitTest/Test.h"
 
 static int a;
 TEST(LlvmLibcAtExit, Basic) {
   // In case tests ever run multiple times.
   a = 0;
TEST(LlvmLibcAtExit, AtExitCallsSysExit) {
   };
   EXPECT_EXITS(test, 1);
 }
 
 static int size;
 static __llvm_libc::cpp::Array<int, 256> arr;
 
 template <int... Ts>
-void register_atexit_handlers(__llvm_libc::cpp::IntegerSequence<int, Ts...>) {
+void register_atexit_handlers(__llvm_libc::cpp::integer_sequence<int, Ts...>) {
   (__llvm_libc::atexit(+[] { arr[size++] = Ts; }), ...);
 }
 
 template <int count> constexpr auto getTest() {
   return [] {
     __llvm_libc::atexit(+[] {
       if (size != count)
         __builtin_trap();
       for (int i = 0; i < count; i++)
         if (arr[i] != count - 1 - i)
           __builtin_trap();
     });
     register_atexit_handlers(
-        __llvm_libc::cpp::MakeIntegerSequence<int, count>{});
+        __llvm_libc::cpp::make_integer_sequence<int, count>{});
     __llvm_libc::exit(0);
   };
 }
 
 TEST(LlvmLibcAtExit, ReverseOrder) {
   // In case tests ever run multiple times.
   size = 0;
 

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

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