[libc][NFC] Use a function instead of templated static member functions for TYPE_DESC

[gchatelet]

Summary

I'm surprised that clang accepts the current code.
It seems odd to me to specialize templated static member variables.

GCC rejects them: https://godbolt.org/z/3ecE9Ps7T

This patch is in the context of https://github.com/llvm/llvm-project/issues/59368

[michaelrj]

LGTM

libc/src/stdio/printf_core/CMakeLists.txt

HDRS
     parser.h
   DEPENDS
     .core_structs
     libc.src.__support.arg_list
     libc.src.__support.ctype_utils
     libc.src.__support.str_to_integer
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.string_view
+    libc.src.__support.CPP.type_traits
 )
 
 add_object_library(
   string_writer
   SRCS
     string_writer.cpp
   HDRS
     string_writer.h

libc/src/stdio/printf_core/parser.h

 //===-- Format string parser 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_PARSER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PARSER_H
 
+#include "src/__support/CPP/type_traits.h"
 #include "src/__support/arg_list.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/printf_config.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
   // parse_index parses the index of a value inside a format string. It
   // assumes that str[*local_pos] points to character after a '%' or '*', and
   // returns 0 if there is no closing $, or if it finds no number. If it finds a
   // number, it will move local_pos past the end of the $, else it will not move
   // local_pos.
   size_t parse_index(size_t *local_pos);
 
-  template <typename T>
-  static constexpr TypeDesc TYPE_DESC{sizeof(T), PrimaryType::Integer};
-  template <>
-  static constexpr TypeDesc TYPE_DESC<double>{sizeof(double),
-                                              PrimaryType::Float};
-  template <>
-  static constexpr TypeDesc TYPE_DESC<long double>{sizeof(long double),
-                                                   PrimaryType::Float};
-  template <>
-  static constexpr TypeDesc TYPE_DESC<void *>{sizeof(void *),
-                                              PrimaryType::Pointer};
-  template <>
-  static constexpr TypeDesc TYPE_DESC<void>{0, PrimaryType::Integer};
+  template <typename T> static constexpr TypeDesc get_type_desc() {
+    if constexpr (cpp::is_same_v<T, void>) {
+      return TypeDesc{0, PrimaryType::Integer};
+    } else {
+      constexpr bool isPointer = cpp::is_same_v<T, void *>;
+      constexpr bool isFloat =
+          cpp::is_same_v<T, double> || cpp::is_same_v<T, long double>;
+      return TypeDesc{sizeof(T), isPointer ? PrimaryType::Pointer
+                                 : isFloat ? PrimaryType::Float
+                                           : PrimaryType::Integer};
+    }
+  }
 
   void inline set_type_desc(size_t index, TypeDesc value) {
     if (index != 0 && index <= DESC_ARR_LEN)
       desc_arr[index - 1] = value;
   }
 
   // get_arg_value gets the value from the arg list at index (starting at 1).
   // This may require parsing the format string. An index of 0 is interpreted as
   // the next value.
   template <class T> T inline get_arg_value(size_t index) {
     if (!(index == 0 || index == args_index))
       args_to_index(index);
 
-    set_type_desc(index, TYPE_DESC<T>);
+    set_type_desc(index, get_type_desc<T>());
 
     ++args_index;
     return get_next_arg_value<T>();
   }
 
   // the ArgList can only return the next item in the list. This function is
   // used in index mode when the item that needs to be read is not the next one.
   // It moves cur_args to the index requested so the the appropriate value may

libc/src/stdio/printf_core/parser.cpp

if (str[local_pos] == '%') {
       // them so they're parsed but the result is discarded.
       parse_flags(&local_pos);
 
       // handle width
       if (str[local_pos] == '*') {
         ++local_pos;
 
         size_t width_index = parse_index(&local_pos);
-        set_type_desc(width_index, TYPE_DESC<int>);
+        set_type_desc(width_index, get_type_desc<int>());
         if (width_index == index)
-          return TYPE_DESC<int>;
+          return get_type_desc<int>();
 
       } else if (internal::isdigit(str[local_pos])) {
         while (internal::isdigit(str[local_pos]))
           ++local_pos;
       }
 
       // handle precision
       if (str[local_pos] == '.') {
         ++local_pos;
         if (str[local_pos] == '*') {
           ++local_pos;
 
           size_t precision_index = parse_index(&local_pos);
-          set_type_desc(precision_index, TYPE_DESC<int>);
+          set_type_desc(precision_index, get_type_desc<int>());
           if (precision_index == index)
-            return TYPE_DESC<int>;
+            return get_type_desc<int>();
 
         } else if (internal::isdigit(str[local_pos])) {
           while (internal::isdigit(str[local_pos]))
             ++local_pos;
         }
       }
 
       LengthModifier lm = parse_length_modifier(&local_pos);
 
       // if we don't have an index for this conversion, then its position is
       // unknown and all this information is irrelevant. The rest of this logic
       // has been for skipping past this conversion properly to avoid
       // weirdness with %%.
       if (conv_index == 0) {
         ++local_pos;
         continue;
       }
 
-      TypeDesc conv_size = TYPE_DESC<void>;
+      TypeDesc conv_size = get_type_desc<void>();
       switch (str[local_pos]) {
       case ('%'):
-        conv_size = TYPE_DESC<void>;
+        conv_size = get_type_desc<void>();
         break;
       case ('c'):
-        conv_size = TYPE_DESC<int>;
+        conv_size = get_type_desc<int>();
         break;
       case ('d'):
       case ('i'):
       case ('o'):
       case ('x'):
       case ('X'):
       case ('u'):
         switch (lm) {
         case (LengthModifier::hh):
         case (LengthModifier::h):
         case (LengthModifier::none):
-          conv_size = TYPE_DESC<int>;
+          conv_size = get_type_desc<int>();
           break;
         case (LengthModifier::l):
-          conv_size = TYPE_DESC<long>;
+          conv_size = get_type_desc<long>();
           break;
         case (LengthModifier::ll):
         case (LengthModifier::L): // This isn't in the standard, but is in other
                                   // libc implementations.
-          conv_size = TYPE_DESC<long long>;
+          conv_size = get_type_desc<long long>();
           break;
         case (LengthModifier::j):
-          conv_size = TYPE_DESC<intmax_t>;
+          conv_size = get_type_desc<intmax_t>();
           break;
         case (LengthModifier::z):
-          conv_size = TYPE_DESC<size_t>;
+          conv_size = get_type_desc<size_t>();
           break;
         case (LengthModifier::t):
-          conv_size = TYPE_DESC<ptrdiff_t>;
+          conv_size = get_type_desc<ptrdiff_t>();
           break;
         }
         break;
 #ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
       case ('f'):
       case ('F'):
       case ('e'):
       case ('E'):
       case ('a'):
       case ('A'):
       case ('g'):
       case ('G'):
         if (lm != LengthModifier::L)
-          conv_size = TYPE_DESC<double>;
+          conv_size = get_type_desc<double>();
         else
-          conv_size = TYPE_DESC<long double>;
+          conv_size = get_type_desc<long double>();
         break;
 #endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
 #ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
       case ('n'):
 #endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
       case ('p'):
       case ('s'):
-        conv_size = TYPE_DESC<void *>;
+        conv_size = get_type_desc<void *>();
         break;
       default:
-        conv_size = TYPE_DESC<int>;
+        conv_size = get_type_desc<int>();
         break;
       }
 
       set_type_desc(conv_index, conv_size);
       if (conv_index == index)
         return conv_size;
     }
     // If the end of the format section is on the '\0'. This means we need to
     // not advance the local_pos.
     if (str[local_pos] != '\0')
       ++local_pos;
   }
 
   // If there is no size for the requested index, then just guess that it's an
   // int.
-  return TYPE_DESC<int>;
+  return get_type_desc<int>();
 }
 
 void Parser::args_to_index(size_t index) {
   if (args_index > index) {
     args_index = 1;
     args_cur = args_start;
   }
 
   while (args_index < index) {
-    Parser::TypeDesc cur_type_desc = TYPE_DESC<void>;
+    Parser::TypeDesc cur_type_desc = get_type_desc<void>();
     if (args_index <= DESC_ARR_LEN)
       cur_type_desc = desc_arr[args_index - 1];
 
-    if (cur_type_desc == TYPE_DESC<void>)
+    if (cur_type_desc == get_type_desc<void>())
       cur_type_desc = get_type_desc(args_index);
 
-    if (cur_type_desc == TYPE_DESC<uint32_t>)
+    if (cur_type_desc == get_type_desc<uint32_t>())
       args_cur.next_var<uint32_t>();
-    else if (cur_type_desc == TYPE_DESC<uint64_t>)
+    else if (cur_type_desc == get_type_desc<uint64_t>())
       args_cur.next_var<uint64_t>();
 #ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
     // Floating point numbers are stored separately from the other arguments.
-    else if (cur_type_desc == TYPE_DESC<double>)
+    else if (cur_type_desc == get_type_desc<double>())
       args_cur.next_var<double>();
-    else if (cur_type_desc == TYPE_DESC<long double>)
+    else if (cur_type_desc == get_type_desc<long double>())
       args_cur.next_var<long double>();
 #endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
     // pointers may be stored separately from normal values.
-    else if (cur_type_desc == TYPE_DESC<void *>)
+    else if (cur_type_desc == get_type_desc<void *>())
       args_cur.next_var<void *>();
     else
       args_cur.next_var<uint32_t>();
 
     ++args_index;
   }
 }
 
 #endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
 } // namespace printf_core
 } // namespace __llvm_libc