further simplify by using Cpp::Construct

Author: aaronj0

core/metacling/src/TClingCallFunc.cxx

@@ -1418,38 +1418,19 @@ void *TClingCallFunc::ExecDefaultConstructor(const TClingClassInfo *info,
       ::Error("TClingCallFunc::ExecDefaultConstructor", "Invalid class info!");
       return nullptr;
    }
-   clang::Decl *D = const_cast<clang::Decl *>(info->GetDecl());
-   // ensure D is a constructor
-   if (!Cpp::IsConstructor(D)) {
-      // we could have the scope decl instead
-      if (Cpp::IsClass(D)) {
-         D = static_cast<clang::Decl *>(Cpp::GetDefaultConstructor(D));
-      } else {
-         ::Error("TClingCallFunc::ExecDefaultConstructor",
-                 "Could not find a default constructor for the given ClassInfo");
-         return nullptr;
-      }
-   }
-
-   // generate wrapper with jitcall
-   Cpp::JitCall JC = Cpp::MakeFunctionCallable(D);
-   if (JC.getKind() != Cpp::JitCall::kConstructorCall) {
-      ::Error("TClingCallFunc::ExecDefaultConstructor", "Could not generate/compile wrapper for given constructor");
-      return nullptr;
-   }
-
    // this function's clients assume nary = 0 for operator new and nary > 0 for array new. JitCall expects
    // the number of objects you want to construct; nary = 1 constructs a single object
    // This handles this difference in semantics
    if (nary == 0)
       nary = 1;
 
-   // invoke the constructor (placement/heap) in one shot
-   // flag is non-null for placement new, null for normal new
-   void *flag = address ? reinterpret_cast<void *>(1) : nullptr;
-   void *result = address;
-   JC.InvokeConstructor(&result, nary, {}, flag);
-   return result;
+   clang::Decl *D = const_cast<clang::Decl *>(info->GetDecl());
+
+   if (Cpp::IsClass(D) || Cpp::IsConstructor(D))
+      return Cpp::Construct(D, address, nary);
+
+   ::Error("TClingCallFunc::ExecDefaultConstructor", "ClassInfo missing a valid Scope/Constructor");
+   return nullptr;
 }
 
 void TClingCallFunc::ExecDestructor(const TClingClassInfo *info, void *address /*=0*/,

interpreter/CppInterOp/include/CppInterOp/CppInterOp.h

@@ -849,7 +849,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/CppInterOp.cpp

@@ -3753,22 +3753,27 @@ 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;
-    }
+  TCppFunction_t ctor;
+  if (Cpp::IsConstructor(scope))
+    ctor = scope;
+  else if (Cpp::IsClass(scope)) {
+    if (!HasDefaultConstructor(scope))
+      return nullptr;
+    ctor = Cpp::GetDefaultConstructor(scope);
+  }
+  else
+    return nullptr;
 
-    void* obj = nullptr;
-    JC.InvokeConstructor(&obj, count, {}, nullptr);
-    return obj;
+  if (JitCall JC = MakeFunctionCallable(&interp, ctor)) {
+    if (JC.getKind() != Cpp::JitCall::kConstructorCall)
+      return nullptr;
+    // invoke the constructor (placement/heap) in one shot
+    // flag is non-null for placement new, null for normal new
+    void* flag = arena ? reinterpret_cast<void*>(1) : nullptr;
+    void* result = arena;
+    JC.InvokeConstructor(&result, count, {}, flag);
+    return result;
   }
   return nullptr;
 }