[es6] Initial steps towards a correct implementation of IsCallable.

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 423 matching lines @@
       return this < x.length;
     }
     return %HasElement(x, this);
   }
   return %HasProperty(x, this);
 }
 
 
 function CALL_NON_FUNCTION() {
   var delegate = %GetFunctionDelegate(this);
-  if (!IS_FUNCTION(delegate)) {
-    var callsite = %RenderCallSite();
-    if (callsite == "") callsite = typeof this;
-    throw %make_type_error(kCalledNonCallable, callsite);
-  }
   return %Apply(delegate, this, arguments, 0, %_ArgumentsLength());
 }
 
 
 function CALL_NON_FUNCTION_AS_CONSTRUCTOR() {
   var delegate = %GetConstructorDelegate(this);
-  if (!IS_FUNCTION(delegate)) {
-    var callsite = %RenderCallSite();
-    if (callsite == "") callsite = typeof this;
-    throw %make_type_error(kCalledNonCallable, callsite);
-  }
   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 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 &&
-        IS_SPEC_FUNCTION(this)) {
+        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_SPEC_FUNCTION(this)) {
-    throw %make_type_error(kApplyNonFunction, %to_string_fun(this), typeof this);
+  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 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 &&
-        IS_SPEC_FUNCTION(this)) {
+        IS_CALLABLE(this)) {
       return length;
     }
   }
 
-  if (!IS_SPEC_FUNCTION(this)) {
+  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);
 
   // 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_CONSTRUCT_PREPARE(
     args, newTarget) {
   var length;
-  var ctorOk = IS_SPEC_FUNCTION(this) && %IsConstructor(this);
-  var newTargetOk = IS_SPEC_FUNCTION(newTarget) && %IsConstructor(newTarget);
+  var ctorOk = IS_CALLABLE(this) && %IsConstructor(this);
+  var newTargetOk = IS_CALLABLE(newTarget) && %IsConstructor(newTarget);
 
   // 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 &&
         ctorOk && newTargetOk) {
       return length;
     }
   }
 
   if (!ctorOk) {
-    if (!IS_SPEC_FUNCTION(this)) {
+    if (!IS_CALLABLE(this)) {
       throw %make_type_error(kCalledNonCallable, %to_string_fun(this));
     } else {
       throw %make_type_error(kNotConstructor, %to_string_fun(this));
     }
   }
 
   if (!newTargetOk) {
-    if (!IS_SPEC_FUNCTION(newTarget)) {
+    if (!IS_CALLABLE(newTarget)) {
       throw %make_type_error(kCalledNonCallable, %to_string_fun(newTarget));
     } else {
       throw %make_type_error(kNotConstructor, %to_string_fun(newTarget));
     }
   }
 
   if (!IS_SPEC_OBJECT(args)) {
     throw %make_type_error(kWrongArgs, "Reflect.construct");
   }
 
@@ skipping 159 matching lines @@
   if (!IS_SPEC_OBJECT(O)) return false;
   var spreadable = O[isConcatSpreadableSymbol];
   if (IS_UNDEFINED(spreadable)) return IS_ARRAY(O);
   return ToBoolean(spreadable);
 }
 
 
 // ECMA-262, section 8.6.2.6, page 28.
 function DefaultNumber(x) {
   var valueOf = x.valueOf;
-  if (IS_SPEC_FUNCTION(valueOf)) {
+  if (IS_CALLABLE(valueOf)) {
     var v = %_CallFunction(x, valueOf);
     if (IS_SYMBOL(v)) throw MakeTypeError(kSymbolToNumber);
     if (IS_SIMD_VALUE(x)) throw MakeTypeError(kSimdToNumber);
     if (IsPrimitive(v)) return v;
   }
   var toString = x.toString;
-  if (IS_SPEC_FUNCTION(toString)) {
+  if (IS_CALLABLE(toString)) {
     var s = %_CallFunction(x, toString);
     if (IsPrimitive(s)) return s;
   }
   throw MakeTypeError(kCannotConvertToPrimitive);
 }
 
 // ECMA-262, section 8.6.2.6, page 28.
 function DefaultString(x) {
   if (!IS_SYMBOL_WRAPPER(x)) {
     if (IS_SYMBOL(x)) throw MakeTypeError(kSymbolToString);
     var toString = x.toString;
-    if (IS_SPEC_FUNCTION(toString)) {
+    if (IS_CALLABLE(toString)) {
       var s = %_CallFunction(x, toString);
       if (IsPrimitive(s)) return s;
     }
 
     var valueOf = x.valueOf;
-    if (IS_SPEC_FUNCTION(valueOf)) {
+    if (IS_CALLABLE(valueOf)) {
       var v = %_CallFunction(x, valueOf);
       if (IsPrimitive(v)) return v;
     }
   }
   throw MakeTypeError(kCannotConvertToPrimitive);
 }
 
 function ToPositiveInteger(x, rangeErrorIndex) {
   var i = TO_INTEGER_MAP_MINUS_ZERO(x);
   if (i < 0) throw MakeRangeError(rangeErrorIndex);
@@ skipping 78 matching lines @@
 
 utils.Export(function(to) {
   to.ToBoolean = ToBoolean;
   to.ToLength = ToLength;
   to.ToNumber = ToNumber;
   to.ToPrimitive = ToPrimitive;
   to.ToString = ToString;
 });
 
 })