[interop] Upgrade version to bring in upstreamed patches

Adds various upstreamed developments:

compiler-research/CppInterOp#650 streamlines the logic in Cpp::Construct to be more generic.
compiler-research/CppInterOp#643 by @hageboeck making CppInterOp work with new gtest target names
Fixed wrapper name conflicts with ROOT that also uses `__cf`, allowing us to integrate JitCall incrementally and co-exist with CallFunc
Fixes related to the cppyy forks
Unrelated work on Emscripten and WebAssembly

Author: aaronj0

interpreter/CppInterOp/.clang-format

@@ -1,7 +1,7 @@
 BasedOnStyle: LLVM
 
 Language: Cpp
-Standard: Cpp11
+Standard: c++17
 PointerAlignment: Left
 
 IncludeCategories:

interpreter/CppInterOp/Emscripten-build-instructions.md

@@ -173,6 +173,7 @@ $env:CMAKE_SYSTEM_PREFIX_PATH=$env:PREFIX
 ```
 
 on Windows. Now to build and test your Emscripten build of CppInterOp using node on Linux and osx execute the following
+(BUILD_SHARED_LIBS=ON is only needed if building xeus-cpp, as CppInterOp can be built as an Emscripten static library)
 
 ```bash
 mkdir build
@@ -190,6 +191,7 @@ emmake make -j $(nproc --all) check-cppinterop
 ```
 
 To build and test your Emscripten build of CppInterOp on using node Windows execute the following
+(BUILD_SHARED_LIBS=ON is only needed if building xeus-cpp, as CppInterOp can be built as an Emscripten static library)
 
 ```powershell
 emcmake cmake -DCMAKE_BUILD_TYPE=Release    `

interpreter/CppInterOp/cmake/modules/GoogleTest.cmake

@@ -22,10 +22,18 @@ include(ExternalProject)
 if (EMSCRIPTEN)
   if (CMAKE_C_COMPILER MATCHES ".bat")
     set(config_cmd emcmake.bat cmake)
-    set(build_cmd emmake.bat make)
+    if(CMAKE_GENERATOR STREQUAL "Ninja")
+      set(build_cmd emmake.bat ninja)
+    else()
+      set(build_cmd emmake.bat make)
+    endif()
   else()
     set(config_cmd emcmake cmake)
-    set(build_cmd emmake make)
+    if(CMAKE_GENERATOR STREQUAL "Ninja")
+      set(build_cmd emmake ninja)
+    else()
+      set(build_cmd emmake make)
+    endif()
   endif()
 else()
   set(config_cmd ${CMAKE_COMMAND})

interpreter/CppInterOp/cppinterop-version.tag

@@ -1 +1 @@
-130dd30548b59d8f618339158ab917c083184968
+9c9423069529caea5aee79b61580fe9a7b1eb73b

interpreter/CppInterOp/docs/DebuggingCppInterOp.rst

@@ -48,7 +48,7 @@ Here's a comprehensive example that demonstrates common CppInterOp usage pattern
 
 .. code-block:: cpp
 
-  #include "clang/Interpreter/CppInterOp.h"
+  #include <CppInterOp/CppInterOp.h>
   #include <iostream>
 
   void run_code(std::string code) {

interpreter/CppInterOp/docs/Emscripten-build-instructions.rst

@@ -197,6 +197,7 @@ and
    $env:CMAKE_SYSTEM_PREFIX_PATH=$env:PREFIX
 
 on Windows. Now to build and test your Emscripten build of CppInterOp on Linux and osx execute the following
+(BUILD_SHARED_LIBS=ON is only needed if building xeus-cpp, as CppInterOp can be built as an Emscripten static library)
 
 .. code:: bash
 
@@ -214,6 +215,7 @@ on Windows. Now to build and test your Emscripten build of CppInterOp on Linux a
    emmake make -j $(nproc --all) check-cppinterop
 
 To build and test your Emscripten build of CppInterOp on Windows execute the following
+(BUILD_SHARED_LIBS=ON is only needed if building xeus-cpp, as CppInterOp can be built as an Emscripten static library)
 
 .. code:: powershell
 

interpreter/CppInterOp/include/CppInterOp/CppInterOp.h

@@ -224,6 +224,8 @@ class JitCall {
   ///\param[in] nary - Use array new if we have to construct an array of
   ///           objects (nary > 1).
   ///\param[in] args - a pointer to a argument list and argument size.
+  ///\param[in] is_arena - a pointer that indicates if placement new is to be
+  /// used
   // FIXME: Change the type of withFree from int to bool in the wrapper code.
   void InvokeConstructor(void* result, unsigned long nary = 1,
                          ArgList args = {}, void* is_arena = nullptr) const {
@@ -849,7 +851,7 @@ CPPINTEROP_API void Deallocate(TCppScope_t scope, TCppObject_t address,
 
 /// Creates one or more objects of class \c scope by calling its default
 /// constructor.
-/// \param[in] scope Class to construct
+/// \param[in] scope Class to construct, or handle to Constructor
 /// \param[in] arena If set, this API uses placement new to construct at this
 /// address.
 /// \param[in] is used to indicate the number of objects to construct.

interpreter/CppInterOp/lib/CppInterOp/CMakeLists.txt

@@ -114,6 +114,7 @@ endif()
 
 
 if(EMSCRIPTEN)
+  if(BUILD_SHARED_LIBS)
   # FIXME: When dynamically linking the Emscripten shared library to the
   # unit tests main_module you get errors due to undefined symbols. The reading of the file
   # below into a SYMBOLS_LIST variable is a temporary workaround that exports the undefined
@@ -131,8 +132,13 @@ if(EMSCRIPTEN)
     PRIVATE "SHELL: -s SIDE_MODULE=1"
     PRIVATE "SHELL: ${SYMBOLS_LIST}"
   )
+else()
+  target_link_options(clangCppInterOp
+    PRIVATE "SHELL: -s WASM_BIGINT"
+  )
+endif()
   if (CPPINTEROP_ENABLE_TESTING)
-    # When compiling Emscripten tests the shared library it links to is expected to be in the same folder as the compiled Javascript
+    # When compiling Emscripten tests the CppInterOp library it links to is expected to be in the same folder as the compiled Javascript
     add_custom_command(TARGET clangCppInterOp POST_BUILD
       COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:clangCppInterOp> ${CMAKE_BINARY_DIR}/unittests/CppInterOp/
     )

interpreter/CppInterOp/lib/CppInterOp/CppInterOp.cpp

@@ -616,8 +616,6 @@ static Decl* GetScopeFromType(QualType QT) {
     Type = Type->getUnqualifiedDesugaredType();
     if (auto* ET = llvm::dyn_cast<EnumType>(Type))
       return ET->getDecl();
-    if (auto* FnType = llvm::dyn_cast<FunctionProtoType>(Type))
-      Type = const_cast<clang::Type*>(FnType->getReturnType().getTypePtr());
     return Type->getAsCXXRecordDecl();
   }
   return 0;
@@ -1327,6 +1325,8 @@ void GetDatamembers(TCppScope_t scope, std::vector<TCppScope_t>& datamembers) {
 
   if (auto* CXXRD = llvm::dyn_cast_or_null<CXXRecordDecl>(D)) {
     getSema().ForceDeclarationOfImplicitMembers(CXXRD);
+    if (CXXRD->hasDefinition())
+      CXXRD = CXXRD->getDefinition();
 
     llvm::SmallVector<RecordDecl::decl_iterator, 2> stack_begin;
     llvm::SmallVector<RecordDecl::decl_iterator, 2> stack_end;
@@ -1447,7 +1447,7 @@ intptr_t GetVariableOffset(compat::Interpreter& I, Decl* D,
       }
       offset += C.toCharUnitsFromBits(C.getFieldOffset(FD)).getQuantity();
     }
-    if (BaseCXXRD && BaseCXXRD != FieldParentRecordDecl) {
+    if (BaseCXXRD && BaseCXXRD != FieldParentRecordDecl->getCanonicalDecl()) {
       // FieldDecl FD belongs to some class C, but the base class BaseCXXRD is
       // not C. That means BaseCXXRD derives from C. Offset needs to be
       // calculated for Derived class
@@ -1476,7 +1476,7 @@ intptr_t GetVariableOffset(compat::Interpreter& I, Decl* D,
       }
       if (auto* RD = llvm::dyn_cast<CXXRecordDecl>(FieldParentRecordDecl)) {
         // add in the offsets for the (multi level) base classes
-        while (BaseCXXRD != RD) {
+        while (BaseCXXRD != RD->getCanonicalDecl()) {
           CXXRecordDecl* Parent = direction.at(RD);
           offset +=
               C.getASTRecordLayout(Parent).getBaseClassOffset(RD).getQuantity();
@@ -1689,6 +1689,10 @@ std::string GetTypeAsString(TCppType_t var) {
   PrintingPolicy Policy((LangOptions()));
   Policy.Bool = true;               // Print bool instead of _Bool.
   Policy.SuppressTagKeyword = true; // Do not print `class std::string`.
+#if CLANG_VERSION_MAJOR > 16
+  Policy.SuppressElaboration = true;
+#endif
+  Policy.FullyQualifiedName = true;
   return compat::FixTypeName(QT.getAsString(Policy));
 }
 
@@ -1833,6 +1837,7 @@ void get_type_as_string(QualType QT, std::string& type_name, ASTContext& C,
 #if CLANG_VERSION_MAJOR > 16
   Policy.SuppressElaboration = true;
 #endif
+  Policy.SuppressTagKeyword = !QT->isEnumeralType();
   Policy.FullyQualifiedName = true;
   QT.getAsStringInternal(type_name, Policy);
 }
@@ -2103,6 +2108,30 @@ void make_narg_call(const FunctionDecl* FD, const std::string& return_type,
       std::string template_args = complete_name.substr(idx);
       name = name_without_template_args +
              (template_args.empty() ? "" : " " + template_args);
+
+      // If a template has consecutive parameter packs, then it is impossible to
+      // use the explicit name in the wrapper, since the type deduction is what
+      // determines the split of the packs. Instead, we'll revert to the
+      // non-templated function name and hope that the type casts in the wrapper
+      // will suffice.
+      if (FD->isTemplateInstantiation() && FD->getPrimaryTemplate()) {
+        const FunctionTemplateDecl* FTDecl =
+            llvm::dyn_cast<FunctionTemplateDecl>(FD->getPrimaryTemplate());
+        if (FTDecl) {
+          auto* templateParms = FTDecl->getTemplateParameters();
+          int numPacks = 0;
+          for (size_t iParam = 0, nParams = templateParms->size();
+               iParam < nParams; ++iParam) {
+            if (templateParms->getParam(iParam)->isTemplateParameterPack())
+              numPacks += 1;
+            else
+              numPacks = 0;
+          }
+          if (numPacks > 1) {
+            name = name_without_template_args;
+          }
+        }
+      }
     }
     if (op_flag || N <= 1)
       callbuf << name;
@@ -2707,7 +2736,7 @@ int get_wrapper_code(compat::Interpreter& I, const FunctionDecl* FD,
   //
   {
     std::ostringstream buf;
-    buf << "__cf";
+    buf << "__jc";
     // const NamedDecl* ND = dyn_cast<NamedDecl>(FD);
     // std::string mn;
     // fInterp->maybeMangleDeclName(ND, mn);
@@ -3422,6 +3451,8 @@ static Decl* InstantiateTemplate(TemplateDecl* TemplateD,
   // This will instantiate tape<T> type and return it.
   SourceLocation noLoc;
   QualType TT = S.CheckTemplateIdType(TemplateName(TemplateD), noLoc, TLI);
+  if (TT.isNull())
+    return nullptr;
 
   // Perhaps we can extract this into a new interface.
   S.RequireCompleteType(fakeLoc, TT, diag::err_tentative_def_incomplete_type);
@@ -3753,22 +3784,25 @@ void Deallocate(TCppScope_t scope, TCppObject_t address, TCppIndex_t count) {
 // FIXME: Add optional arguments to the operator new.
 TCppObject_t Construct(compat::Interpreter& interp, TCppScope_t scope,
                        void* arena /*=nullptr*/, TCppIndex_t count /*=1UL*/) {
-  auto* Class = (Decl*)scope;
-  // FIXME: Diagnose.
-  if (!HasDefaultConstructor(Class))
-    return nullptr;
 
-  auto* const Ctor = GetDefaultConstructor(interp, Class);
-  if (JitCall JC = MakeFunctionCallable(&interp, Ctor)) {
-    if (arena) {
-      JC.InvokeConstructor(&arena, count, {},
-                           (void*)~0); // Tell Invoke to use placement new.
-      return arena;
-    }
+  if (!Cpp::IsConstructor(scope) && !Cpp::IsClass(scope))
+    return nullptr;
+  if (Cpp::IsClass(scope) && !HasDefaultConstructor(scope))
+    return nullptr;
 
-    void* obj = nullptr;
-    JC.InvokeConstructor(&obj, count, {}, nullptr);
-    return obj;
+  TCppFunction_t ctor = nullptr;
+  if (Cpp::IsClass(scope))
+    ctor = Cpp::GetDefaultConstructor(scope);
+  else // a ctor
+    ctor = scope;
+
+  if (JitCall JC = MakeFunctionCallable(&interp, ctor)) {
+    // invoke the constructor (placement/heap) in one shot
+    // flag is non-null for placement new, null for normal new
+    void* is_arena = arena ? reinterpret_cast<void*>(1) : nullptr;
+    void* result = arena;
+    JC.InvokeConstructor(&result, count, /*args=*/{}, is_arena);
+    return result;
   }
   return nullptr;
 }

interpreter/CppInterOp/unittests/CMakeLists.txt

@@ -3,16 +3,23 @@ set(CTEST_BUILD_NAME
 enable_testing()
 
 # LLVM builds (not installed llvm) provides gtest.
-if (NOT TARGET gtest)
+if (NOT TARGET GTest::gtest AND NOT TARGET gtest)
   include(GoogleTest)
 endif()
 
 if(EMSCRIPTEN)
-  set(gtest_libs gtest gmock)
+  if (TARGET GTest::gtest)
+    # Target names in CMake >= v3.23
+    set(gtest_libs GTest::gtest GTest::gmock)
+  else()
+    set(gtest_libs gtest gmock)
+  endif()
 else()
-  set(gtest_libs gtest gtest_main)
-  if (TARGET gmock)
-    list(APPEND gtest_libs gmock gmock_main)
+  if (TARGET GTest::gtest)
+    # Target names in CMake >= v3.23
+    set(gtest_libs GTest::gtest GTest::gmock GTest::gtest_main)
+  else()
+    set(gtest_libs gtest gtest_main gmock)
   endif()
   set(link_pthreads_lib pthread)
 endif()