Revert of [builtins] Unify the various versions of [[Call]] with a Call builtin.

src/runtime.js

 // Copyright 2006-2008 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.
 
 // This files contains runtime support implemented in JavaScript.
 
 // CAUTION: Some of the functions specified in this file are called
 // directly from compiled code. These are the functions with names in
 // ALL CAPS. The compiled code passes the first argument in 'this'.
 
@@ skipping 406 matching lines @@
   }
   throw %make_type_error(kStrongImplicitConversion);
 }
 
 
 /* -----------------------------
    - - -   H e l p e r s   - - -
    -----------------------------
 */
 
+function CALL_NON_FUNCTION() {
+  var delegate = %GetFunctionDelegate(this);
+  return %Apply(delegate, this, arguments, 0, %_ArgumentsLength());
+}
+
+
 function CALL_NON_FUNCTION_AS_CONSTRUCTOR() {
   var delegate = %GetConstructorDelegate(this);
   return %Apply(delegate, this, arguments, 0, %_ArgumentsLength());
 }
 
 
+function CALL_FUNCTION_PROXY() {
+  var arity = %_ArgumentsLength() - 1;
+  var proxy = %_Arguments(arity);  // The proxy comes in as an additional arg.
+  var trap = %GetCallTrap(proxy);
+  return %Apply(trap, this, arguments, 0, arity);
+}
+
+
 function CALL_FUNCTION_PROXY_AS_CONSTRUCTOR () {
   var proxy = this;
   var trap = %GetConstructTrap(proxy);
   return %Apply(trap, this, arguments, 0, %_ArgumentsLength());
 }
 
 
 function APPLY_PREPARE(args) {
   var length;
-
-  // First check that the receiver is callable.
-  if (!IS_CALLABLE(this)) {
-    throw %make_type_error(kApplyNonFunction, %to_string_fun(this),
-                           typeof this);
-  }
-
   // First check whether length is a positive Smi and args is an
   // array. This is the fast case. If this fails, we do the slow case
   // that takes care of more eventualities.
   if (IS_ARRAY(args)) {
     length = args.length;
-    if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength) {
+    if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength &&
+        IS_CALLABLE(this)) {
       return length;
     }
   }
 
   length = (args == null) ? 0 : TO_UINT32(args.length);
 
   // We can handle any number of apply arguments if the stack is
   // big enough, but sanity check the value to avoid overflow when
   // multiplying with pointer size.
   if (length > kSafeArgumentsLength) throw %make_range_error(kStackOverflow);
 
+  if (!IS_CALLABLE(this)) {
+    throw %make_type_error(kApplyNonFunction, %to_string_fun(this),
+                           typeof this);
+  }
+
   // Make sure the arguments list has the right type.
   if (args != null && !IS_SPEC_OBJECT(args)) {
     throw %make_type_error(kWrongArgs, "Function.prototype.apply");
   }
 
   // Return the length which is the number of arguments to copy to the
   // stack. It is guaranteed to be a small integer at this point.
   return length;
 }
 
 
 function REFLECT_APPLY_PREPARE(args) {
   var length;
-
-  // First check that the receiver is callable.
-  if (!IS_CALLABLE(this)) {
-    throw %make_type_error(kApplyNonFunction, %to_string_fun(this),
-                           typeof this);
-  }
-
   // First check whether length is a positive Smi and args is an
   // array. This is the fast case. If this fails, we do the slow case
   // that takes care of more eventualities.
   if (IS_ARRAY(args)) {
     length = args.length;
-    if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength) {
+    if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength &&
+        IS_CALLABLE(this)) {
       return length;
     }
   }
 
+  if (!IS_CALLABLE(this)) {
+    throw %make_type_error(kCalledNonCallable, %to_string_fun(this));
+  }
+
   if (!IS_SPEC_OBJECT(args)) {
     throw %make_type_error(kWrongArgs, "Reflect.apply");
   }
 
   length = %to_length_fun(args.length);
 
   // We can handle any number of apply arguments if the stack is
   // big enough, but sanity check the value to avoid overflow when
   // multiplying with pointer size.
   if (length > kSafeArgumentsLength) throw %make_range_error(kStackOverflow);
@@ skipping 278 matching lines @@
   "add_builtin", ADD,
   "add_strong_builtin", ADD_STRONG,
   "apply_prepare_builtin", APPLY_PREPARE,
   "bit_and_builtin", BIT_AND,
   "bit_and_strong_builtin", BIT_AND_STRONG,
   "bit_or_builtin", BIT_OR,
   "bit_or_strong_builtin", BIT_OR_STRONG,
   "bit_xor_builtin", BIT_XOR,
   "bit_xor_strong_builtin", BIT_XOR_STRONG,
   "call_function_proxy_as_constructor_builtin", CALL_FUNCTION_PROXY_AS_CONSTRUCTOR,
+  "call_function_proxy_builtin", CALL_FUNCTION_PROXY,
   "call_non_function_as_constructor_builtin", CALL_NON_FUNCTION_AS_CONSTRUCTOR,
+  "call_non_function_builtin", CALL_NON_FUNCTION,
   "compare_builtin", COMPARE,
   "compare_strong_builtin", COMPARE_STRONG,
   "concat_iterable_to_array_builtin", CONCAT_ITERABLE_TO_ARRAY,
   "div_builtin", DIV,
   "div_strong_builtin", DIV_STRONG,
   "equals_builtin", EQUALS,
   "mod_builtin", MOD,
   "mod_strong_builtin", MOD_STRONG,
   "mul_builtin", MUL,
   "mul_strong_builtin", MUL_STRONG,
@@ skipping 25 matching lines @@
 
 utils.Export(function(to) {
   to.ToBoolean = ToBoolean;
   to.ToLength = ToLength;
   to.ToNumber = ToNumber;
   to.ToPrimitive = ToPrimitive;
   to.ToString = ToString;
 });
 
 })