[interop] Fix build errors with -Dtesting=off (#17791)

* [interop] Bump to latest version, fixes cmake overriding testing flag

* Patch in InterOp that fixes testing mode issues(to be upstreamed)

* [interpreter] Configure the flags for InterOp correctly

Also moves the addition of `CppInterOpUnitTests` to the build chain, from metacling, to the interpreter cmake

Author: aaronj0

.github/workflows/cppinterop-diff.yml

@@ -16,7 +16,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: compiler-research/CppInterOp
-          ref: 6c6f94a22bd971520a249e2c02e4259cdd3a5be6
+          ref: b0c3e360bdbea9618dd2744836671667c108bf97
           path: CppInterOp
       - name: Drop directories that are not added to ROOT
         working-directory: CppInterOp

core/metacling/src/CMakeLists.txt

@@ -125,10 +125,6 @@ ROOT_LINKER_LIBRARY(Cling
 # When these two link at the same time, they can exhaust the RAM on many machines, since they both link against llvm.
 add_dependencies(Cling rootcling_stage1)
 
-if(testing)
-  set_target_properties(CppInterOpUnitTests PROPERTIES EXCLUDE_FROM_ALL OFF)
-endif()
-
 if(MSVC)
   set_target_properties(Cling PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
   set(cling_exports ${cling_exports}

interpreter/CMakeLists.txt

@@ -523,6 +523,17 @@ set(CPPINTEROP_INCLUDE_DIRS
   CACHE STRING "CppInterOp include directories.")
 
 #---Set InterOp to build on Cling, this can be toggled to use Clang-REPL-------------------------------------------------------
-set(CPPINTEROP_USE_CLING ON BOOL "Use Cling as backend")
+set(CPPINTEROP_USE_CLING ON CACHE BOOL "" FORCE)
+set(CPPINTEROP_USE_REPL OFF CACHE BOOL "" FORCE)
+
+#---Disable testing on InterOp if ROOT's testing is OFF (InterOp tests are enabled by default) -------------------------------------------------------
+if(testing)
+  set(CPPINTEROP_ENABLE_TESTING ON CACHE BOOL "" FORCE)
+else()
+  set(CPPINTEROP_ENABLE_TESTING OFF CACHE BOOL "")
+endif()
 
 add_subdirectory(CppInterOp)
+if(testing)
+  set_target_properties(CppInterOpUnitTests PROPERTIES EXCLUDE_FROM_ALL OFF)
+endif()

interpreter/CppInterOp/CMakeLists.txt

@@ -6,6 +6,16 @@ set(CMAKE_MODULE_PATH
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules"
   )
 
+enable_language(CXX)
+set(CMAKE_CXX_EXTENSIONS NO)
+
+option(CPPINTEROP_USE_CLING "Use Cling as backend" OFF)
+option(CPPINTEROP_USE_REPL "Use clang-repl as backend" ON)
+option(CPPINTEROP_ENABLE_TESTING "Enable the CppInterOp testing infrastructure." ON)
+
+if (CPPINTEROP_USE_CLING AND CPPINTEROP_USE_REPL)
+message(FATAL_ERROR "We can only use Cling (${CPPINTEROP_USE_CLING}=On) or Repl (CPPINTEROP_USE_REPL=On), but not both of them.")
+endif()
 # If we are not building as a part of LLVM, build CppInterOp as a standalone
 # project, using LLVM as an external library:
 if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
@@ -51,19 +61,10 @@ if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
     endif()
     if (NOT DEFINED Clang_DIR)
       set(Clang_DIR ${Cling_DIR})
-    endif()
   endif()
+endif()
 
-enable_language(CXX)
-set(CMAKE_CXX_EXTENSIONS NO)
 include(GNUInstallDirs)
-  option(CPPINTEROP_USE_CLING "Use Cling as backend" OFF)
-  option(CPPINTEROP_USE_REPL "Use clang-repl as backend" ON)
-
-  if (CPPINTEROP_USE_CLING AND CPPINTEROP_USE_REPL)
-    message(FATAL_ERROR "We can only use Cling (CPPINTEROP_USE_CLING=On) or Repl (CPPINTEROP_USE_REPL=On), but not both of them.")
-  endif()
-  
   ## Define supported version of clang and llvm
 
   set(CLANG_MIN_SUPPORTED 13.0)
@@ -292,16 +293,15 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)
 # In rare cases we might want to have clang installed in a different place
 # than llvm and the header files should be found first (even though the
 # LLVM_INCLUDE_DIRS) contain clang headers, too.
-if (CPPINTEROP_USE_CLING)
+if(CPPINTEROP_USE_CLING)
   add_definitions(-DCPPINTEROP_USE_CLING)
   include_directories(SYSTEM ${CLING_INCLUDE_DIRS})
-  else()
-  if (NOT CPPINTEROP_USE_REPL)
-  message(FATAL_ERROR "We need either CPPINTEROP_USE_CLING or CPPINTEROP_USE_REPL")
-  endif()
+elseif(CPPINTEROP_USE_REPL)
   add_definitions(-DCPPINTEROP_USE_REPL)
+else()
+  message(FATAL_ERROR "We need either CPPINTEROP_USE_CLING or CPPINTEROP_USE_REPL")
+endif()
 
-endif(CPPINTEROP_USE_CLING)
 include_directories(SYSTEM ${CLANG_INCLUDE_DIRS})
 include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
 separate_arguments(LLVM_DEFINITIONS_LIST NATIVE_COMMAND ${LLVM_DEFINITIONS})
@@ -453,10 +453,7 @@ option(CPPINTEROP_ENABLE_SPHINX "Use sphinx to generage CppInterOp user document
 
 if(EMSCRIPTEN)
     message("Build with emscripten")
-    option(CPPINTEROP_ENABLE_TESTING "Enables the testing infrastructure." OFF)
-else()
-    message("Build with cmake")
-    option(CPPINTEROP_ENABLE_TESTING "Enables the testing infrastructure." ON)
+    set(CPPINTEROP_ENABLE_TESTING OFF)
 endif()
 
 if(MSVC)

interpreter/CppInterOp/lib/Interpreter/CppInterOp.cpp

@@ -1675,6 +1675,9 @@ namespace Cpp {
       //
       ASTContext& C = FD->getASTContext();
       PrintingPolicy Policy(C.getPrintingPolicy());
+#if CLANG_VERSION_MAJOR > 16
+      Policy.SuppressElaboration = true;
+#endif
       refType = kNotReference;
       if (QT->isRecordType() && forArgument) {
         get_type_as_string(QT, type_name, C, Policy);
@@ -1989,18 +1992,22 @@ namespace Cpp {
         EReferenceType refType = kNotReference;
         bool isPointer = false;
 
+        std::ostringstream typedefbuf;
+        std::ostringstream callbuf;
+
+        collect_type_info(FD, QT, typedefbuf, callbuf, type_name, refType,
+                          isPointer, indent_level, false);
+
+        buf << typedefbuf.str();
+
         buf << "if (ret) {\n";
         ++indent_level;
         {
-          std::ostringstream typedefbuf;
-          std::ostringstream callbuf;
           //
           //  Write the placement part of the placement new.
           //
           indent(callbuf, indent_level);
           callbuf << "new (ret) ";
-          collect_type_info(FD, QT, typedefbuf, callbuf, type_name, refType,
-                            isPointer, indent_level, false);
           //
           //  Write the type part of the placement new.
           //

interpreter/CppInterOp/unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -888,6 +888,9 @@ TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
       int f3() { return 3; }
 
       extern "C" int f4() { return 4; }
+
+      typedef int(*int_func)(void);
+      int_func f5() { return f3; }
     }
   )");
 
@@ -923,6 +926,18 @@ TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
   FCI4.Invoke(&ret4);
   EXPECT_EQ(ret4, 4);
 
+#if CLANG_VERSION_MAJOR > 16
+  Cpp::JitCall FCI5 =
+      Cpp::MakeFunctionCallable(Cpp::GetNamed("f5", Cpp::GetNamed("NS")));
+  EXPECT_TRUE(FCI5.getKind() == Cpp::JitCall::kGenericCall);
+
+  typedef int (*int_func)();
+  int_func callback = nullptr;
+  FCI5.Invoke((void*)&callback);
+  EXPECT_TRUE(callback);
+  EXPECT_EQ(callback(), 3);
+#endif
+
   // FIXME: Do we need to support private ctors?
   Interp->process(R"(
     class C {