[api] Stay in C++ when constructing an API-function

src/builtins/builtins-api.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/builtins/builtins.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/builtins/builtins-utils.h"
 
@@ skipping 139 matching lines @@
     v->VisitPointers(lowest_address(), highest_address() + 1);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RelocatableArguments);
 };
 
 }  // namespace
 
 MaybeHandle<Object> Builtins::InvokeApiFunction(Isolate* isolate,
+                                                bool is_construct,
                                                 Handle<HeapObject> function,
                                                 Handle<Object> receiver,
-                                                int argc,
-                                                Handle<Object> args[]) {
+                                                int argc, Handle<Object> args[],
+                                                Handle<HeapObject> new_target) {
   DCHECK(function->IsFunctionTemplateInfo() ||
          (function->IsJSFunction() &&
           JSFunction::cast(*function)->shared()->IsApiFunction()));
 
   // Do proper receiver conversion for non-strict mode api functions.
-  if (!receiver->IsJSReceiver()) {
+  if (!is_construct && !receiver->IsJSReceiver()) {
     if (function->IsFunctionTemplateInfo() ||
         is_sloppy(JSFunction::cast(*function)->shared()->language_mode())) {
       ASSIGN_RETURN_ON_EXCEPTION(isolate, receiver,
                                  Object::ConvertReceiver(isolate, receiver),
                                  Object);
     }
   }
 
   Handle<FunctionTemplateInfo> fun_data =
       function->IsFunctionTemplateInfo()
           ? Handle<FunctionTemplateInfo>::cast(function)
           : handle(JSFunction::cast(*function)->shared()->get_api_func_data(),
                    isolate);
-  Handle<HeapObject> new_target = isolate->factory()->undefined_value();
   // Construct BuiltinArguments object:
   // new target, function, arguments reversed, receiver.
   const int kBufferSize = 32;
   Object* small_argv[kBufferSize];
   Object** argv;
   const int frame_argc = argc + BuiltinArguments::kNumExtraArgsWithReceiver;
   if (frame_argc <= kBufferSize) {
     argv = small_argv;
   } else {
     argv = new Object*[frame_argc];
   }
   int cursor = frame_argc - 1;
   argv[cursor--] = *receiver;
   for (int i = 0; i < argc; ++i) {
     argv[cursor--] = *args[i];
   }
   DCHECK(cursor == BuiltinArguments::kArgcOffset);
   argv[BuiltinArguments::kArgcOffset] = Smi::FromInt(frame_argc);
   argv[BuiltinArguments::kTargetOffset] = *function;
   argv[BuiltinArguments::kNewTargetOffset] = *new_target;
   MaybeHandle<Object> result;
   {
     RelocatableArguments arguments(isolate, frame_argc, &argv[frame_argc - 1]);
-    result = HandleApiCallHelper<false>(isolate, function, new_target, fun_data,
-                                        receiver, arguments);
+    if (is_construct) {
+      result = HandleApiCallHelper<true>(isolate, function, new_target,
+                                         fun_data, receiver, arguments);
+    } else {
+      result = HandleApiCallHelper<false>(isolate, function, new_target,
+                                          fun_data, receiver, arguments);
+    }
   }
   if (argv != small_argv) delete[] argv;
   return result;
 }
 
 // Helper function to handle calls to non-function objects created through the
 // API. The object can be called as either a constructor (using new) or just as
 // a function (without new).
 MUST_USE_RESULT static Object* HandleApiCallAsFunctionOrConstructor(
     Isolate* isolate, bool is_construct_call, BuiltinArguments args) {
@@ skipping 58 matching lines @@
 }
 
 // Handle calls to non-function objects created through the API. This delegate
 // function is used when the call is a construct call.
 BUILTIN(HandleApiCallAsConstructor) {
   return HandleApiCallAsFunctionOrConstructor(isolate, true, args);
 }
 
 }  // namespace internal
 }  // namespace v8