[libc][NFC] clean int to string static templates

libc/src/__support/integer_to_string.h

 
 #include "src/__support/CPP/ArrayRef.h"
 #include "src/__support/CPP/StringView.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 
-template <typename T, uint8_t BASE = 10> class IntegerToString {
+template <typename T, uint8_t BASE = 10,
+          cpp::enable_if_t<2 <= BASE && BASE <= 36, int> = 0>
+class IntegerToString {
 public:
   static constexpr inline size_t floor_log_2(size_t num) {
     size_t i = 0;
     for (; num > 1; num /= 2) {
       ++i;
     }
     return i;
   }
public:
   // 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.
   // For other bases, we approximate by rounding down to the nearest power of
   // two base, since the space needed is easy to calculate and it won't
   // overestimate by too much.
 
-  template <uint8_t STATIC_BASE> static constexpr size_t bufsize() {
-    constexpr size_t BITS_PER_DIGIT = floor_log_2(STATIC_BASE);
+  static constexpr size_t bufsize() {
+    constexpr size_t BITS_PER_DIGIT = floor_log_2(BASE);
     constexpr size_t BUFSIZE_COMMON =
         ((sizeof(T) * 8 + (BITS_PER_DIGIT - 1)) / BITS_PER_DIGIT);
     constexpr size_t BUFSIZE_BASE10 = (sizeof(T) * 5 + 1) / 2;
     return (cpp::is_signed<T>() ? 1 : 0) +
-           (STATIC_BASE == 10 ? BUFSIZE_BASE10 : BUFSIZE_COMMON);
+           (BASE == 10 ? BUFSIZE_BASE10 : BUFSIZE_COMMON);
   }
 
-  static constexpr size_t BUFSIZE = bufsize<BASE>();
+  static constexpr size_t BUFSIZE = bufsize();
 
 private:
   static_assert(cpp::is_integral_v<T>,
                 "IntegerToString can only be used with integral types.");
 
   using UnsignedType = cpp::make_unsigned_t<T>;
 
   char strbuf[BUFSIZE] = {'\0'};
convert_alpha_numeric(T val, cpp::MutableArrayRef<char> &buffer,
     cpp::StringView buff_str(buffer.data() + buffer.size() - len, len);
     return buff_str;
   }
 
   // This function exists to check at compile time that the base is valid, as
   // well as to convert the templated call into a non-templated call. This
   // allows the compiler to decide to do strength reduction and constant folding
   // on the base or not, depending on if size or performance is required.
-  template <uint8_t STATIC_BASE = BASE,
-            cpp::enable_if_t<2 <= STATIC_BASE && STATIC_BASE <= 36, int> = 0>
   static inline constexpr cpp::StringView
   convert_internal(T val, cpp::MutableArrayRef<char> &buffer, bool lowercase) {
-    return convert_alpha_numeric(val, buffer, lowercase, STATIC_BASE);
+    return convert_alpha_numeric(val, buffer, lowercase, BASE);
   }
 
 public:
-  template <uint8_t STATIC_BASE = BASE>
   static inline cpp::optional<cpp::StringView>
   convert(T val, cpp::MutableArrayRef<char> &buffer, bool lowercase) {
     // If This function can actually be a constexpr, then the below "if" will be
     // optimized out.
-    if (buffer.size() < bufsize<STATIC_BASE>())
+    if (buffer.size() < bufsize())
       return cpp::optional<cpp::StringView>();
     return cpp::optional<cpp::StringView>(
-        convert_internal<STATIC_BASE>(val, buffer, lowercase));
+        convert_internal(val, buffer, lowercase));
   }
 
   constexpr explicit IntegerToString(T val) {
     cpp::MutableArrayRef<char> bufref(strbuf, BUFSIZE);
-    str_view = convert_internal<BASE>(val, bufref, true);
+    str_view = convert_internal(val, bufref, true);
   }
 
   constexpr explicit IntegerToString(T val, bool lowercase) {
     cpp::MutableArrayRef<char> bufref(strbuf, BUFSIZE);
-    str_view = convert_internal<BASE>(val, bufref, lowercase);
+    str_view = convert_internal(val, bufref, lowercase);
   }
 
   cpp::StringView str() const { return str_view; }
 
   operator cpp::StringView() const { return str(); }
 };
 
 template <typename T> IntegerToString<T> integer_to_string(T val) {
   return IntegerToString<T>(val);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H