[promise] Make Promise.reject match spec, and validate promise capabilities

src/js/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, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 209 matching lines @@
 function NewPromiseCapability(C) {
   if (C === GlobalPromise) {
     // Optimized case, avoid extra closure.
     var promise = PromiseInit(new GlobalPromise(promiseRawSymbol));
     var callbacks = CreateResolvingFunctions(promise);
     return {
       promise: promise,
       resolve: callbacks.resolve,
       reject: callbacks.reject
     };
-  } else {
-    var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
-    result.promise = new C(function(resolve, reject) {
-      // TODO(littledan): Check for resolve and reject being not undefined
-      result.resolve = resolve;
-      result.reject = reject;
-    });
-    return result;
   }
+
+  var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
+  result.promise = new C(function(resolve, reject) {
+    if (!IS_UNDEFINED(result.resolve) || !IS_UNDEFINED(result.reject))
+        throw MakeTypeError(kPromiseExecutorAlreadyInvoked);
+    result.resolve = resolve;
+    result.reject = reject;
+  });
+
+  if (!IS_CALLABLE(result.resolve))
+      throw MakeTypeError(kCalledNonCallable, "promiseCapability.[[Resolve]]");
+  if (!IS_CALLABLE(result.reject))
+      throw MakeTypeError(kCalledNonCallable, "promiseCapability.[[Reject]]");
+
+  return result;
 }
 
 function PromiseDeferred() {
   return NewPromiseCapability(this);
 }
 
 function PromiseResolved(x) {
   return %_Call(PromiseCast, this, x);
 }
 
 function PromiseRejected(r) {
   if (!IS_RECEIVER(this)) {
     throw MakeTypeError(kCalledOnNonObject, PromiseRejected);
   }
-  var promise;
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
-    promise = PromiseCreateAndSet(-1, r);
+    var promise = PromiseCreateAndSet(-1, r);
     // The debug event for this would always be an uncaught promise reject,
     // which is usually simply noise. Do not trigger that debug event.
     %PromiseRejectEvent(promise, r, false);
+    return promise;
   } else {
-    promise = new this(function(resolve, reject) { reject(r) });
+    var promiseCapability = NewPromiseCapability(this);
+    %_Call(promiseCapability.reject, UNDEFINED, r);

[adamk, 2016/01/05 20:33:09]

Any reason to use %_Call here instead of just making the call directly?

[caitp (gmail), 2016/01/05 20:39:54]

The `promiseCapability` object is emulating a Record type in the spec, and is
not meant to be exposed to userland JS.

It's possible to see it as the method receiver when the callback is not created
by v8's implementation

[adamk, 2016/01/05 20:44:41]

You could do:

var reject = promiseCapability.reject;
reject(r);

but I guess that's not a huge gain, given you have access to %_Call.

+    return promiseCapability.promise;
   }
-  return promise;
 }
 
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
   var constructor = this.constructor;
   onResolve = IS_CALLABLE(onResolve) ? onResolve : PromiseIdResolveHandler;
   onReject = IS_CALLABLE(onReject) ? onReject : PromiseIdRejectHandler;
   var deferred = NewPromiseCapability(constructor);
   switch (GET_PRIVATE(this, promiseStatusSymbol)) {
@@ skipping 78 matching lines @@
       deferred.resolve(resolutions);
     }
 
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 function PromiseRace(iterable) {
+  if (!IS_RECEIVER(this)) {
+    throw MakeTypeError(kCalledOnNonObject, PromiseRace);
+  }
+
   var deferred = NewPromiseCapability(this);
   try {
     for (var value of iterable) {
       var reject = function(r) { deferred.reject(r) };
       this.resolve(value).then(function(x) { deferred.resolve(x) }, reject);
       SET_PRIVATE(reject, promiseCombinedDeferredSymbol, deferred);
     }
   } catch (e) {
     deferred.reject(e)
   }
@@ skipping 71 matching lines @@
 [PromiseChain, PromiseDeferred, PromiseResolved].forEach(
     fn => %FunctionRemovePrototype(fn));
 
 utils.Export(function(to) {
   to.PromiseChain = PromiseChain;
   to.PromiseDeferred = PromiseDeferred;
   to.PromiseResolved = PromiseResolved;
 });
 
 })