Change deprecated semantics of function template signatures.

src/builtins.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1220 matching lines @@
 BUILTIN(StrictModePoisonPill) {
   HandleScope scope;
   return isolate->Throw(*isolate->factory()->NewTypeError(
       "strict_poison_pill", HandleVector<Object>(NULL, 0)));
 }
 
 // -----------------------------------------------------------------------------
 //
 
 
-// Returns the holder JSObject if the function can legally be called
-// with this receiver.  Returns Heap::null_value() if the call is
-// illegal.  Any arguments that don't fit the expected type is
-// overwritten with undefined.  Arguments that do fit the expected
-// type is overwritten with the object in the prototype chain that
-// actually has that type.
-static inline Object* TypeCheck(Heap* heap,
-                                int argc,
-                                Object** argv,
-                                FunctionTemplateInfo* info) {
+// Returns true if the function can legally be called with the given
+// receiver. Returns false if the call is illegal. Any arguments that
+// don't fit the expected type are overwritten with undefined.
+static inline bool TypeCheck(Heap* heap,
+                             int argc,
+                             Object** argv,
+                             FunctionTemplateInfo* info) {
   Object* recv = argv[0];
   // API calls are only supported with JSObject receivers.
-  if (!recv->IsJSObject()) return heap->null_value();
+  if (!recv->IsJSObject()) return false;
   Object* sig_obj = info->signature();
-  if (sig_obj->IsUndefined()) return recv;
+  if (sig_obj->IsUndefined()) return true;
   SignatureInfo* sig = SignatureInfo::cast(sig_obj);
   // If necessary, check the receiver
   Object* recv_type = sig->receiver();
-
-  Object* holder = recv;
-  if (!recv_type->IsUndefined()) {
-    for (; holder != heap->null_value(); holder = holder->GetPrototype()) {
-      if (holder->IsInstanceOf(FunctionTemplateInfo::cast(recv_type))) {
-        break;
-      }
-    }
-    if (holder == heap->null_value()) return holder;
+  if (!recv_type->IsUndefined() &&
+      !recv->IsInstanceOf(FunctionTemplateInfo::cast(recv_type))) {
+    return false;
   }
   Object* args_obj = sig->args();
   // If there is no argument signature we're done
-  if (args_obj->IsUndefined()) return holder;
+  if (args_obj->IsUndefined()) return true;
   FixedArray* args = FixedArray::cast(args_obj);
   int length = args->length();
   if (argc <= length) length = argc - 1;
   for (int i = 0; i < length; i++) {
     Object* argtype = args->get(i);
     if (argtype->IsUndefined()) continue;
     Object** arg = &argv[-1 - i];
     Object* current = *arg;
-    for (; current != heap->null_value(); current = current->GetPrototype()) {
-      if (current->IsInstanceOf(FunctionTemplateInfo::cast(argtype))) {
-        *arg = current;
-        break;
-      }
+    if (!current->IsInstanceOf(FunctionTemplateInfo::cast(argtype))) {
+      *arg = heap->undefined_value();
     }
-    if (current == heap->null_value()) *arg = heap->undefined_value();
   }
-  return holder;
+  return true;
 }
 
 
 template <bool is_construct>
 MUST_USE_RESULT static MaybeObject* HandleApiCallHelper(
     BuiltinArguments<NEEDS_CALLED_FUNCTION> args, Isolate* isolate) {
   ASSERT(is_construct == CalledAsConstructor(isolate));
   Heap* heap = isolate->heap();
 
   HandleScope scope(isolate);
   Handle<JSFunction> function = args.called_function();
   ASSERT(function->shared()->IsApiFunction());
 
   FunctionTemplateInfo* fun_data = function->shared()->get_api_func_data();
   if (is_construct) {
     Handle<FunctionTemplateInfo> desc(fun_data, isolate);
     bool pending_exception = false;
     isolate->factory()->ConfigureInstance(
         desc, Handle<JSObject>::cast(args.receiver()), &pending_exception);
     ASSERT(isolate->has_pending_exception() == pending_exception);
     if (pending_exception) return Failure::Exception();
     fun_data = *desc;
   }
 
-  Object* raw_holder = TypeCheck(heap, args.length(), &args[0], fun_data);
-
-  if (raw_holder->IsNull()) {
+  if (!TypeCheck(heap, args.length(), &args[0], fun_data)) {
     // This function cannot be called with the given receiver.  Abort!
     Handle<Object> obj =
         isolate->factory()->NewTypeError(
             "illegal_invocation", HandleVector(&function, 1));
     return isolate->Throw(*obj);
   }
 
   Object* raw_call_data = fun_data->call_code();
   if (!raw_call_data->IsUndefined()) {
     CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
     Object* callback_obj = call_data->callback();
     v8::InvocationCallback callback =
         v8::ToCData<v8::InvocationCallback>(callback_obj);
     Object* data_obj = call_data->data();
     Object* result;
 
     LOG(isolate, ApiObjectAccess("call", JSObject::cast(*args.receiver())));
-    ASSERT(raw_holder->IsJSObject());
 
     CustomArguments custom(isolate);
+    // TODO(2268): Switch to pass holder once embedders have adapted.
     v8::ImplementationUtilities::PrepareArgumentsData(custom.end(),
-        isolate, data_obj, *function, raw_holder);
+        isolate, data_obj, *function, *args.receiver());
 
     v8::Arguments new_args = v8::ImplementationUtilities::NewArguments(
         custom.end(),
         &args[0] - 1,
         args.length() - 1,
         is_construct);
 
     v8::Handle<v8::Value> value;
     {
       // Leaving JavaScript.
@@ skipping 573 matching lines @@
   return Handle<Code>(code_address);                        \
 }
 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C)
 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 
 
 } }  // namespace v8::internal