Implement ConstructorCall in JitCall, disentangled from generics

Author: aaronj0

include/CppInterOp/CppInterOp.h

@@ -103,6 +103,7 @@ class JitCall {
   enum Kind : char {
     kUnknown = 0,
     kGenericCall,
+    kConstructorCall,
     kDestructorCall,
   };
   struct ArgList {
@@ -116,20 +117,25 @@ class JitCall {
   // FIXME: Hide these implementation details by moving wrapper generation in
   // this class.
   // (self, nargs, args, result, nary)
-  using GenericCall = void (*)(void*, size_t, void**, void*, size_t);
+  using GenericCall = void (*)(void*, size_t, void**, void*);
+  // (result, nary, nargs, args, is_arena)
+  using ConstructorCall = void (*)(void*, size_t, size_t, void**, void*);
   // (self, nary, withFree)
   using DestructorCall = void (*)(void*, size_t, int);
 
 private:
   union {
     GenericCall m_GenericCall;
+    ConstructorCall m_ConstructorCall;
     DestructorCall m_DestructorCall;
   };
   Kind m_Kind;
   TCppConstFunction_t m_FD;
   JitCall() : m_GenericCall(nullptr), m_Kind(kUnknown), m_FD(nullptr) {}
   JitCall(Kind K, GenericCall C, TCppConstFunction_t FD)
       : m_GenericCall(C), m_Kind(K), m_FD(FD) {}
+  JitCall(Kind K, ConstructorCall C, TCppConstFunction_t Ctor)
+      : m_ConstructorCall(C), m_Kind(K), m_FD(Ctor) {}
   JitCall(Kind K, DestructorCall C, TCppConstFunction_t Dtor)
       : m_DestructorCall(C), m_Kind(K), m_FD(Dtor) {}
 
@@ -164,20 +170,28 @@ class JitCall {
   // self can go in the end and be nullptr by default; result can be a nullptr
   // by default. These changes should be synchronized with the wrapper if we
   // decide to directly.
-  void Invoke(void* result, ArgList args = {}, void* self = nullptr,
-              size_t nary = 0UL) const {
+  void Invoke(void* result, ArgList args = {}, void* self = nullptr) const {
     // NOLINTBEGIN(*-type-union-access)
-    // Forward if we intended to call a dtor with only 1 parameter.
-    if (m_Kind == kDestructorCall && result && !args.m_Args) {
-      InvokeDestructor(result, nary, /*withFree=*/true);
-      return;
+    // Its possible the JitCall object deals with structor decls but went through Invoke
+    if (result && !args.m_Args && m_Kind!=kGenericCall) {
+      // Forward if we intended to call a dtor with only 1 parameter.
+      if (m_Kind == kDestructorCall) {
+          InvokeDestructor(result, /*nary=*/0UL, /*withFree=*/true);
+          return;
+      }
+      // Forward if we intended to call a constructor (nary cannot be inferred, so
+      // we stick to constructing a single object)
+      if (m_Kind == kConstructorCall) {
+          InvokeConstructor(result, /*nary=*/1UL, args, self);
+          return;
+      }
     }
 
 #ifndef NDEBUG
     assert(AreArgumentsValid(result, args, self) && "Invalid args!");
     ReportInvokeStart(result, args, self);
 #endif // NDEBUG
-    m_GenericCall(self, args.m_ArgSize, args.m_Args, result, nary);
+    m_GenericCall(self, args.m_ArgSize, args.m_Args, result);
     // NOLINTEND(*-type-union-access)
   }
   /// Makes a call to a destructor.
@@ -195,6 +209,23 @@ class JitCall {
 #endif // NDEBUG
     m_DestructorCall(object, nary, withFree);
   }
+
+  /// Makes a call to a constructor.
+  ///\param[in] result - the memory address at which we construct the object
+  ///           (placement new).
+  ///\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.
+  // 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 {
+    assert(m_Kind == kConstructorCall && "Wrong overload!");
+#ifndef NDEBUG
+    assert(AreArgumentsValid(result, args, nullptr, nary) && "Invalid args!");
+    ReportInvokeStart(result, args, nullptr);
+#endif // NDEBUG
+    m_ConstructorCall(result, nary, args.m_ArgSize, args.m_Args, is_arena);
+  }
 };
 
 ///\returns the version string information of the library.

include/clang-c/CXCppInterOp.h

@@ -333,7 +333,7 @@ CINDEX_LINKAGE void clang_deallocate(CXObject address);
  * arena is set it uses placement new.
  */
 CINDEX_LINKAGE CXObject clang_construct(CXScope scope, void* arena,
-                                        size_t count);
+                                        size_t count = 1UL);
 
 /**
  * Creates a trampoline function and makes a call to a generic function or
@@ -350,7 +350,7 @@ CINDEX_LINKAGE CXObject clang_construct(CXScope scope, void* arena,
  * \param self The 'this pointer' of the object.
  */
 CINDEX_LINKAGE void clang_invoke(CXScope func, void* result, void** args,
-                                 size_t n, size_t nary, void* self);
+                                 size_t n, void* self);
 
 /**
  * Calls the destructor of object of type \c type. When withFree is true it

lib/CppInterOp/CXCppInterOp.cpp

@@ -606,9 +606,9 @@ CXObject clang_construct(CXScope scope, void* arena, size_t count) {
 }
 
 void clang_invoke(CXScope func, void* result, void** args, size_t n,
-                  size_t nary, void* self) {
+                  void* self) {
   Cpp::MakeFunctionCallable(getInterpreter(func), getDecl(func))
-      .Invoke(result, {args, n}, self, nary);
+      .Invoke(result, {args, n}, self);
 }
 
 namespace Cpp {

lib/CppInterOp/CppInterOp.cpp

@@ -2947,6 +2947,13 @@ CPPINTEROP_API JitCall MakeFunctionCallable(TInterp_t I,
     return {};
   }
 
+  if (const auto* Ctor = dyn_cast<CXXConstructorDecl>(D)) {
+    if (auto Wrapper = make_wrapper(*interp, cast<FunctionDecl>(D)))
+      return {JitCall::kConstructorCall, Wrapper, Ctor};
+    // FIXME: else error we failed to compile the wrapper.
+    return {};
+  }
+
   if (auto Wrapper = make_wrapper(*interp, cast<FunctionDecl>(D))) {
     return {JitCall::kGenericCall, Wrapper, cast<FunctionDecl>(D)};
   }
@@ -3693,13 +3700,13 @@ TCppObject_t Construct(compat::Interpreter& interp, TCppScope_t scope,
   auto* const Ctor = GetDefaultConstructor(interp, Class);
   if (JitCall JC = MakeFunctionCallable(&interp, Ctor)) {
     if (arena) {
-      JC.Invoke(&arena, {}, (void*)~0,
-                count); // Tell Invoke to use placement new.
+      JC.InvokeConstructor(&arena, count, {},
+                           (void*)~0); // Tell Invoke to use placement new.
       return arena;
     }
 
     void* obj = nullptr;
-    JC.Invoke(&obj);
+    JC.InvokeConstructor(&obj, count, {}, nullptr);
     return obj;
   }
   return nullptr;

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1481,7 +1481,7 @@ TEST(FunctionReflectionTest, JitCallAdvanced) {
   auto* I = clang_createInterpreterFromRawPtr(Cpp::GetInterpreter());
   auto S = clang_getDefaultConstructor(make_scope(Decls[0], I));
   void* object_c = nullptr;
-  clang_invoke(S, &object_c, nullptr, 0, 0UL, nullptr);
+  clang_invoke(S, &object_c, nullptr, 0, nullptr);
   EXPECT_TRUE(object_c) << "Failed to call the ctor.";
   clang_destruct(object_c, make_scope(Decls[1], I), true);
   // Clean up resources
@@ -1974,7 +1974,7 @@ TEST(FunctionReflectionTest, Construct) {
   testing::internal::CaptureStdout();
   auto* I = clang_createInterpreterFromRawPtr(Cpp::GetInterpreter());
   auto scope_c = make_scope(static_cast<clang::Decl*>(scope), I);
-  auto object_c = clang_construct(scope_c, nullptr, 0UL);
+  auto object_c = clang_construct(scope_c, nullptr, 1UL);
   EXPECT_TRUE(object_c != nullptr);
   output = testing::internal::GetCapturedStdout();
   EXPECT_EQ(output, "Constructor Executed");
@@ -2097,7 +2097,7 @@ TEST(FunctionReflectionTest, Destruct) {
   testing::internal::CaptureStdout();
   auto* I = clang_createInterpreterFromRawPtr(Cpp::GetInterpreter());
   auto scope_c = make_scope(static_cast<clang::Decl*>(scope), I);
-  auto object_c = clang_construct(scope_c, nullptr, 0UL);
+  auto object_c = clang_construct(scope_c, nullptr, 1UL);
   clang_destruct(object_c, scope_c, true);
   output = testing::internal::GetCapturedStdout();
   EXPECT_EQ(output, "Destructor Executed");