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

src/promise.js

 // 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.
 
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 11 matching lines @@
 var promiseValueSymbol = utils.GetPrivateSymbol("promise_value_symbol");
 
 // -------------------------------------------------------------------
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
 var lastMicrotaskId = 0;
 
 var GlobalPromise = function Promise(resolver) {
   if (resolver === promiseRawSymbol) return;
   if (!%_IsConstructCall()) throw MakeTypeError(kNotAPromise, this);
-  if (!IS_SPEC_FUNCTION(resolver))
+  if (!IS_CALLABLE(resolver))
     throw MakeTypeError(kResolverNotAFunction, resolver);
   var promise = PromiseInit(this);
   try {
     %DebugPushPromise(promise, Promise);
     resolver(function(x) { PromiseResolve(promise, x) },
              function(r) { PromiseReject(promise, r) });
   } catch (e) {
     PromiseReject(promise, e);
   } finally {
     %DebugPopPromise();
@@ skipping 34 matching lines @@
 }
 
 function PromiseCoerce(constructor, x) {
   if (!IsPromise(x) && IS_SPEC_OBJECT(x)) {
     var then;
     try {
       then = x.then;
     } catch(r) {
       return %_CallFunction(constructor, r, PromiseRejected);
     }
-    if (IS_SPEC_FUNCTION(then)) {
+    if (IS_CALLABLE(then)) {
       var deferred = %_CallFunction(constructor, PromiseDeferred);
       try {
         %_CallFunction(x, deferred.resolve, deferred.reject, then);
       } catch(r) {
         deferred.reject(r);
       }
       return deferred.promise;
     }
   }
   return x;
@@ skipping 153 matching lines @@
   return deferred.promise;
 }
 
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
-  onResolve = IS_SPEC_FUNCTION(onResolve) ? onResolve
-                                          : PromiseIdResolveHandler;
-  onReject = IS_SPEC_FUNCTION(onReject) ? onReject
-                                        : PromiseIdRejectHandler;
+  onResolve = IS_CALLABLE(onResolve) ? onResolve : PromiseIdResolveHandler;
+  onReject = IS_CALLABLE(onReject) ? onReject : PromiseIdRejectHandler;
   var that = this;
   var constructor = this.constructor;
   return %_CallFunction(
     this,
     function(x) {
       x = PromiseCoerce(constructor, x);
       if (x === that) {
         DEBUG_PREPARE_STEP_IN_IF_STEPPING(onReject);
         return onReject(MakeTypeError(kPromiseCyclic, x));
       } else if (IsPromise(x)) {
@@ skipping 108 matching lines @@
   "promise_catch", PromiseCatch,
   "promise_chain", PromiseChain,
   "promise_create", PromiseCreate,
   "promise_has_user_defined_reject_handler", PromiseHasUserDefinedRejectHandler,
   "promise_reject", PromiseReject,
   "promise_resolve", PromiseResolve,
   "promise_then", PromiseThen,
 ]);
 
 })