[api] Expose FunctionCallbackInfo::NewTarget

src/builtins.cc

 // Copyright 2012 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.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/base/once.h"
@@ skipping 4460 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 //
 
 
 namespace {
 
 template <bool is_construct>
 MUST_USE_RESULT MaybeHandle<Object> HandleApiCallHelper(
     Isolate* isolate, BuiltinArguments<BuiltinExtraArguments::kTarget> args) {

[Benedikt Meurer, 2016/04/23 11:57:47]

You could change this to generally accept kTargetAndNewTarget, then you don't
need to duplicate the code. Just make sure to also push NewTarget in
builtins-x64.cc

[Benedikt Meurer, 2016/04/23 18:21:45]

Ignore the part about builtins-x64.cc, I just noticed that this will already
work.

[adamk, 2016/04/25 18:53:40]

Can you point me at where we load undefined for the non-construct case? I see it
for ReflectApply and FunctionApply, but not in the general case...

[Benedikt Meurer, 2016/04/25 19:02:00]

Sure, it's part of the invoke function sequence, see
https://code.google.com/p/chromium/codesearch#chromium/src/v8/src/x64/macro-a...
for the x64 port.

[adamk, 2016/04/25 22:59:55]

Done.

   HandleScope scope(isolate);
   Handle<HeapObject> function = args.target<HeapObject>();
   Handle<JSReceiver> receiver;
 
   DCHECK(function->IsFunctionTemplateInfo() ||
          Handle<JSFunction>::cast(function)->shared()->IsApiFunction());
 
   Handle<FunctionTemplateInfo> fun_data =
       function->IsFunctionTemplateInfo()
           ? Handle<FunctionTemplateInfo>::cast(function)
           : handle(JSFunction::cast(*function)->shared()->get_api_func_data());
   if (is_construct) {
     DCHECK(args.receiver()->IsTheHole());

[Benedikt Meurer, 2016/04/23 11:57:47]

I wonder if we could unify this with the general implicit receiver construction.
If yes, then we could get away with only HandleApiCall and we wouldn't even need
the distinction in the JSConstructStubHelper.

     if (fun_data->instance_template()->IsUndefined()) {
       v8::Local<ObjectTemplate> templ =
           ObjectTemplate::New(reinterpret_cast<v8::Isolate*>(isolate),
                               ToApiHandle<v8::FunctionTemplate>(fun_data));
       fun_data->set_instance_template(*Utils::OpenHandle(*templ));
     }
     Handle<ObjectTemplateInfo> instance_template(
         ObjectTemplateInfo::cast(fun_data->instance_template()), isolate);
     ASSIGN_RETURN_ON_EXCEPTION(isolate, receiver,
                                ApiNatives::InstantiateObject(instance_template),
@@ skipping 28 matching lines @@
     DCHECK(raw_call_data->IsCallHandlerInfo());
     CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
     Object* callback_obj = call_data->callback();
     v8::FunctionCallback callback =
         v8::ToCData<v8::FunctionCallback>(callback_obj);
     Object* data_obj = call_data->data();
 
     LOG(isolate, ApiObjectAccess("call", JSObject::cast(*args.receiver())));
     DCHECK(raw_holder->IsJSObject());
 
-    FunctionCallbackArguments custom(isolate,
-                                     data_obj,
-                                     *function,
-                                     raw_holder,
-                                     &args[0] - 1,
-                                     args.length() - 1,
+    FunctionCallbackArguments custom(isolate, data_obj, *function, raw_holder,
+                                     isolate->heap()->undefined_value(),
+                                     &args[0] - 1, args.length() - 1,
                                      is_construct);
 
     Handle<Object> result = custom.Call(callback);
     if (result.is_null()) result = isolate->factory()->undefined_value();
 
     RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
     if (!is_construct || result->IsJSObject()) {
       return scope.CloseAndEscape(result);
     }
   }
 
   return scope.CloseAndEscape(receiver);
 }
 
 }  // namespace
 
 
 BUILTIN(HandleApiCall) {
   HandleScope scope(isolate);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
                                      HandleApiCallHelper<false>(isolate, args));
   return *result;
 }
 
 
 BUILTIN(HandleApiCallConstruct) {
   HandleScope scope(isolate);
-  Handle<Object> result;
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
-                                     HandleApiCallHelper<true>(isolate, args));
-  return *result;
+  Handle<HeapObject> function = args.target<HeapObject>();
+  Handle<HeapObject> new_target = args.new_target();
+  Handle<JSReceiver> receiver;
+
+  DCHECK(function->IsFunctionTemplateInfo() ||
+         Handle<JSFunction>::cast(function)->shared()->IsApiFunction());
+
+  Handle<FunctionTemplateInfo> fun_data =
+      function->IsFunctionTemplateInfo()
+          ? Handle<FunctionTemplateInfo>::cast(function)
+          : handle(JSFunction::cast(*function)->shared()->get_api_func_data());
+  DCHECK(args.receiver()->IsTheHole());
+  if (fun_data->instance_template()->IsUndefined()) {
+    v8::Local<ObjectTemplate> templ =
+        ObjectTemplate::New(reinterpret_cast<v8::Isolate*>(isolate),
+                            ToApiHandle<v8::FunctionTemplate>(fun_data));
+    fun_data->set_instance_template(*Utils::OpenHandle(*templ));
+  }
+  Handle<ObjectTemplateInfo> instance_template(
+      ObjectTemplateInfo::cast(fun_data->instance_template()), isolate);
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+      isolate, receiver, ApiNatives::InstantiateObject(instance_template));
+  args[0] = *receiver;
+  DCHECK_EQ(*receiver, *args.receiver());
+
+  Object* raw_holder = fun_data->GetCompatibleReceiver(isolate, *receiver);
+
+  if (raw_holder->IsNull()) {
+    // This function cannot be called with the given receiver.  Abort!
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kIllegalInvocation));
+  }
+
+  Object* raw_call_data = fun_data->call_code();
+  if (!raw_call_data->IsUndefined()) {
+    DCHECK(raw_call_data->IsCallHandlerInfo());
+    CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
+    Object* callback_obj = call_data->callback();
+    v8::FunctionCallback callback =
+        v8::ToCData<v8::FunctionCallback>(callback_obj);
+    Object* data_obj = call_data->data();
+
+    LOG(isolate, ApiObjectAccess("call", JSObject::cast(*args.receiver())));
+    DCHECK(raw_holder->IsJSObject());
+
+    FunctionCallbackArguments custom(isolate, data_obj, *function, raw_holder,
+                                     *new_target, &args[0] - 1,
+                                     args.length() - 1, true);
+
+    Handle<Object> result = custom.Call(callback);
+    if (result.is_null()) result = isolate->factory()->undefined_value();
+
+    RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+    if (result->IsJSObject()) {
+      return *result;
+    }
+  }
+
+  return *receiver;
 }
 
 Handle<Code> Builtins::CallFunction(ConvertReceiverMode mode,
                                     TailCallMode tail_call_mode) {
   switch (tail_call_mode) {
     case TailCallMode::kDisallow:
       switch (mode) {
         case ConvertReceiverMode::kNullOrUndefined:
           return CallFunction_ReceiverIsNullOrUndefined();
         case ConvertReceiverMode::kNotNullOrUndefined:
@@ skipping 158 matching lines @@
   Object* callback_obj = call_data->callback();
   v8::FunctionCallback callback =
       v8::ToCData<v8::FunctionCallback>(callback_obj);
 
   // Get the data for the call and perform the callback.
   Object* result;
   {
     HandleScope scope(isolate);
     LOG(isolate, ApiObjectAccess("call non-function", obj));
 
-    FunctionCallbackArguments custom(isolate,
-                                     call_data->data(),
-                                     constructor,
-                                     obj,
-                                     &args[0] - 1,
-                                     args.length() - 1,
+    FunctionCallbackArguments custom(isolate, call_data->data(), constructor,
+                                     obj, isolate->heap()->undefined_value(),
+                                     &args[0] - 1, args.length() - 1,
                                      is_construct_call);
     Handle<Object> result_handle = custom.Call(callback);
     if (result_handle.is_null()) {
       result = isolate->heap()->undefined_value();
     } else {
       result = *result_handle;
     }
   }
   // Check for exceptions and return result.
   RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
@@ skipping 571 matching lines @@
 BUILTIN_LIST_T(DEFINE_BUILTIN_ACCESSOR_T)
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 #undef DEFINE_BUILTIN_ACCESSOR_T
 #undef DEFINE_BUILTIN_ACCESSOR_H
 
 }  // namespace internal
 }  // namespace v8