[cpyrt] Take element type of std::initializer_list args from the class

Almost every constructor of a standard container has a
std::initializer_list<T> argument, and each of them resolved a type
from its spelling, which declares new code:

- GetPriority() resolved the argument name through GetScope(), which
  deliberately maps std::initializer_list<T> to std::vector<T>, a
  mapping the ranking of overloads relies on. This declared a new
  trampoline variable on every call.
- CreateConverter() and the InitializerListConverter resolved the
  element type T from a substring of the type name.

Take T from the template arguments of the std::initializer_list class
instead, and instantiate std::vector<T> from it directly for the
ranking. Names like std::vector<std::initializer_list<int>>, where the
list is not the argument class itself, still go through GetScope().

Add interop wrappers for Cpp::GetClassTemplateInstantiationArgs() and
Cpp::GetUnderlyingType().

For example:

    import time
    import cppjit

    cppjit.cppdef("#include <set>\n#include <list>\n#include <vector>\n#include <utility>\n")

    types = ["int", "long", "short", "char", "float", "double",
             "unsigned int", "unsigned long"]
    pairs = [f"std::pair<{a}, {b}>" for a, b in
             [("int", "int"), ("long", "double"), ("double", "double"),
              ("short", "short"), ("float", "float"), ("long", "long"),
              ("unsigned int", "unsigned long"), ("char", "char")]]

    classes = ([cppjit.gbl.std.set[t] for t in types] +
               [cppjit.gbl.std.list[t] for t in types] +
               [cppjit.gbl.std.vector[p] for p in pairs])

    start = time.perf_counter()
    for cls in classes:
        cls()  # first construction of each class
    print(f"first construction of {len(classes)} container classes: {1000 * (time.perf_counter() - start):.0f} ms")

This takes about 645 ms instead of 690 ms (median of 3 trials, Linux
x86_64, Python 3.14, CppInterOp/LLVM 22.1.8). The savings grow with the
number of distinct container instantiations created for the first time.

Author: guitargeek

src/cpyrt/CPPMethod.cxx

@@ -525,7 +525,29 @@ int cpyrt::CPPMethod::GetPriority() {
 
       // prefer more derived classes
       const std::string& clean_name = TypeManip::clean_type(aname, false);
-      interop::TCppScope_t scope = interop::GetScope(clean_name);
+      interop::TCppScope_t scope;
+      if (clean_name.find('<') != std::string::npos &&
+          clean_name.find("initializer_list") != std::string::npos) {
+        // GetScope() deliberately resolves std::initializer_list<T> as
+        // std::vector<T>, which the ranking relies on; but resolving the
+        // spelling declares a new trampoline on every call. Take the element
+        // type from the argument class and instantiate std::vector<T> from
+        // it directly. Names where the list is not the argument class itself
+        // (e.g. std::vector<std::initializer_list<int>>) still go through
+        // GetScope().
+        interop::TCppScope_t list =
+            interop::GetScopeFromType(interop::GetUnderlyingType(
+                interop::GetMethodArgType(fMethod, iarg)));
+        std::vector<Cpp::TemplateArgInfo> args;
+        if (list && interop::GetName(list) == "initializer_list")
+          interop::GetClassTemplateInstantiationArgs(list, args);
+        scope = args.size() == 1
+                    ? interop::InstantiateTemplate(
+                          interop::GetNamed("vector", interop::GetNamed("std")),
+                          args.data(), args.size())
+                    : interop::GetScope(clean_name);
+      } else
+        scope = interop::GetScope(clean_name);
       if (scope)
         priority += static_cast<int>(interop::GetNumBasesLongestBranch(scope));
 

src/cpyrt/Converters.cxx

@@ -3230,9 +3230,23 @@ struct faux_initlist {
 cpyrt::InitializerListConverter::InitializerListConverter(
     interop::TCppScope_t klass, std::string const& value_type)
 
+    : InitializerListConverter{klass, value_type,
+                               interop::GetType(value_type, true)} {}
+
+cpyrt::InitializerListConverter::InitializerListConverter(
+    interop::TCppScope_t klass, std::string const& value_type,
+    interop::TCppType_t value_ctype)
+
     : InstanceConverter{klass}, fValueTypeName{value_type},
-      fValueType{interop::GetScope(value_type)},
-      fValueSize{interop::SizeOfType(interop::GetType(value_type, true))} {}
+      fValueType{interop::IsClassType(value_ctype)
+                     ? interop::GetScopeFromType(value_ctype)
+                     : nullptr},
+      fValueSize{0} {
+  // like GetScope(), make sure a class template instance is defined
+  if (fValueType)
+    interop::IsComplete(fValueType);
+  fValueSize = interop::SizeOfType(value_ctype);
+}
 
 cpyrt::InitializerListConverter::~InitializerListConverter() {
   for (Converter* converter : fConverters) {
@@ -3781,14 +3795,21 @@ cppjit::cpyrt::CreateConverter(interop::TCppType_t type, cdims_t dims) {
 
   //-- special case: initializer list
   if (realTypeStr.compare(0, 21, "std::initializer_list") == 0) {
-    // get the type of the list and create a converter (TODO: get hold of
-    // value_type?)
+    // get the type of the list and create a converter
     auto pos = realTypeStr.find('<');
     std::string value_type =
         realTypeStr.substr(pos + 1, realTypeStr.size() - pos - 2);
+    // take the element type from the class, as resolving its spelling
+    // declares new code
+    interop::TCppScope_t list = interop::GetScopeFromType(realType);
+    std::vector<Cpp::TemplateArgInfo> args;
+    interop::GetClassTemplateInstantiationArgs(list, args);
+    interop::TCppType_t value_ctype = args.size() == 1
+                                          ? interop::TCppType_t(args[0].m_Type)
+                                          : interop::GetType(value_type, true);
     Converter* cnv = nullptr;
     bool use_byte_cnv = false;
-    if (cpd == "" && interop::GetScope(value_type)) {
+    if (cpd == "" && interop::IsClassType(value_ctype)) {
       // initializer list of object values does not work as the target is raw
       // memory; simply use byte copies
 
@@ -3797,8 +3818,7 @@ cppjit::cpyrt::CreateConverter(interop::TCppType_t type, cdims_t dims) {
     } else
       cnv = CreateConverter(value_type);
     if (cnv || use_byte_cnv)
-      return new InitializerListConverter(interop::GetScopeFromType(realType),
-                                          value_type);
+      return new InitializerListConverter(list, value_type, value_ctype);
   }
 
   //-- still nothing? use a generalized converter

src/cpyrt/DeclareConverters.h

@@ -515,6 +515,9 @@ class InitializerListConverter : public InstanceConverter {
 public:
   InitializerListConverter(interop::TCppScope_t klass,
                            std::string const& value_type);
+  InitializerListConverter(interop::TCppScope_t klass,
+                           std::string const& value_type,
+                           interop::TCppType_t value_ctype);
   InitializerListConverter(const InitializerListConverter&) = delete;
   InitializerListConverter& operator=(const InitializerListConverter&) = delete;
   virtual ~InitializerListConverter();

src/interop/cppjit_interop.h

@@ -57,6 +57,8 @@ std::string ResolveName(const std::string& cppitem_name);
 RPY_EXPORTED
 TCppType_t ResolveType(TCppType_t cppitem_name);
 RPY_EXPORTED
+TCppType_t GetUnderlyingType(TCppType_t type);
+RPY_EXPORTED
 TCppType_t ResolveEnumReferenceType(TCppType_t type);
 RPY_EXPORTED
 TCppType_t ResolveEnumPointerType(TCppType_t type);
@@ -388,6 +390,9 @@ long long GetEnumDataValue(TCppScope_t scope);
 RPY_EXPORTED
 TCppScope_t InstantiateTemplate(TCppScope_t tmpl, Cpp::TemplateArgInfo* args,
                                 size_t args_size);
+RPY_EXPORTED
+void GetClassTemplateInstantiationArgs(TCppScope_t templ_instance,
+                                       std::vector<Cpp::TemplateArgInfo>& args);
 
 RPY_EXPORTED
 void DumpScope(TCppScope_t scope);

src/interop/interop_wrapper.cxx

@@ -720,6 +720,11 @@ interop::TCppScope_t interop::GetScopeFromType(TCppType_t type) {
   return Cpp::GetScopeFromType(type);
 }
 
+interop::TCppType_t interop::GetUnderlyingType(TCppType_t type) {
+  std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
+  return Cpp::GetUnderlyingType(type);
+}
+
 interop::TCppType_t interop::GetTypeFromScope(TCppScope_t klass) {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   return Cpp::GetTypeFromScope(klass);
@@ -1776,6 +1781,12 @@ interop::TCppScope_t interop::InstantiateTemplate(TCppScope_t tmpl,
                                   /*instantiate_body=*/false);
 }
 
+void interop::GetClassTemplateInstantiationArgs(
+    TCppScope_t templ_instance, std::vector<Cpp::TemplateArgInfo>& args) {
+  std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
+  Cpp::GetClassTemplateInstantiationArgs(templ_instance, args);
+}
+
 void interop::DumpScope(TCppScope_t scope) {
   std::lock_guard<std::recursive_mutex> Lock(InterOpMutex);
   Cpp::DumpScope(scope);