interop_wrapper.cxx

Go to the documentation of this file.

#ifndef _WIN32
#ifndef _CRT_SECURE_NO_WARNINGS
// silence warnings about getenv, strncpy, etc.
#define _CRT_SECURE_NO_WARNINGS
#endif
#endif
 
#include "precommondefs.h" // This defines several system feature macros and should be included before any system header.
 
// Bindings
#include "cppjit_interop.h"
 
using namespace cppjit;
#include "callcontext.h"
 
// ROOT
#include "TClass.h"
#include "TInterpreter.h"
#include "TROOT.h"
#include "TSystem.h"
 
typedef cppjit::cpyrt::Parameter Parameter;
 
static inline size_t CALL_NARGS(size_t nargs) { return nargs & ~DIRECT_CALL; }
 
// Standard
#include <algorithm> // for std::count, std::remove
#include <array>
#include <cassert>
#include <csignal>
#include <cstdlib> // for getenv
#include <cstring>
#include <iostream>
#include <map>
#include <mutex>
#include <new>
#include <regex>
#include <set>
#include <sstream>
#include <stdexcept>
#include <typeinfo>
#include <vector>
 
// Take ROOT's interpreter lock (when it exists) around every CppInterOp
// entry point, so Python-side reflection serializes against TCling users on
// other threads (I/O, RDataFrame workers).
// The private recursive mutex still serializes concurrent Python-side callers
// when ROOT thread safety is not enabled. Lock order is global-then-local; no
// deadlock is possible since threads coming through TCling only ever take the
// global mutex.
class RInterOpMutex {
public:
  void lock() {
    // gInterpreterMutex may get created at any point (by
    // ROOT::EnableThreadSafety), so remember for each acquisition what was
    // actually locked, to release exactly that in unlock().
    TVirtualMutex* global = gInterpreterMutex;
    if (global)
      global->Lock();
    fLocal.lock();
    fGlobalLocked.push_back(global);
  }
 
  void unlock() {
    TVirtualMutex* global = fGlobalLocked.back();
    fGlobalLocked.pop_back();
    fLocal.unlock();
    if (global)
      global->UnLock();
  }
 
private:
  std::recursive_mutex fLocal;
  // Lock/unlock pairs are properly nested per thread, so a per-thread stack
  // suffices to match each unlock() to its lock().
  static thread_local std::vector<TVirtualMutex*> fGlobalLocked;
};
 
thread_local std::vector<TVirtualMutex*> RInterOpMutex::fGlobalLocked;
 
RInterOpMutex InterOpMutex;
 
// builtin types
static std::set<std::string> g_builtins = {"bool",
                                           "char",
                                           "signed char",
                                           "unsigned char",
                                           "wchar_t",
                                           "short",
                                           "unsigned short",
                                           "int",
                                           "unsigned int",
                                           "long",
                                           "unsigned long",
                                           "long long",
                                           "unsigned long long",
                                           "float",
                                           "double",
                                           "long double",
                                           "void"};
 
// configuration
static bool gEnableFastPath = true;
 
// global initialization -----------------------------------------------------
namespace {
 
static inline bool is_integral(std::string& s) {
  if (s == "false") {
    s = "0";
    return true;
  } else if (s == "true") {
    s = "1";
    return true;
  }
  return !s.empty() && std::find_if(s.begin(), s.end(), [](unsigned char c) {
                         return !std::isdigit(c);
                       }) == s.end();
}
 
struct InterOpPaths {
  std::string Library;
  std::vector<std::string> IncludeDirs;
  std::string ClangIncludeDir; // empty when no usable resource dir is known
};
 
// In ROOT the dispatch API comes from libCling (loadDispatchAPI) and the
// CppInterOp headers are staged under ROOT's etc directory, etc/cppinterop
// in the build tree and in the install tree alike, so TROOT::GetEtcDir()
// locates them in both.
static InterOpPaths cppinterop_paths() {
  InterOpPaths Paths;
  std::string dir = TROOT::GetEtcDir().Data();
  dir += "/cppinterop";
  if (gSystem->AccessPathName(dir.c_str()))
    std::cerr << "[cppjit] CppInterOp headers not found in " << dir
              << std::endl;
  Paths.IncludeDirs.push_back(dir);
  return Paths;
}
 
// The one place the dispatch source is dlopen'd. In ROOT, CppInterOp is
// compiled into libCling, so the dispatch API is loaded from there instead of
// from a standalone libclangCppInterOp.
static bool loadDispatchAPI(const InterOpPaths& /*Paths*/) {
  (void)gROOT;
  char* libcling = gSystem->DynamicPathName("libCling");
 
  if (!libcling) {
    std::cerr << "[cppjit] Failed to find libCling" << std::endl;
    return false;
  }
  if (!Cpp::LoadDispatchAPI(libcling)) {
    std::cerr << "[cppjit] Failed to load CppInterOp" << std::endl;
    return false;
  }
  return true;
}
 
// CppInterOp itself appends CPPINTEROP_EXTRA_INTERPRETER_ARGS inside
// CreateInterpreter, so nothing needs to be forwarded from here.
static interop::TInterp_t
acquireOrCreateInterpreter(const InterOpPaths& Paths) {
  if (auto existingInterp = Cpp::GetInterpreter())
    return existingInterp;
 
  std::vector<const char*> args = {"-std=c++17"};
#if !(defined(__arm64__) && defined(__APPLE__))
  // apple silicon clang rejects -march=native
  args.push_back("-march=native");
#endif
  // Without clang's builtin headers the interpreter fails at its first
  // #include. Prefer the bundled copy: it matches the build clang and
  // needs no LLVM on the host. DetectResourceDir refuses version
  // mismatches, and CppInterOp itself probes only bare `clang`.
  std::string resourceDir = Paths.ClangIncludeDir;
  if (resourceDir.empty())
    resourceDir = Cpp::DetectResourceDir("clang-" CPPJIT_CLANG_MAJOR);
  if (!resourceDir.empty()) {
    args.push_back("-resource-dir");
    args.push_back(resourceDir.c_str());
  }
  return Cpp::CreateInterpreter(args, /*GpuArgs=*/{});
}
 
static void configureInterpreter(const InterOpPaths& Paths) {
  std::set<std::string> bi{g_builtins};
  for (const auto& name : bi) {
    for (const char* a : {"*", "&", "*&", "[]", "*[]"})
      g_builtins.insert(name + a);
  }
 
  if (getenv("CPPJIT_DISABLE_FASTPATH"))
    gEnableFastPath = false;
 
  // set opt level (default to 2 if not given; Cling itself defaults to 0)
  int optLevel = 2;
 
  if (getenv("CPPJIT_OPT_LEVEL"))
    optLevel = atoi(getenv("CPPJIT_OPT_LEVEL"));
 
  if (optLevel != 0) {
    std::ostringstream s;
    s << "#pragma cling optimize " << optLevel;
    Cpp::Process(s.str().c_str());
  }
 
  for (const std::string& dir : Paths.IncludeDirs)
    Cpp::AddIncludePath(dir.c_str());
  Cpp::LoadLibrary("libstdc++", /* lookup= */ true);
}
 
static bool preloadHeaders() {
  const char* code = "#include <algorithm>\n"
                     "#include <numeric>\n"
                     "#include <complex>\n"
                     "#include <iostream>\n"
                     "#include <string.h>\n" // for strcpy
                     "#include <string>\n"
                     "#include <vector>\n"
                     "#include <utility>\n"
                     "#include <memory>\n"
                     "#include <functional>\n" // for the dispatcher code to
                                               // use std::function
                     "#include <map>\n"        // FIXME: Replace with modules
                     "#include <sstream>\n"    // FIXME: Replace with modules
                     "#include <array>\n"      // FIXME: Replace with modules
                     "#include <list>\n"       // FIXME: Replace with modules
                     "#include <deque>\n"      // FIXME: Replace with modules
                     "#include <tuple>\n"      // FIXME: Replace with modules
                     "#include <set>\n"        // FIXME: Replace with modules
                     "#include <chrono>\n"     // FIXME: Replace with modules
                     "#include <cmath>\n"      // FIXME: Replace with modules
                     "#if __has_include(<optional>)\n"
                     "#include <optional>\n"
                     "#endif\n"
                     "#include <CppInterOp/Dispatch.h>\n";
  return Cpp::Process(code) == 0;
}
 
static void defineRuntimeHelpers() {
  Cpp::Declare("namespace __cppjit_internal { template<class C1, class C2>"
               " bool is_equal(const C1& c1, const C2& c2) { return "
               "(bool)(c1 == c2); } }",
               /*silent=*/false);
  Cpp::Declare("namespace __cppjit_internal { template<class C1, class C2>"
               " bool is_not_equal(const C1& c1, const C2& c2) { return "
               "(bool)(c1 != c2); } }",
               /*silent=*/false);
 
  // helper for multiple inheritance
  Cpp::Declare("namespace __cppjit_internal { struct Sep; }",
               /*silent=*/false);
}
 
} // unnamed namespace
 
// Load CppInterOp and set up the interpreter. A dlopen during static
// initialization is unsafe, so _cpython_cppjit.py calls this explicitly
// before the first libcppjit use. Thread-safe and idempotent; returns 1 on
// success.
extern "C" {
RPY_EXPORTED int LoadCppInterOp();
}
 
extern "C" int LoadCppInterOp() {
  static std::once_flag Once;
  static int Loaded = 0;
  std::call_once(Once, [] {
    std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
    const InterOpPaths Paths = cppinterop_paths();
    if (!loadDispatchAPI(Paths))
      return;
 
    if (!acquireOrCreateInterpreter(Paths)) {
      std::cerr << "[cppjit] Failed to create the C++ interpreter" << std::endl;
      return;
    }
    configureInterpreter(Paths);
    if (!preloadHeaders()) {
      std::cerr << "[cppjit] The C++ standard headers do not parse, see the "
                   "diagnostic above. Install a C++ toolchain such as g++ or "
                   "the conda package cxx-compiler."
                << std::endl;
      return;
    }
    defineRuntimeHelpers();
 
    Loaded = 1;
  });
  return Loaded;
}
 
// local helpers -------------------------------------------------------------
static inline char* cppstring_to_cstring(const std::string& cppstr) {
  char* cstr = (char*)malloc(cppstr.size() + 1);
  memcpy(cstr, cppstr.c_str(), cppstr.size() + 1);
  return cstr;
}
 
// direct interpreter access -------------------------------------------------
// Returns false on failure and true on success
bool interop::Compile(const std::string& code, bool silent) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  // Declare returns an enum which equals 0 on success
  return !Cpp::Declare(code.c_str(), silent);
}
 
void interop::LockInterpreter() { InterOpMutex.lock(); }
 
void interop::UnlockInterpreter() { InterOpMutex.unlock(); }
 
std::string interop::ToString(TCppScope_t klass, TCppObject_t obj) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  if (klass && obj && !Cpp::IsNamespace(klass))
    return Cpp::ObjToString(Cpp::GetQualifiedCompleteName(klass).c_str(),
                            obj.data);
  return "";
}
 
// // name to opaque C++ scope representation
// -----------------------------------
std::string interop::ResolveName(const std::string& name) {
  if (!name.empty()) {
    if (interop::TCppType_t type =
            interop::GetType(name, /*enable_slow_lookup=*/true))
      return interop::GetTypeAsString(interop::ResolveType(type));
    return name;
  }
  return "";
}
 
interop::TCppType_t interop::ResolveEnumReferenceType(TCppType_t type) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  if (Cpp::GetValueKind(type) != Cpp::ValueKind::LValue)
    return type;
 
  TCppType_t nonReferenceType = Cpp::GetNonReferenceType(type);
  if (Cpp::IsEnumType(nonReferenceType)) {
    TCppType_t underlying_type =
        Cpp::GetIntegerTypeFromEnumType(nonReferenceType);
    return Cpp::GetReferencedType(underlying_type, /*rvalue=*/false);
  }
  return type;
}
 
interop::TCppType_t interop::ResolveEnumPointerType(TCppType_t type) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  if (!Cpp::IsPointerType(type))
    return type;
 
  TCppType_t PointeeType = Cpp::GetPointeeType(type);
  if (Cpp::IsEnumType(PointeeType)) {
    TCppType_t underlying_type = Cpp::GetIntegerTypeFromEnumType(PointeeType);
    return Cpp::GetPointerType(underlying_type);
  }
  return type;
}
 
interop::TCppType_t int_like_type(interop::TCppType_t type) {
  interop::TCppType_t check_int_typedefs = type;
  if (Cpp::IsPointerType(check_int_typedefs))
    check_int_typedefs = Cpp::GetPointeeType(check_int_typedefs);
  if (Cpp::IsReferenceType(check_int_typedefs))
    check_int_typedefs =
        Cpp::GetReferencedType(check_int_typedefs, /*rvalue=*/false);
 
  if (Cpp::GetTypeAsString(check_int_typedefs) == "int8_t" ||
      Cpp::GetTypeAsString(check_int_typedefs) == "uint8_t")
    return check_int_typedefs;
  return nullptr;
}
 
interop::TCppType_t interop::ResolveType(TCppType_t type) {
  if (!type)
    return type;
 
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  TCppType_t check_int_typedefs = int_like_type(type);
  if (check_int_typedefs)
    return type;
 
  interop::TCppType_t canonType = Cpp::GetCanonicalType(type);
 
  if (Cpp::IsEnumType(canonType)) {
    if (Cpp::GetTypeAsString(type) != "std::byte")
      return Cpp::GetIntegerTypeFromEnumType(canonType);
  }
  if (Cpp::HasTypeQualifier(canonType, Cpp::QualKind::Restrict)) {
    return Cpp::RemoveTypeQualifier(canonType, Cpp::QualKind::Restrict);
  }
 
  return canonType;
}
 
interop::TCppType_t interop::GetRealType(TCppType_t type) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  TCppType_t check_int_typedefs = int_like_type(type);
  if (check_int_typedefs)
    return check_int_typedefs;
  return Cpp::GetUnderlyingType(type);
}
 
interop::TCppType_t interop::GetPointerType(TCppType_t type) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetPointerType(type);
}
 
interop::TCppType_t interop::GetReferencedType(TCppType_t type, bool rvalue) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetReferencedType(type, rvalue);
}
 
bool interop::IsRValueReferenceType(TCppType_t type) {
  return Cpp::GetValueKind(type) == Cpp::ValueKind::RValue;
}
 
bool interop::IsLValueReferenceType(TCppType_t type) {
  return Cpp::GetValueKind(type) == Cpp::ValueKind::LValue;
}
 
// Whether the callee can rebind a pointer through this reference (T*&);
// false for T* const& and for references to non-pointers.
bool interop::IsMutablePtrRefType(TCppType_t type) {
  if (!Cpp::IsReferenceType(type))
    return false;
  TCppType_t nonref = Cpp::GetNonReferenceType(type);
  return Cpp::IsPointerType(nonref) &&
         !Cpp::HasTypeQualifier(nonref, Cpp::QualKind::Const);
}
 
bool interop::IsClassType(TCppType_t type) { return Cpp::IsRecordType(type); }
 
bool interop::IsIntegerType(TCppType_t type, bool* is_signed /*= nullptr*/) {
  if (is_signed) {
    Cpp::Signedness sign;
    bool res = Cpp::IsIntegerType(type, &sign);
    *is_signed = (sign == Cpp::Signedness::kSigned);
    return res;
  }
  return Cpp::IsIntegerType(type, nullptr);
}
 
bool interop::IsPointerType(TCppType_t type) {
  return Cpp::IsPointerType(type);
}
 
bool interop::IsFunctionPointerType(TCppType_t type) {
  return Cpp::IsFunctionPointerType(type);
}
 
std::string trim(const std::string& line) {
  if (line.empty())
    return "";
  const char* WhiteSpace = " \t\v\r\n";
  std::size_t start = line.find_first_not_of(WhiteSpace);
  std::size_t end = line.find_last_not_of(WhiteSpace);
  return line.substr(start, end - start + 1);
}
 
// returns false of angular brackets dont match, else true
bool split_comma_saparated_types(const std::string& name,
                                 std::vector<std::string>& types) {
  std::string trimed_name = trim(name);
  size_t start_pos = 0;
  size_t end_pos = 0;
  int matching_angular_brackets = 0;
  while (end_pos < trimed_name.size()) {
    switch (trimed_name[end_pos]) {
    case ',': {
      if (!matching_angular_brackets) {
        if (end_pos > start_pos)
          types.push_back(
              trim(trimed_name.substr(start_pos, end_pos - start_pos)));
        start_pos = end_pos + 1;
      }
      break;
    }
    case '<': {
      matching_angular_brackets++;
      break;
    }
    case '>': {
      matching_angular_brackets--;
      break;
    }
    }
    end_pos++;
  }
  if (start_pos < trimed_name.size())
    types.push_back(trim(trimed_name.substr(start_pos, end_pos - start_pos)));
  return true;
}
 
interop::TCppScope_t GetEnumFromCompleteName(const std::string& name) {
  std::string delim = "::";
  size_t start = 0;
  size_t end = name.find(delim);
  interop::TCppScope_t curr_scope;
  while (end != std::string::npos) {
    curr_scope = Cpp::GetNamed(name.substr(start, end - start), curr_scope);
    start = end + delim.length();
    end = name.find(delim, start);
  }
  return Cpp::GetNamed(name.substr(start, end), curr_scope);
}
static bool is_identifier(std::string_view s) {
  if (s.empty())
    return false;
  auto is_valid_start = [](unsigned char c) {
    return std::isalpha(c) || c == '_';
  };
  auto is_valid_body = [](unsigned char c) {
    return std::isalnum(c) || c == '_';
  };
  return is_valid_start(s[0]) &&
         std::all_of(s.begin() + 1, s.end(), is_valid_body);
};
 
// returns true if no new type was added.
bool interop::AppendTypesSlow(const std::string& name,
                              std::vector<Cpp::TemplateArgInfo>& types,
                              interop::TCppScope_t parent) {
 
  // Add no new type if string is empty
  if (name.empty())
    return true;
 
  // The ast printer gave us garbage.
  if (name == "<unnamed>")
    return true;
 
  // A type inside an anonymous namespace cannot be spelled in injected
  // code; attempting it crashes codegen on the ill-formed recovery (e.g.
  // auto-downcasting to an anonymous FuncExporter<...> instantiation).
  if (name.find("(anonymous namespace)") != std::string::npos)
    return true;
 
  auto replace_all = [](std::string& str, const std::string& from,
                        const std::string& to) {
    if (from.empty())
      return;
    size_t start_pos = 0;
    while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
      str.replace(start_pos, from.length(), to);
      start_pos += to.length();
    }
  };
 
  std::string resolved_name = name;
  replace_all(resolved_name, "std::initializer_list<",
              "std::vector<"); // replace initializer_list with vector
 
  // If we have a single identifier, we don't need anything complicated.
  // Try scoped lookup first (catches type aliases / nested types declared
  // inside `parent`), then fall back to TU (catches typedefs declared
  // outside the query scope, e.g. `typedef Foo Bar;` at TU consulted
  // from a method on Foo).
  if (is_identifier(name)) {
    TCppType_t type = parent ? Cpp::GetType(name, parent) : nullptr;
    if (!type)
      type = Cpp::GetType(name);
    if (type) {
      types.emplace_back(type.data);
      return false;
    }
    if (!parent || parent == Cpp::GetGlobalScope())
      return true;
    // Fall through: the name may live in a scope enclosing `parent` (e.g.
    // "RVecF" from within ROOT::RDF::RInterface<...> resolves to
    // ROOT::RVecF); the trampoline below applies real unqualified lookup.
  }
 
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  // Every lookup below declares code through the interpreter, which parses,
  // commits a transaction and leaves a new declaration in the AST, so each one
  // costs more than the last. The same names come back constantly (overload
  // ranking resolves every argument type of every candidate on each call that
  // is not memoized), so remember what a name resolved to. A name that fails
  // may still resolve once more declarations are available, so only successes
  // are cached.
  using SlowTypesKey = std::pair<std::string, const void*>;
  static std::map<SlowTypesKey, std::vector<Cpp::TemplateArgInfo>> s_cache;
  const SlowTypesKey cache_key{name, parent.data};
  // the integral values are strings whose ownership passes to the caller
  // (which frees them), so the cache keeps and hands out copies of its own
  auto copy_of = [](const Cpp::TemplateArgInfo& info) {
    return Cpp::TemplateArgInfo(info.m_Type, info.m_IntegralValue
                                                 ? strdup(info.m_IntegralValue)
                                                 : nullptr);
  };
  if (auto cached = s_cache.find(cache_key); cached != s_cache.end()) {
    for (const Cpp::TemplateArgInfo& info : cached->second)
      types.push_back(copy_of(info));
    return false;
  }
  const size_t n_types_before = types.size();
  auto remember = [&] {
    std::vector<Cpp::TemplateArgInfo> resolved;
    for (size_t i = n_types_before; i < types.size(); ++i)
      resolved.push_back(copy_of(types[i]));
    s_cache.emplace(cache_key, std::move(resolved));
  };
 
  // We might have an entire expression such as int, double.
  static unsigned long long struct_count = 0;
  std::string code =
      "template<typename ...T> struct __cppjit_interop_AppendTypesSlow {};\n";
  if (!struct_count)
    Cpp::Declare(code.c_str(), /*silent=*/true); // initialize the trampoline
 
  // Perform the lookup from within the innermost (reopenable) namespace
  // enclosing `parent` -- `parent` itself if it is a namespace, else the
  // namespace its class chain lives in -- by reopening that namespace around
  // the trampoline declaration: the compiler then applies real C++ name
  // lookup, walking outward with proper shadowing of outer names, which a
  // global declaration with a parent-qualified fallback cannot emulate (e.g.
  // "RVecF" from within ROOT::RDF::RInterface<...> resolves to ROOT::RVecF).
  std::string lookup_ns;
  TCppScope_t lookup_scope = nullptr;
  for (TCppScope_t s = parent; s && s != Cpp::GetGlobalScope();
       s = Cpp::GetParentScope(s)) {
    if (!Cpp::IsNamespace(s))
      continue;
    std::string qname = Cpp::GetQualifiedName(s);
    if (!qname.empty() && qname.find('(') == std::string::npos) { // unnamed?
      lookup_ns = qname;
      lookup_scope = s;
    }
    break;
  }
 
  // The reopened namespace doesn't see names nested in a class parent, so a
  // name written relative to it (e.g. a nested type) won't resolve. Try the
  // name as given, then qualified by the parent.
  std::vector<std::string> candidates = {resolved_name};
  if (parent && parent != Cpp::GetGlobalScope() && parent != lookup_scope &&
      (interop::IsNamespace(parent) || interop::IsClass(parent)))
    candidates.push_back(Cpp::GetQualifiedCompleteName(parent) +
                         "::" + resolved_name);
 
  for (const std::string& candidate : candidates) {
    std::string var = "__cppjit_interop_s" + std::to_string(struct_count++);
    // nodebug: with -g the variable's debug info would carry the full DIE
    // tree of every template argument (all member declarations included) --
    // a large, uncacheable per-lookup cost on heavyweight types.
    std::string decl = "__cppjit_interop_AppendTypesSlow<" + candidate +
                       "> __attribute__((nodebug)) " + var + ";\n";
    if (!lookup_ns.empty())
      decl = "namespace " + lookup_ns + " { " + decl + "}\n";
    if (!Cpp::Declare(decl.c_str(), /*silent=*/true)) {
      TCppType_t varN = Cpp::GetVariableType(Cpp::GetNamed(
          var.c_str(), lookup_ns.empty() ? nullptr : lookup_scope));
      TCppScope_t instance_class = Cpp::GetScopeFromType(varN);
      if (!instance_class)
        continue; // recovered-but-broken decl; try next candidate or split path
      size_t oldSize = types.size();
      Cpp::GetClassTemplateInstantiationArgs(instance_class, types);
      if (oldSize == types.size())
        return true;
      remember();
      return false;
    }
  }
 
  // We split each individual types based on , and resolve it
  // FIXME: see discussion on should we support template instantiation with
  // string:
  //   https://github.com/compiler-research/cppyy-backend/pull/137#discussion_r2079357491
  //   We should consider eliminating the `split_comma_saparated_types` and
  //   `is_integral` string parsing.
  std::vector<std::string> individual_types;
  if (!split_comma_saparated_types(resolved_name, individual_types))
    return true;
 
  for (std::string& i : individual_types) {
    // Try going via interop::GetType first.
    const char* integral_value = nullptr;
    interop::TCppType_t type = nullptr;
 
    if (!lookup_ns.empty()) {
      // resolve from within the parent namespace, honouring C++ name lookup
      // and shadowing (see the trampoline declaration above)
      std::string id = "__cppjit_interop_s" + std::to_string(struct_count++);
      if (!Cpp::Declare(("namespace " + lookup_ns + " { using " + id +
                         " = __typeof__(" + i + "); }\n")
                            .c_str(),
                        /*silent=*/true))
        type = Cpp::GetCanonicalType(
            Cpp::GetTypeFromScope(Cpp::GetNamed(id, lookup_scope)));
    } else {
      type = GetType(i, /*enable_slow_lookup=*/true);
      if (!type && parent &&
          (interop::IsNamespace(parent) || interop::IsClass(parent))) {
        type =
            interop::GetTypeFromScope(interop::GetNamed(resolved_name, parent));
      }
    }
 
    if (!type) {
      types.clear();
      return true;
    }
 
    if (is_integral(i))
      integral_value = strdup(i.c_str());
    if (TCppScope_t scope = GetEnumFromCompleteName(i))
      if (Cpp::IsEnumConstant(scope))
        integral_value =
            strdup(std::to_string(Cpp::GetEnumConstantValue(scope)).c_str());
    types.emplace_back(type.data, integral_value);
  }
  remember();
  return false;
}
 
interop::TCppType_t interop::GetType(const std::string& name,
                                     bool enable_slow_lookup /* = false */) {
  // The ast printer gave us garbage.
  if (name == "<unnamed>")
    return nullptr;
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  if (auto type = Cpp::GetType(name))
    return type;
 
  // Plain identifiers don't need the heavy __typeof__ trampoline:
  // Cpp::GetType above already covers builtin types and named
  // scopes. Exception: the three identifier-shaped C++ value-
  // literals -- `true`, `false`, `nullptr` -- aren't reachable by
  // name (no type called "false") but appear as non-type template
  // args in libstdc++ types like _Node_iterator<..., false, false>;
  // map them to their underlying type directly so the per-chunk
  // fallback in AppendTypesSlow gets a real type without paying
  // the trampoline cost.
  if (is_identifier(name)) {
    if (name == "true" || name == "false")
      return Cpp::GetType("bool");
    if (name == "nullptr")
      return Cpp::GetType("nullptr_t", Cpp::GetNamed("std"));
    return nullptr;
  }
 
  if (!enable_slow_lookup) {
    if (name.find("::") != std::string::npos)
      throw std::runtime_error(
          "Calling interop::GetType with qualified name '" + name + "'\n");
    return nullptr;
  }
 
  // Here we might need to deal with integral types such as 3.14.
 
  // Declaring the trampoline parses and compiles code, and each one adds a
  // new alias to the AST, so memoize the resolved types by name. A name that
  // fails to resolve may succeed once more declarations are available, so
  // failures are retried.
  static std::map<std::string, TCppType_t> s_slow_type_cache;
  auto cached = s_slow_type_cache.find(name);
  if (cached != s_slow_type_cache.end())
    return cached->second;
 
  static unsigned long long var_count = 0;
  std::string id = "__cppjit_interop_GetType_" + std::to_string(var_count++);
  std::string using_clause = "using " + id + " = __typeof__(" + name + ");\n";
 
  if (!Cpp::Declare(using_clause.c_str(), /*silent=*/true)) {
    TCppScope_t lookup = Cpp::GetNamed(id);
    TCppType_t lookup_ty = Cpp::GetTypeFromScope(lookup);
    TCppType_t result = Cpp::GetCanonicalType(lookup_ty);
    if (result)
      s_slow_type_cache.emplace(name, result);
    return result;
  }
  return nullptr;
}
 
interop::TCppType_t interop::GetComplexType(const std::string& name) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetComplexType(Cpp::GetType(name));
}
 
std::string interop::ResolveEnum(TCppScope_t handle) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  std::string type =
      Cpp::GetTypeAsString(Cpp::GetIntegerTypeFromEnumScope(handle));
  if (type == "signed char")
    return "char";
  return type;
}
 
interop::TCppScope_t interop::GetUnderlyingScope(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetUnderlyingScope(scope);
}
 
interop::TCppScope_t interop::GetScope(const std::string& name,
                                       TCppScope_t parent_scope) {
  std::unique_lock<RInterOpMutex> Lock(InterOpMutex);
  // Resolving a templated name below declares a new variable in the
  // interpreter (see AppendTypesSlow), so remember the result to not declare
  // one, and grow the memory, on every lookup of the same name.
  static std::map<std::pair<void*, std::string>, TCppScope_t> template_scopes;
  const bool is_template = name.find('<') != std::string::npos;
  const auto key = std::make_pair(parent_scope.data, name);
  if (is_template)
    if (auto it = template_scopes.find(key); it != template_scopes.end())
      return it->second;
 
  // CppInterOp directly looks at the AST which is not enough.
  // We require lazy module loading that ROOT relies on, so we do it here
  // first. Use TClass::GetClass to trigger auto-loading of dictionaries and
  // modules.
  // This also covers nested names: declarations come from the C++ modules,
  // so e.g. ROOT::RDF can be used before its libraries are loaded, and the
  // JIT then finds their symbols only by scanning every library on the
  // search path (about half a second).
  if (!parent_scope || parent_scope == Cpp::GetGlobalScope())
    TClass::GetClass(name.c_str(), true /* load */, true /* silent */);
  else if (Cpp::IsNamespace(parent_scope) || Cpp::IsClass(parent_scope))
    TClass::GetClass(
        (Cpp::GetQualifiedCompleteName(parent_scope) + "::" + name).c_str(),
        true /* load */, true /* silent */);
 
  if (interop::TCppScope_t scope = Cpp::GetScope(name, parent_scope))
    return scope;
  if (!parent_scope || parent_scope == Cpp::GetGlobalScope()) {
    if (interop::TCppScope_t scope = Cpp::GetScopeFromCompleteName(name))
      return scope;
  } else if (name.find('<') == std::string::npos) {
    // Cpp::GetScope handles single identifiers only, so walk the components
    // of a qualified name. Templated names take the branch below: "::" inside
    // a template argument list cannot be split naively.
    TCppScope_t curr = parent_scope;
    size_t start = 0, end;
    while (curr && (end = name.find("::", start)) != std::string::npos) {
      curr = Cpp::GetScope(name.substr(start, end - start), curr);
      start = end + 2;
    }
    if (curr && curr != parent_scope)
      if (interop::TCppScope_t scope = Cpp::GetScope(name.substr(start), curr))
        return scope;
  }
 
  // FIXME: avoid string parsing here
  if (is_template) {
    // Templated type; may need instantiation. Resolve the whole type
    // expression (e.g. "std::array<float, 3>") and read back its scope.
    // Splitting off the argument list and resolving it directly cannot
    // represent non-type arguments such as the `3` in std::array<float, 3>.
    std::vector<Cpp::TemplateArgInfo> types;
    Lock.unlock(); // unlock to allow AppendTypesSlow
    bool added_new_type =
        !interop::AppendTypesSlow(name, types, /*parent=*/parent_scope);
    Lock.lock();
    if (added_new_type && types.size() == 1) {
      // A pointer or reference spelling (e.g. "std::chrono::nanoseconds *",
      // the return type of std::array<nanoseconds, N>::begin()) does not
      // name a scope; GetScopeFromType would silently strip the pointer and
      // return the pointee's scope, misclassifying the name.
      if (Cpp::IsPointerType(types[0].m_Type) ||
          Cpp::IsReferenceType(types[0].m_Type))
        return nullptr;
      TCppScope_t scope = Cpp::GetScopeFromType(types[0].m_Type);
      // Naming the type as a template argument above does not instantiate
      // it, so the specialization may still be declared-but-undefined.
      // Force its definition: callers expect a complete scope, e.g. to
      // walk its base classes.
      if (scope) {
        Cpp::IsComplete(scope);
        template_scopes[key] = scope;
      }
      return scope;
    }
  }
  return nullptr;
}
 
interop::TCppScope_t interop::GetFullScope(const std::string& name) {
  return interop::GetScope(name);
}
 
interop::TCppScope_t interop::GetTypeScope(TCppScope_t var) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetScopeFromType(Cpp::GetVariableType(var));
}
 
interop::TCppScope_t interop::GetNamed(const std::string& name,
                                       TCppScope_t parent_scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  if (TCppScope_t named = Cpp::GetNamed(name, parent_scope))
    return named;
 
  // "gROOT" is a macro expanding to ROOT::GetROOT(); ROOT master exposed it
  // to cppyy as a TGlobalMappedFunction, a mechanism this backend does not
  // consult. Resolve it to the underlying variable instead (making sure it
  // has been initialized first).
  if (name == "gROOT" &&
      (!parent_scope || parent_scope == Cpp::GetGlobalScope())) {
    ROOT::GetROOT();
    return Cpp::GetNamed(
        "gROOTLocal",
        Cpp::GetNamed("Internal", Cpp::GetNamed("ROOT", nullptr)));
  }
 
  return nullptr;
}
 
bool interop::IsVisibleName(const std::string& name, TCppScope_t parent_scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::IsVisibleName(name, parent_scope);
}
 
interop::TCppScope_t interop::GetParentScope(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetParentScope(scope);
}
 
interop::TCppScope_t interop::GetScopeFromType(TCppType_t type) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetScopeFromType(type);
}
 
interop::TCppType_t interop::GetTypeFromScope(TCppScope_t klass) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetTypeFromScope(klass);
}
 
interop::TCppScope_t interop::GetGlobalScope() {
  // The global scope (the first declaration of the interpreter's translation
  // unit) never changes, but this is called on every method call that
  // receives 'self' as its first argument, so avoid the lock and the query.
  static const TCppScope_t s_global = [] {
    std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
    return Cpp::GetGlobalScope();
  }();
  return s_global;
}
 
bool interop::IsTemplate(TCppScope_t handle) { return Cpp::IsTemplate(handle); }
 
bool interop::IsTemplateInstantiation(TCppScope_t handle) {
  return Cpp::IsTemplateSpecialization(handle);
}
 
bool interop::IsTypedefed(TCppScope_t handle) {
  return Cpp::IsTypedefed(handle);
}
 
namespace {
class AutoCastRTTI {
public:
  virtual ~AutoCastRTTI() {}
};
} // namespace
 
interop::TCppScope_t interop::GetActualClass(TCppScope_t klass,
                                             TCppObject_t obj) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  if (!obj || !Cpp::IsClassPolymorphic(klass))
    return klass;
 
  // Skip the std stream hierarchy: autocasting it is not useful, and on MSVC
  // its virtual inheritance puts the vbptr, not a vfptr, at offset 0, so the
  // RTTI probe below follows a garbage pointer.
  static const std::array<TCppScope_t, 3> stream_bases = {
      interop::GetScope("std::ios_base"), interop::GetScope("std::streambuf"),
      interop::GetScope("std::wstreambuf")};
  for (TCppScope_t base : stream_bases)
    if (base && interop::IsSubclass(klass, base))
      return klass;
 
  // This is hit for every polymorphic object handed to Python, and the name
  // lookups below cost microseconds, so their outcomes are memoized. Keyed on
  // (static class, dynamic type). Only outcomes that cannot change later are
  // cached; a failed lookup may succeed once more declarations are available,
  // so failures are retried.
  static std::map<std::pair<const void*, const std::type_info*>, TCppScope_t>
      s_actual_class_cache;
  const std::type_info* typ = &typeid(*(AutoCastRTTI*)obj.data);
  if (!typ)
    return klass;
  const auto cacheKey = std::make_pair((const void*)klass.data, typ);
  auto cached = s_actual_class_cache.find(cacheKey);
  if (cached != s_actual_class_cache.end())
    return cached->second;
 
#ifdef _WIN32
  // MSVC's type_info::name() is already human-readable, but prefixed with
  // the tag kind ("class TWinNTSystem"), which plain name lookup does not
  // accept. Strip the prefix by hand; respelling through type resolution
  // would JIT an uncached declaration per downcast. Template arguments
  // keep their tags, which is harmless as templated names go through type
  // resolution rather than plain lookup.
  std::string demangled_name = typ->name();
  for (const char* prefix : {"class ", "struct ", "union ", "enum "}) {
    if (demangled_name.compare(0, strlen(prefix), prefix) == 0) {
      demangled_name = demangled_name.substr(strlen(prefix));
      break;
    }
  }
#else
  std::string mangled_name = typ->name();
  std::string demangled_name = Cpp::Demangle(mangled_name);
#endif
 
  // A type in an anonymous namespace cannot be named in injected code and
  // has no dictionary, so looking it up would fail; worse, its unspellable
  // name crashes the interpreter ("(anonymous namespace)" on Itanium,
  // "`anonymous namespace'" on MSVC). Keep the base type.
  if (demangled_name.find("anonymous namespace") != std::string::npos)
    return klass;
 
  if (TCppScope_t scope = interop::GetScope(demangled_name)) {
    // A type inside an anonymous namespace cannot be spelled in injected
    // code (e.g. the dispatcher's), so it is unusable as a cast target;
    // keep the static type. Anonymous namespaces are the ones without a
    // name of their own.
    for (TCppScope_t p = Cpp::GetParentScope(scope); p;
         p = Cpp::GetParentScope(p))
      if (Cpp::IsNamespace(p) && Cpp::GetName(p).empty())
        return klass;
    // Only return the derived type once it has a complete definition. Under
    // runtime_cxxmodules=OFF, autoloading the dictionary registers only a
    // forward declaration, so force the definition into the AST here. Internal
    // classes like TCling have no header and cannot be completed (their
    // CXXRecordDecl has no DefinitionData); GetOrForceDefinition returns null
    // for them and we fall back to the base type, avoiding a crash when
    // querying offsets.
    if (Cpp::GetOrForceDefinition(scope)) {
      s_actual_class_cache.emplace(cacheKey, scope);
      return scope;
    }
  }
 
  return klass;
}
 
size_t interop::SizeOf(TCppScope_t klass) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::SizeOf(klass);
}
 
size_t interop::SizeOfType(TCppType_t klass) {
  if (!klass)
    return 0;
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetSizeOfType(klass);
}
 
bool interop::IsBuiltin(const std::string& type_name) {
  static std::set<std::string> s_builtins = {"bool",
                                             "char",
                                             "signed char",
                                             "unsigned char",
                                             "wchar_t",
                                             "short",
                                             "unsigned short",
                                             "int",
                                             "unsigned int",
                                             "long",
                                             "unsigned long",
                                             "long long",
                                             "unsigned long long",
                                             "float",
                                             "double",
                                             "long double",
                                             "void"};
  if (s_builtins.find(trim(type_name)) != s_builtins.end())
    return true;
 
  if (strstr(type_name.c_str(), "std::complex"))
    return true;
 
  return false;
}
 
bool interop::IsBuiltin(TCppType_t type) { return Cpp::IsBuiltin(type); }
 
bool interop::IsComplete(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::IsComplete(scope);
}
 
// // memory management
// ---------------------------------------------------------
interop::TCppObject_t interop::Allocate(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::Allocate(scope, /*count=*/1);
}
 
void interop::Deallocate(TCppScope_t scope, TCppObject_t instance) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  Cpp::Deallocate(scope, instance, /*count=*/1);
}
 
// Constructors and destructors are resolved (and JIT-compiled) under the
// lock and run without it, as WrapperCall does: their bodies are user code.
interop::TCppObject_t interop::Construct(TCppScope_t scope,
                                         void* arena /*=nullptr*/) {
  std::unique_lock<RInterOpMutex> Lock(InterOpMutex);
  if (!Cpp::HasDefaultConstructor(scope))
    return nullptr;
  Cpp::JitCall JC =
      Cpp::MakeFunctionCallable(Cpp::GetDefaultConstructor(scope));
  Lock.unlock();
  if (!JC)
    return nullptr;
  void* result = arena;
  JC.InvokeConstructor(&result, /*nary=*/1, /*args=*/{},
                       /*is_arena=*/arena ? reinterpret_cast<void*>(1)
                                          : nullptr);
  return result;
}
 
static Cpp::JitCall destructor_callable(interop::TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::MakeFunctionCallable(Cpp::GetDestructor(scope));
}
 
void interop::Destruct(TCppScope_t scope, TCppObject_t instance) {
  if (Cpp::JitCall JC = destructor_callable(scope))
    JC.InvokeDestructor(instance.data, /*nary=*/0, /*withFree=*/true);
}
 
static inline bool copy_args(Parameter* args, size_t nargs, void** vargs) {
  bool runRelease = false;
  for (size_t i = 0; i < nargs; ++i) {
    switch (args[i].fTypeCode) {
    case 'X': /* (void*)type& with free */
      runRelease = true;
    case 'V': /* (void*)type& */
      vargs[i] = args[i].fValue.fVoidp;
      break;
    case 'r': /* const type& */
      vargs[i] = args[i].fRef;
      break;
    default: /* all other types in union */
      vargs[i] = (void*)&args[i].fValue.fVoidp;
      break;
    }
  }
  return runRelease;
}
 
static inline void release_args(Parameter* args, size_t nargs) {
  for (size_t i = 0; i < nargs; ++i) {
    if (args[i].fTypeCode == 'X')
      free(args[i].fValue.fVoidp);
  }
}
 
static inline bool WrapperCall(interop::TCppMethod_t method, size_t nargs,
                               void* args_, void* self, void* result) {
  Parameter* args = (Parameter*)args_;
  // bool is_direct = nargs & DIRECT_CALL;
  nargs = CALL_NARGS(nargs);
 
  // if (!is_ready(wrap, is_direct))
  //     return false;        // happens with compilation error
  InterOpMutex.lock();
  if (Cpp::JitCall JC = Cpp::MakeFunctionCallable(method)) {
    InterOpMutex.unlock();
    bool runRelease = false;
    // const auto& fgen = /* is_direct ? faceptr.fDirect : */ faceptr;
    if (nargs <= cpyrt::SMALL_ARGS_N) {
      void* smallbuf[cpyrt::SMALL_ARGS_N];
      if (nargs)
        runRelease = copy_args(args, nargs, smallbuf);
      // CLING_CATCH_UNCAUGHT_
      JC.Invoke(result, {smallbuf, nargs}, self);
      // _CLING_CATCH_UNCAUGHT
    } else {
      std::vector<void*> buf(nargs);
      runRelease = copy_args(args, nargs, buf.data());
      // CLING_CATCH_UNCAUGHT_
      JC.Invoke(result, {buf.data(), nargs}, self);
      // _CLING_CATCH_UNCAUGHT
    }
    if (runRelease)
      release_args(args, nargs);
    return true;
  }
  InterOpMutex.unlock();
  return false;
}
 
template <typename T>
static inline T CallT(interop::TCppMethod_t method, interop::TCppObject_t self,
                      size_t nargs, void* args) {
  T t{};
  if (WrapperCall(method, nargs, args, self.data, &t))
    return t;
  throw std::runtime_error("failed to resolve function");
  return (T)-1;
}
 
#ifdef PRINT_DEBUG
#define _IMP_CALL_PRINT_STMT(type) printf("IMP CALL with type: %s\n", #type);
#else
#define _IMP_CALL_PRINT_STMT(type)
#endif
 
#define CPPJIT_IMP_CALL(typecode, rtype)                                       \
  rtype interop::Call##typecode(TCppMethod_t method, TCppObject_t self,        \
                                size_t nargs, void* args) {                    \
    _IMP_CALL_PRINT_STMT(rtype)                                                \
    return CallT<rtype>(method, self, nargs, args);                            \
  }
 
void interop::CallV(TCppMethod_t method, TCppObject_t self, size_t nargs,
                    void* args) {
  if (!WrapperCall(method, nargs, args, self.data, nullptr))
    return /* TODO ... report error */;
}
 
// clang-format off
CPPJIT_IMP_CALL(B,  unsigned char)
CPPJIT_IMP_CALL(C,  char         )
CPPJIT_IMP_CALL(H,  short        )
CPPJIT_IMP_CALL(I,  int          )
CPPJIT_IMP_CALL(L,  long         )
CPPJIT_IMP_CALL(LL, long long    )
CPPJIT_IMP_CALL(F,  float        )
CPPJIT_IMP_CALL(D,  double       )
CPPJIT_IMP_CALL(LD, long double  )
// clang-format on
 
void* interop::CallR(TCppMethod_t method, TCppObject_t self, size_t nargs,
                     void* args) {
  void* r = nullptr;
  if (WrapperCall(method, nargs, args, self.data, &r))
    return r;
  return nullptr;
}
 
char* interop::CallS(TCppMethod_t method, TCppObject_t self, size_t nargs,
                     void* args, size_t* length) {
  char* cstr = nullptr;
  // TClassRef cr("std::string"); // TODO: Why is this required?
  std::string* cppresult = (std::string*)malloc(sizeof(std::string));
  if (WrapperCall(method, nargs, args, self.data, (void*)cppresult)) {
    cstr = cppstring_to_cstring(*cppresult);
    *length = cppresult->size();
    cppresult->std::string::~basic_string();
  } else
    *length = 0;
  free((void*)cppresult);
  return cstr;
}
 
interop::TCppObject_t interop::CallConstructor(TCppMethod_t method,
                                               TCppScope_t /*klass*/,
                                               size_t nargs, void* args) {
  void* obj = nullptr;
  WrapperCall(method, nargs, args, nullptr, &obj);
  return (TCppObject_t)obj;
}
 
void interop::CallDestructor(TCppScope_t scope, TCppObject_t self) {
  if (Cpp::JitCall JC = destructor_callable(scope))
    JC.InvokeDestructor(self.data, /*nary=*/0, /*withFree=*/false);
}
 
interop::TCppObject_t interop::CallO(TCppMethod_t method, TCppObject_t self,
                                     size_t nargs, void* args,
                                     TCppType_t result_type) {
  size_t size = interop::SizeOfType(result_type);
  if (size == 0)
    return TCppObject_t{}; // unsizable return type; the caller reports
  void* obj = ::operator new(size);
  if (WrapperCall(method, nargs, args, self.data, obj))
    return (TCppObject_t)obj;
  ::operator delete(obj);
  return TCppObject_t{};
}
 
interop::TCppFuncAddr_t interop::GetFunctionAddress(TCppMethod_t method,
                                                    bool /*check_enabled*/) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetFunctionAddress(method);
}
 
// handling of function argument buffer --------------------------------------
void* interop::AllocateFunctionArgs(size_t nargs) {
  return new Parameter[nargs];
}
 
void interop::DeallocateFunctionArgs(void* args) { delete[] (Parameter*)args; }
 
size_t interop::GetFunctionArgSizeof() { return sizeof(Parameter); }
 
size_t interop::GetFunctionArgTypeoffset() {
  return offsetof(Parameter, fTypeCode);
}
 
// scope reflection information ----------------------------------------------
bool interop::IsNamespace(TCppScope_t scope) {
  if (!scope)
    return false;
 
  // Test if this scope represents a namespace.
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::IsNamespace(scope) || Cpp::GetGlobalScope() == scope;
}
 
bool interop::IsClass(TCppScope_t scope) {
  // Test if this scope represents a namespace.
  return Cpp::IsClass(scope);
}
//
bool interop::IsAbstract(TCppScope_t scope) {
  // Test if this type may not be instantiated.
  return Cpp::IsAbstract(scope);
}
 
bool interop::IsEnumScope(TCppScope_t scope) { return Cpp::IsEnumScope(scope); }
 
bool interop::IsEnumConstant(TCppScope_t scope) {
  return Cpp::IsEnumConstant(interop::GetUnderlyingScope(scope));
}
 
bool interop::IsEnumType(TCppType_t type) { return Cpp::IsEnumType(type); }
 
bool interop::IsAggregate(TCppScope_t type) {
  // Test if this type is a "plain old data" type
  return Cpp::IsAggregate(type);
}
 
bool interop::IsDefaultConstructable(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  // Test if this type has a default constructor or is a "plain old data" type
  return Cpp::HasDefaultConstructor(scope);
}
 
bool interop::IsVariable(TCppScope_t scope) { return Cpp::IsVariable(scope); }
 
void interop::GetAllCppNames(TCppScope_t scope,
                             std::set<std::string>& cppnames) {
  // Collect all known names of C++ entities under scope. This is useful for
  // IDEs employing tab-completion, for example. Note that functions names need
  // not be unique as they can be overloaded.
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  Cpp::GetAllCppNames(scope, cppnames);
}
 
// class reflection information ----------------------------------------------
std::vector<interop::TCppScope_t>
interop::GetUsingNamespaces(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetUsingNamespaces(scope);
}
 
// Normalize a type or scope name to cppyy's canonical form: no space after
// the commas separating template arguments, and pointers/references attached
// to the type. This is the form cpyrt itself constructs (e.g. when
// looking up cached template instantiations by name, see
// Utility::ConstructTemplateArgs) and the convention that user code and the
// test suite inherited from upstream cppyy; clang's printer instead emits
// "a, b", "T *" and "T &".
static std::string cppyy_normalize_name(std::string name) {
  std::string::size_type pos = 0;
  while ((pos = name.find(", ", pos)) != std::string::npos)
    name.erase(pos + 1, 1);
  pos = 0;
  while ((pos = name.find(" *", pos)) != std::string::npos)
    name.erase(pos, 1);
  pos = 0;
  while ((pos = name.find(" &", pos)) != std::string::npos)
    name.erase(pos, 1);
  return name;
}
 
// class reflection information ----------------------------------------------
std::string interop::GetFinalName(TCppScope_t klass) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return cppyy_normalize_name(
      Cpp::GetCompleteName(Cpp::GetUnderlyingScope(klass)));
}
 
std::string interop::GetScopedFinalName(TCppScope_t klass) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return cppyy_normalize_name(Cpp::GetQualifiedCompleteName(klass));
}
 
bool interop::HasVirtualDestructor(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  TCppMethod_t func = Cpp::GetDestructor(scope);
  return Cpp::IsVirtualMethod(func);
}
 
interop::TCppIndex_t interop::GetNumBases(TCppScope_t klass) {
  // Get the total number of base classes that this class has.
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  // Autoloading may have registered only a forward declaration of the class;
  // complete it, or the proxy is built without its bases.
  Cpp::GetOrForceDefinition(klass);
  // Cpp::GetNumBases() instantiates a class template specialization with
  // diagnostics, printing an error for one that can't be defined, e.g. a
  // specialization of a template that is only declared. IsComplete()
  // instantiates it silently.
  if (!Cpp::IsComplete(klass))
    return 0;
  return Cpp::GetNumBases(klass);
}
 
////////////////////////////////////////////////////////////////////////////////
/// \fn interop::TCppIndex_t interop::GetNumBasesLongestBranch(TCppScope_t
/// klass) \brief Retrieve number of base classes in the longest branch of the
///        inheritance tree of the input class.
/// \param[in] klass The class to start the retrieval process from.
///
/// This is a helper function for interop::GetNumBasesLongestBranch.
/// Given an inheritance tree, the function assigns weight 1 to each class that
/// has at least one base. Starting from the input class, the function is
/// called recursively on all the bases. For each base the return value is one
/// (the weight of the base itself) plus the maximum value retrieved for their
/// bases in turn. For example, given the following inheritance tree:
///
/// ~~~{.cpp}
/// class A {}; class B: public A {};
/// class X {}; class Y: public X {}; class Z: public Y {};
/// class C: public B, Z {};
/// ~~~
///
/// calling this function on an instance of `C` will return 3, the steps
/// required to go from C to X.
interop::TCppIndex_t interop::GetNumBasesLongestBranch(TCppScope_t klass) {
  std::vector<size_t> num;
  for (TCppIndex_t ibase = 0; ibase < GetNumBases(klass); ++ibase)
    num.push_back(
        GetNumBasesLongestBranch(interop::GetBaseScope(klass, ibase)));
  if (num.empty())
    return 0;
  return *std::max_element(num.begin(), num.end()) + 1;
}
 
std::string interop::GetBaseName(TCppScope_t klass, TCppIndex_t ibase) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetName(Cpp::GetBaseClass(klass, ibase));
}
 
interop::TCppScope_t interop::GetBaseScope(TCppScope_t klass,
                                           TCppIndex_t ibase) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetBaseClass(klass, ibase);
}
 
bool interop::IsSubclass(TCppScope_t derived, TCppScope_t base) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  // Checked on every method call that receives 'self' as its first argument
  // (e.g. from pythonizations and protocol slots), so memoize per class
  // pair. A class that is still incomplete can gain bases once its
  // definition is loaded, so a negative answer is only cached for complete
  // classes.
  static std::map<std::pair<const void*, const void*>, bool> s_subclass_cache;
  const auto cacheKey = std::make_pair(derived.data, base.data);
  auto cached = s_subclass_cache.find(cacheKey);
  if (cached != s_subclass_cache.end())
    return cached->second;
  bool result = Cpp::IsSubclass(derived, base);
  if (result || (Cpp::IsComplete(derived) && Cpp::IsComplete(base)))
    s_subclass_cache.emplace(cacheKey, result);
  return result;
}
 
static std::set<std::string> gSmartPtrTypes = {
    "std::auto_ptr", "std::shared_ptr", "std::unique_ptr", "std::weak_ptr"};
 
bool interop::IsSmartPtr(TCppScope_t klass) {
  const std::string& rn = interop::GetScopedFinalName(klass);
  if (gSmartPtrTypes.find(rn.substr(0, rn.find("<"))) != gSmartPtrTypes.end())
    return true;
  return false;
}
 
bool interop::GetSmartPtrInfo(TCppScope_t klass, TCppScope_t* raw,
                              TCppMethod_t* deref) {
  TCppScope_t scope = interop::GetUnderlyingScope(klass);
  if (!scope || !interop::IsSmartPtr(scope))
    return false;
 
  if (!raw && !deref)
    return true;
 
  std::vector<TCppMethod_t> ops;
  {
    std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
    // the operator can only be found once the specialization is instantiated
    if (!Cpp::IsComplete(scope))
      return false;
    Cpp::GetOperator(scope, Cpp::Operator::OP_Arrow, ops,
                     /*kind=*/Cpp::OperatorArity::kBoth);
    if (ops.size() != 1)
      return false;
 
    // The dereference operator can be a member template: MSVC's
    // std::shared_ptr::operator-> is SFINAE-constrained on the element
    // type not being an array. Its return type is dependent, so it has
    // to be instantiated (it takes no arguments) before the pointee
    // type can be determined - and before it can be called.
    if (Cpp::IsTemplatedFunction(ops[0]))
      ops[0] = Cpp::BestOverloadFunctionMatch(ops, {}, {});
    if (!ops[0])
      return false;
  }
 
  if (deref)
    *deref = ops[0];
  if (raw)
    *raw = interop::GetScopeFromType(interop::GetMethodReturnType(ops[0]));
  return (!deref || *deref) && (!raw || *raw);
}
 
// type offsets --------------------------------------------------------------
ptrdiff_t interop::GetBaseOffset(TCppScope_t derived, TCppScope_t base,
                                 TCppObject_t address, int direction,
                                 bool rerror) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  // Up-casts may start from a subobject whose complete type is unknown. For
  // down-casts, callers obtain the complete type with GetActualClass, so use
  // its static layout; address points to the base rather than the derived type.
  const void* object = direction > 0 ? address.data : nullptr;
 
  // Queried for every downcast object handed to Python; computing it walks
  // the inheritance paths, so memoize per class pair. Only the static layout
  // (no object address) is fixed per pair once both records are complete; an
  // offset read from the object's vtable is not cached.
  static std::map<std::pair<const void*, const void*>, intptr_t>
      s_base_offset_cache;
  const auto cacheKey = std::make_pair(derived.data, base.data);
  auto cached =
      object ? s_base_offset_cache.end() : s_base_offset_cache.find(cacheKey);
  intptr_t offset = 0;
  if (cached != s_base_offset_cache.end()) {
    offset = cached->second;
  } else {
    // An incomplete record has no walkable bases (GetBaseClassOffset would
    // read an empty base path), and the answer may change once the
    // definition is loaded, so treat it like the error case below and retry
    // next time instead of caching.
    if (!Cpp::IsComplete(derived) || !Cpp::IsComplete(base))
      return rerror ? (ptrdiff_t)-1 : 0;
 
    offset = Cpp::GetBaseClassOffset(derived, base, object);
 
    if (offset == -1) // Cling error, treat silently
      return rerror ? (ptrdiff_t)offset : 0;
 
    if (!object)
      s_base_offset_cache.emplace(cacheKey, offset);
  }
 
  return (ptrdiff_t)(direction < 0 ? -offset : offset);
}
 
// method/function reflection information ------------------------------------
// A deleted overload is not callable, and leaving it in the set adds a
// spurious conversion error to every failed-call report.
static void
remove_deleted_methods(std::vector<interop::TCppMethod_t>& methods) {
  methods.erase(std::remove_if(methods.begin(), methods.end(),
                               [](interop::TCppMethod_t m) {
                                 return Cpp::IsFunctionDeleted(m);
                               }),
                methods.end());
}
 
void interop::GetClassMethods(TCppScope_t scope,
                              std::vector<interop::TCppMethod_t>& methods) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  Cpp::GetClassMethods(scope, methods);
  remove_deleted_methods(methods);
}
 
std::vector<interop::TCppMethod_t>
interop::GetMethodsFromName(TCppScope_t scope, const std::string& name) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  std::vector<interop::TCppMethod_t> methods =
      Cpp::GetFunctionsUsingName(scope, name);
  remove_deleted_methods(methods);
  return methods;
}
 
std::string interop::GetName(TCppScope_t method) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetName(method);
}
 
std::string interop::GetFullName(TCppScope_t method) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return cppyy_normalize_name(Cpp::GetCompleteName(method));
}
 
interop::TCppType_t interop::GetMethodReturnType(TCppMethod_t method) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetFunctionReturnType(method);
}
 
std::string interop::GetMethodReturnTypeAsString(TCppMethod_t method) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  TCppType_t ret = Cpp::GetCanonicalType(Cpp::GetFunctionReturnType(method));
  // C++ deletes top-level cv-qualifiers on non-class return types from the
  // function type ([dcl.fct]); mirror that so name matching sees the plain
  // type, e.g. "unsigned long" for `static const size_t size()`. Class
  // types keep the qualifier: it stays part of the function type there
  // (e.g. for override matching in the dispatcher).
  if (ret && !Cpp::IsRecordType(ret))
    ret = Cpp::RemoveTypeQualifier(ret,
                                   Cpp::QualKind::Const | Cpp::QualKind::Volatile);
  return Cpp::GetTypeAsString(ret);
}
 
interop::TCppIndex_t interop::GetMethodNumArgs(TCppMethod_t method) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetFunctionNumArgs(method);
}
 
interop::TCppIndex_t interop::GetMethodReqArgs(TCppMethod_t method) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetFunctionRequiredArgs(method);
}
 
std::string interop::GetMethodArgName(TCppMethod_t method, TCppIndex_t iarg) {
  if (!method)
    return "<unknown>";
 
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetFunctionArgName(method, iarg);
}
 
interop::TCppType_t interop::GetMethodArgType(TCppMethod_t method,
                                              TCppIndex_t iarg) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetFunctionArgType(method, iarg);
}
 
std::string interop::GetMethodArgTypeAsString(TCppMethod_t method,
                                              TCppIndex_t iarg) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetTypeAsString(Cpp::RemoveTypeQualifier(
      Cpp::GetFunctionArgType(method, iarg), Cpp::QualKind::Const));
}
 
std::string interop::GetMethodArgCanonTypeAsString(TCppMethod_t method,
                                                   TCppIndex_t iarg) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetTypeAsString(
      Cpp::GetCanonicalType(Cpp::GetFunctionArgType(method, iarg)));
}
 
std::string interop::GetMethodArgDefault(TCppMethod_t method,
                                         TCppIndex_t iarg) {
  if (!method)
    return "";
 
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetFunctionArgDefault(method, iarg);
}
 
interop::TCppIndex_t
interop::CompareMethodArgType(TCppMethod_t /*method*/, TCppIndex_t /*iarg*/,
                              const std::string& /*req_type*/) {
  // if (method) {
  //     TFunction* f = m2f(method);
  //     TMethodArg* arg = (TMethodArg
  //     *)f->GetListOfMethodArgs()->At((int)iarg); void *argqtp =
  //     gInterpreter->TypeInfo_QualTypePtr(arg->GetTypeInfo());
 
  //     TypeInfo_t *reqti = gInterpreter->TypeInfo_Factory(req_type.c_str());
  //     void *reqqtp = gInterpreter->TypeInfo_QualTypePtr(reqti);
 
  //     if (ArgSimilarityScore(argqtp, reqqtp) < 10) {
  //         return ArgSimilarityScore(argqtp, reqqtp);
  //     }
  //     else { // Match using underlying types
  //         if(gInterpreter->IsPointerType(argqtp))
  //             argqtp =
  //             gInterpreter->TypeInfo_QualTypePtr(gInterpreter->GetPointerType(argqtp));
 
  //         // Handles reference types and strips qualifiers
  //         TypeInfo_t *arg_ul = gInterpreter->GetNonReferenceType(argqtp);
  //         TypeInfo_t *req_ul = gInterpreter->GetNonReferenceType(reqqtp);
  //         argqtp =
  //         gInterpreter->TypeInfo_QualTypePtr(gInterpreter->GetUnqualifiedType(gInterpreter->TypeInfo_QualTypePtr(arg_ul)));
  //         reqqtp =
  //         gInterpreter->TypeInfo_QualTypePtr(gInterpreter->GetUnqualifiedType(gInterpreter->TypeInfo_QualTypePtr(req_ul)));
 
  //         return ArgSimilarityScore(argqtp, reqqtp);
  //     }
  // }
  return 0; // Method is not valid
}
 
std::string interop::GetMethodSignature(TCppMethod_t method,
                                        bool show_formal_args,
                                        TCppIndex_t max_args) {
  std::ostringstream sig;
  sig << "(";
  int nArgs = GetMethodNumArgs(method);
  if (max_args != (TCppIndex_t)-1)
    nArgs = std::min(nArgs, (int)max_args);
  for (int iarg = 0; iarg < nArgs; ++iarg) {
    sig << cppyy_normalize_name(
        interop::GetMethodArgTypeAsString(method, iarg));
    if (show_formal_args) {
      std::string argname = interop::GetMethodArgName(method, iarg);
      if (!argname.empty())
        sig << " " << argname;
      std::string defvalue = interop::GetMethodArgDefault(method, iarg);
      if (!defvalue.empty())
        sig << " = " << defvalue;
    }
    if (iarg != nArgs - 1)
      sig << ", ";
  }
  sig << ")";
  return sig.str();
}
 
interop::TCppType_t interop::GetFnTypeFromStdFn(TCppType_t fn_type) {
  fn_type = Cpp::IsReferenceType(fn_type) ? Cpp::GetNonReferenceType(fn_type)
                                          : fn_type;
  fn_type =
      Cpp::IsPointerType(fn_type) ? Cpp::GetPointeeType(fn_type) : fn_type;
  TCppScope_t scope = Cpp::GetScopeFromType(fn_type);
  std::vector<Cpp::TemplateArgInfo> args;
  Cpp::GetClassTemplateArgs(scope, args);
  assert(args.size() == 1);
  if (args.size() == 1)
    return args[0].m_Type;
  return nullptr;
}
 
void interop::GetFnTypeSig(TCppType_t fn_type,
                           std::vector<TCppType_t>& arg_types) {
  if (!fn_type)
    return;
  fn_type = Cpp::IsReferenceType(fn_type) ? Cpp::GetNonReferenceType(fn_type)
                                          : fn_type;
  fn_type =
      Cpp::IsPointerType(fn_type) ? Cpp::GetPointeeType(fn_type) : fn_type;
  // Cpp::GetFnTypeSignature() requires a function prototype: anything else
  // (e.g. a member function pointer, or a plain object type) yields nothing
  if (!Cpp::IsFunctionProtoType(fn_type))
    return;
  Cpp::GetFnTypeSignature(fn_type, arg_types);
}
 
bool interop::GetFnTypeSigAsString(TCppType_t fn_type, std::string& ret_type,
                                   std::string& signature) {
  // the first entry is the return type, followed by the argument types
  std::vector<TCppType_t> types;
  GetFnTypeSig(fn_type, types);
  if (types.empty())
    return false;
 
  ret_type = GetTypeAsString(types[0]);
 
  std::ostringstream sig;
  sig << "(";
  for (std::size_t iarg = 1; iarg < types.size(); ++iarg) {
    if (iarg != 1)
      sig << ", ";
    sig << GetTypeAsString(types[iarg]);
  }
  sig << ")";
  signature = sig.str();
  return true;
}
 
bool interop::IsSameType(TCppType_t typ1, TCppType_t typ2) {
  return Cpp::IsSameType(typ1, typ2);
}
 
bool interop::IsFunctionType(TCppType_t typ) {
  typ = Cpp::IsReferenceType(typ) ? Cpp::GetNonReferenceType(typ) : typ;
  typ = Cpp::IsPointerType(typ) ? Cpp::GetPointeeType(typ) : typ;
  return Cpp::IsFunctionProtoType(typ);
}
 
bool interop::IsSimilarFnTypes(TCppType_t typ1, TCppType_t typ2) {
  typ1 = Cpp::IsReferenceType(typ1) ? Cpp::GetNonReferenceType(typ1) : typ1;
  typ2 = Cpp::IsReferenceType(typ2) ? Cpp::GetNonReferenceType(typ2) : typ2;
  typ1 = Cpp::IsPointerType(typ1) ? Cpp::GetPointeeType(typ1) : typ1;
  typ2 = Cpp::IsPointerType(typ2) ? Cpp::GetPointeeType(typ2) : typ2;
  return Cpp::IsSameType(typ1, typ2);
}
 
std::string interop::GetDoxygenComment(TCppScope_t scope, bool strip_markers) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetDoxygenComment(scope, strip_markers);
}
 
bool interop::IsConstMethod(TCppMethod_t method) {
  if (!method)
    return false;
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::IsConstMethod(method);
}
 
void interop::GetTemplatedMethods(TCppScope_t scope,
                                  std::vector<interop::TCppMethod_t>& methods) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  Cpp::GetFunctionTemplatedDecls(scope, methods);
}
 
interop::TCppIndex_t
interop::GetNumTemplatedMethods(TCppScope_t scope, bool /*accept_namespace*/) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  std::vector<interop::TCppMethod_t> mc;
  Cpp::GetFunctionTemplatedDecls(scope, mc);
  return mc.size();
}
 
std::string interop::GetTemplatedMethodName(TCppScope_t scope,
                                            TCppIndex_t imeth) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  std::vector<interop::TCppMethod_t> mc;
  Cpp::GetFunctionTemplatedDecls(scope, mc);
 
  if (imeth < mc.size())
    return Cpp::GetName(TCppScope_t(mc[imeth].data));
 
  return "";
}
 
bool interop::ExistsMethodTemplate(TCppScope_t scope, const std::string& name) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::ExistsFunctionTemplate(name, scope);
}
 
bool interop::IsTemplatedMethod(TCppMethod_t method) {
  return Cpp::IsTemplatedFunction(method);
}
 
bool interop::IsStaticTemplate(TCppScope_t scope, const std::string& name) {
  std::vector<TCppMethod_t> candidate_methods;
  Cpp::GetClassTemplatedMethods(name, scope, candidate_methods);
  bool is_static = true;
  for (auto i : candidate_methods) {
    if (!Cpp::IsStaticMethod(i)) {
      is_static = false;
      break;
    }
  }
  return is_static;
}
 
interop::TCppMethod_t interop::GetMethodTemplate(TCppScope_t scope,
                                                 const std::string& name,
                                                 const std::string& proto) {
  std::string pureName;
  std::string explicit_params;
 
  if ((name.find("operator<") != 0) && (name.find('<') != std::string::npos)) {
    pureName = name.substr(0, name.find('<'));
    size_t start = name.find('<');
    size_t end = name.rfind('>');
    explicit_params = name.substr(start + 1, end - start - 1);
  } else {
    pureName = name;
  }
 
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  std::vector<interop::TCppMethod_t> unresolved_candidate_methods;
  Cpp::GetClassTemplatedMethods(pureName, scope, unresolved_candidate_methods);
  if (unresolved_candidate_methods.empty() && name.find("operator") == 0) {
    // try operators
    interop::GetClassOperators(scope, pureName, unresolved_candidate_methods);
  }
 
  // cpyrt assumes that we attempt instantiation here
  std::vector<Cpp::TemplateArgInfo> arg_types;
  std::vector<Cpp::TemplateArgInfo> templ_params;
  interop::AppendTypesSlow(proto, arg_types, scope);
  interop::AppendTypesSlow(explicit_params, templ_params, scope);
  interop::TCppMethod_t cppmeth = nullptr;
  cppmeth = Cpp::BestOverloadFunctionMatch(unresolved_candidate_methods,
                                           templ_params, arg_types);
 
  // If overload resolution failed but explicit template arguments were
  // supplied, fall back to direct template-argument substitution: ask Sema
  // to instantiate each candidate with the explicit args. Sema's SFINAE
  // rejects overloads whose substitution fails (e.g. the initializer_list
  // form of std::make_any with non-init-list explicit args), so iterating
  // gives back exactly the viable specialisation. The wrapper-side argument
  // conversion then handles e.g. taking the address of an instance when the
  // substituted parameter is a pointer.
  if (!cppmeth && !templ_params.empty()) {
    for (const auto& cand : unresolved_candidate_methods) {
      if (Cpp::DeclRef spec = Cpp::InstantiateTemplate(
              TCppScope_t(cand.data), templ_params.data(), templ_params.size(),
              /*instantiate_body=*/false)) {
        cppmeth = spec.data;
        break;
      }
    }
  }
 
  return TCppMethod_t(cppmeth.data);
  // if it fails, use Sema to propogate info about why it failed (DeductionInfo)
}
 
static inline bool is_basic_string_of(const std::string& n, const char* charT) {
  // Match "std::basic_string<charT" whether or not the default template
  // arguments (char_traits, allocator) are spelled out; the character type
  // must be followed by ',' or '>' so that e.g. "char" does not match
  // "char16_t".
  std::string prefix = "std::basic_string<";
  prefix += charT;
  if (n.compare(0, prefix.size(), prefix) != 0)
    return false;
  return n.size() > prefix.size() &&
         (n[prefix.size()] == ',' || n[prefix.size()] == '>');
}
 
static inline std::string type_remap(const std::string& n1,
                                     const std::string& n2) {
  // Operator lookups of (C++ string, Python str) should succeed for the
  // combos of string/str, wstring/str, string/unicode and wstring/unicode;
  // since C++ does not have a operator+(std::string, std::wstring), we'll
  // have to look up the same type and rely on the converters in
  // cpyrt/_cppjit.
  if (n1 == "str" || n1 == "unicode" || is_basic_string_of(n1, "char")) {
    if (is_basic_string_of(n2, "wchar_t"))
      return "std::basic_string<wchar_t>&"; // match like for like
    return "std::basic_string<char>&";      // probably best bet
  } else if (is_basic_string_of(n1, "wchar_t")) {
    return "std::basic_string<wchar_t>&";
  } else if (n1 == "complex") {
    return "std::complex<double>";
  }
  return n1;
}
 
void interop::GetClassOperators(interop::TCppScope_t klass,
                                const std::string& opname,
                                std::vector<TCppMethod_t>& operators) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  std::string op = opname.substr(8);
  Cpp::GetOperator(klass, Cpp::GetOperatorFromSpelling(op), operators,
                   /*kind=*/Cpp::OperatorArity::kBoth);
}
 
interop::TCppMethod_t interop::GetGlobalOperator(TCppScope_t scope,
                                                 const std::string& lc,
                                                 const std::string& rc,
                                                 const std::string& opname) {
  std::string rc_type = type_remap(rc, lc);
  std::string lc_type = type_remap(lc, rc);
 
  std::vector<TCppMethod_t> overloads;
  Cpp::GetOperator(scope, Cpp::GetOperatorFromSpelling(opname), overloads,
                   /*kind=*/Cpp::OperatorArity::kBoth);
 
  // Avoid pushing nullptr into arg_types which would crash
  // BestOverloadFunctionMatch when it dereferences each entry's QualType.
  auto resolve_arg_type = [](const std::string& name) -> interop::TCppType_t {
    if (auto s = interop::GetScope(name))
      if (auto t = interop::GetTypeFromScope(s))
        return interop::GetReferencedType(t);
    return interop::GetType(name, /*enable_slow_lookup=*/true);
  };
 
  std::vector<Cpp::TemplateArgInfo> arg_types;
  if (auto l = resolve_arg_type(lc_type))
    arg_types.emplace_back(l.data);
  else
    return nullptr;
 
  if (!rc_type.empty()) {
    if (auto r = resolve_arg_type(rc_type))
      arg_types.emplace_back(r.data);
    else
      return nullptr;
  }
  interop::TCppMethod_t cppmeth =
      Cpp::BestOverloadFunctionMatch(overloads, {}, arg_types);
  if (cppmeth)
    return cppmeth;
  return nullptr;
}
 
// method properties ---------------------------------------------------------
bool interop::IsDeletedMethod(TCppMethod_t method) {
  return Cpp::IsFunctionDeleted(method);
}
 
bool interop::IsPublicMethod(TCppMethod_t method) {
  return Cpp::IsPublicMethod(method);
}
 
bool interop::IsProtectedMethod(TCppMethod_t method) {
  return Cpp::IsProtectedMethod(method);
}
 
bool interop::IsPrivateMethod(TCppMethod_t method) {
  return Cpp::IsPrivateMethod(method);
}
 
bool interop::IsConstructor(TCppMethod_t method) {
  return Cpp::IsConstructor(method);
}
 
bool interop::IsDestructor(TCppMethod_t method) {
  return Cpp::IsDestructor(method);
}
 
bool interop::IsStaticMethod(TCppMethod_t method) {
  return Cpp::IsStaticMethod(method);
}
 
bool interop::IsExplicit(TCppMethod_t method) {
  return Cpp::IsExplicit(method);
}
 
// data member reflection information ----------------------------------------
void interop::GetDatamembers(TCppScope_t scope,
                             std::vector<TCppScope_t>& datamembers) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  Cpp::GetDatamembers(scope, datamembers);
  Cpp::GetStaticDatamembers(scope, datamembers);
  Cpp::GetEnumConstantDatamembers(scope, datamembers, false);
}
 
bool interop::CheckDatamember(TCppScope_t scope, const std::string& name) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return (bool)Cpp::LookupDatamember(name, scope);
}
 
bool interop::IsLambdaClass(TCppType_t type) {
  return Cpp::IsLambdaClass(type);
}
 
interop::TCppScope_t interop::WrapLambdaFromVariable(TCppScope_t var) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  std::ostringstream code;
  std::string name = interop::GetFinalName(var);
  code << "namespace __cppjit_internal_wrap_g {\n"
       << "  " << "std::function " << name
       << " = ::" << Cpp::GetQualifiedName(var) << ";\n"
       << "}\n";
 
  if (interop::Compile(code.str().c_str())) {
    TCppScope_t res = Cpp::GetNamed(
        name, Cpp::GetScope("__cppjit_internal_wrap_g", /*parent=*/nullptr));
    if (res)
      return res;
  }
  return var;
}
 
interop::TCppMethod_t
interop::AdaptFunctionForLambdaReturn(interop::TCppMethod_t fn) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  std::string fn_name = Cpp::GetQualifiedCompleteName(TCppScope_t(fn.data));
  std::string signature = interop::GetMethodSignature(fn, true);
 
  std::ostringstream call;
  call << "(";
  for (size_t i = 0, n = interop::GetMethodNumArgs(fn); i < n; i++) {
    call << interop::GetMethodArgName(fn, i);
    if (i != n - 1)
      call << ", ";
  }
  call << ")";
 
  std::ostringstream code;
  static int i = 0;
  std::string name = "lambda_return_convert_" + std::to_string(++i);
  code << "namespace __cppjit_internal_wrap_g {\n"
       << "auto " << name << signature << "{" << "return std::function("
       << fn_name << call.str() << "); }\n"
       << "}\n";
  if (interop::Compile(code.str().c_str())) {
    TCppScope_t res = Cpp::GetNamed(
        name, Cpp::GetScope("__cppjit_internal_wrap_g", /*parent=*/nullptr));
    if (res)
      return TCppMethod_t(res.data);
  }
  return fn;
}
 
interop::TCppType_t interop::GetDatamemberType(TCppScope_t var) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetVariableType(Cpp::GetUnderlyingScope(var));
}
 
std::string interop::GetDatamemberTypeAsString(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetTypeAsString(
      Cpp::GetVariableType(Cpp::GetUnderlyingScope(scope)));
}
 
std::string interop::GetTypeAsString(TCppType_t type) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetTypeAsString(type);
}
 
intptr_t interop::GetDatamemberOffset(TCppScope_t var, TCppScope_t klass) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetVariableOffset(Cpp::GetUnderlyingScope(var), klass);
}
 
// data member properties ----------------------------------------------------
bool interop::IsPublicData(TCppScope_t datamem) {
  return Cpp::IsPublicVariable(datamem);
}
 
bool interop::IsProtectedData(TCppScope_t datamem) {
  return Cpp::IsProtectedVariable(datamem);
}
 
bool interop::IsPrivateData(TCppScope_t datamem) {
  return Cpp::IsPrivateVariable(datamem);
}
 
bool interop::IsStaticDatamember(TCppScope_t var) {
  return Cpp::IsStaticVariable(interop::GetUnderlyingScope(var));
}
 
bool interop::IsConstVar(TCppScope_t var) { return Cpp::IsConstVariable(var); }
 
interop::TCppMethod_t interop::ReduceReturnType(TCppMethod_t fn,
                                                TCppType_t reduce) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
 
  std::string fn_name = Cpp::GetQualifiedCompleteName(TCppScope_t(fn.data));
  std::string signature = interop::GetMethodSignature(fn, true);
  std::string result_type = interop::GetTypeAsString(reduce);
 
  std::ostringstream call;
  call << "(";
  for (size_t i = 0, n = interop::GetMethodNumArgs(fn); i < n; i++) {
    call << interop::GetMethodArgName(fn, i);
    if (i != n - 1)
      call << ", ";
  }
  call << ")";
 
  std::ostringstream code;
  static int i = 0;
  std::string name = "reduced_function_" + std::to_string(++i);
  code << "namespace __cppjit_internal_wrap_g {\n"
       << result_type << " " << name << signature << "{" << "return ("
       << result_type << ")::" << fn_name << call.str() << "; }\n"
       << "}\n";
  if (interop::Compile(code.str().c_str())) {
    TCppScope_t res = Cpp::GetNamed(
        name, Cpp::GetScope("__cppjit_internal_wrap_g", /*parent=*/nullptr));
    if (res)
      return TCppMethod_t(res.data);
  }
  return fn;
}
 
std::vector<long int> interop::GetDimensions(TCppType_t type) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetDimensions(type);
}
 
// enum properties -----------------------------------------------------------
std::vector<interop::TCppScope_t> interop::GetEnumConstants(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetEnumConstants(scope);
}
 
interop::TCppType_t interop::GetEnumConstantType(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetEnumConstantType(Cpp::GetUnderlyingScope(scope));
}
 
long long interop::GetEnumDataValue(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::GetEnumConstantValue(scope);
}
 
interop::TCppScope_t interop::InstantiateTemplate(TCppScope_t tmpl,
                                                  Cpp::TemplateArgInfo* args,
                                                  size_t args_size) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  return Cpp::InstantiateTemplate(tmpl, args, args_size,
                                  /*instantiate_body=*/false);
}
 
void interop::DumpScope(TCppScope_t scope) {
  std::lock_guard<RInterOpMutex> Lock(InterOpMutex);
  Cpp::DumpScope(scope);
}