[es6] refactor Promise resolution

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();
 
 // -------------------------------------------------------------------
 // Imports
 
 var InternalArray = utils.InternalArray;
 var MakeTypeError;
 var promiseCombinedDeferredSymbol =
     utils.ImportNow("promise_combined_deferred_symbol");
 var promiseHasHandlerSymbol =
     utils.ImportNow("promise_has_handler_symbol");
 var promiseOnRejectSymbol = utils.ImportNow("promise_on_reject_symbol");
 var promiseOnResolveSymbol =
     utils.ImportNow("promise_on_resolve_symbol");
+var alreadyResolvedSymbol = utils.ImportNow("promise_already_resolved_symbol");
 var promiseRawSymbol = utils.ImportNow("promise_raw_symbol");
 var promiseStatusSymbol = utils.ImportNow("promise_status_symbol");
 var promiseValueSymbol = utils.ImportNow("promise_value_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 
 utils.Import(function(from) {
   MakeTypeError = from.MakeTypeError;
 });
 
 // -------------------------------------------------------------------
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
 var lastMicrotaskId = 0;
 
+function CreateResolvingFunctions(promise) {

[caitp (gmail), 2015/11/09 21:10:24]

http://tc39.github.io/ecma262/#sec-createresolvingfunctions --- makes sure that
this is all done the same way every time. context-allocated variables could
technically be used all the time, but I think they aren't needed here?

However, I'm not 100% sure that it avoids context-allocating the function
reference, so it might be a wasted effort for now.

+  var alreadyResolved = { __proto__: null, value: false };
+
+  var resolve = function(value) {

[caitp (gmail), 2015/11/09 21:10:24]

I think the spec mandates that these functions don't have a `name` property,
which will break once names are inferred properly per the spec :(

+    var alreadyResolved = GET_PRIVATE(resolve, alreadyResolvedSymbol);
+    if (alreadyResolved.value === true) return;
+    alreadyResolved.value = true;
+    var promise = GET_PRIVATE(resolve, promiseValueSymbol);
+    if (value === promise) {
+      return PromiseReject(promise, MakeTypeError(kPromiseCyclic, value));
+    }
+    PromiseResolve(promise, value);
+  };
+
+  var reject = function(reason) {
+    if (alreadyResolved.value === true) return;
+    alreadyResolved.value = true;
+    PromiseReject(GET_PRIVATE(reject, promiseValueSymbol), reason);
+  };
+
+  SET_PRIVATE(resolve, promiseValueSymbol, promise);
+  SET_PRIVATE(resolve, alreadyResolvedSymbol, alreadyResolved);
+  SET_PRIVATE(reject, promiseValueSymbol, promise);
+  SET_PRIVATE(reject, alreadyResolvedSymbol, alreadyResolved);
+  return {
+    resolve: resolve,
+    reject: reject
+  };
+}
+
+
 var GlobalPromise = function Promise(resolver) {
   if (resolver === promiseRawSymbol) return;
   if (!%_IsConstructCall()) throw MakeTypeError(kNotAPromise, this);
   if (!IS_CALLABLE(resolver))
     throw MakeTypeError(kResolverNotAFunction, resolver);
   var promise = PromiseInit(this);
   try {
     %DebugPushPromise(promise, Promise, resolver);
-    resolver(function(x) { PromiseResolve(promise, x) },
-             function(r) { PromiseReject(promise, r) });
+    var callbacks = CreateResolvingFunctions(promise);
+    resolver(callbacks.resolve, callbacks.reject);
   } catch (e) {
     PromiseReject(promise, e);
   } finally {
     %DebugPopPromise();
   }
 }
 
 // Core functionality.
 
 function PromiseSet(promise, status, value, onResolve, onReject) {
@@ skipping 29 matching lines @@
 
 function PromiseCoerce(constructor, x) {
   if (!IsPromise(x) && IS_SPEC_OBJECT(x)) {
     var then;
     try {
       then = x.then;
     } catch(r) {
       return %_Call(PromiseRejected, constructor, r);
     }
     if (IS_CALLABLE(then)) {
-      var deferred = %_Call(PromiseDeferred, constructor);
+      var deferred = NewPromiseCapability(constructor);
       try {
         %_Call(then, x, deferred.resolve, deferred.reject);
       } catch(r) {
         deferred.reject(r);
       }
       return deferred.promise;
     }
   }
   return x;
 }
@@ skipping 47 matching lines @@
 
 function IsPromise(x) {
   return IS_SPEC_OBJECT(x) && HAS_DEFINED_PRIVATE(x, promiseStatusSymbol);
 }
 
 function PromiseCreate() {
   return new GlobalPromise(PromiseNopResolver)
 }
 
 function PromiseResolve(promise, x) {
-  PromiseDone(promise, +1, x, promiseOnResolveSymbol)
+  if (GET_PRIVATE(promise, promiseStatusSymbol) === 0) {
+    if (IS_SPEC_OBJECT(x)) {
+      // 25.4.1.3.2 steps 8-12
+      try {
+        var then = x.then;
+      } catch (e) {
+        return PromiseReject(promise, e);
+      }
+      if (IS_CALLABLE(then)) {
+        // PromiseResolveThenableJob
+        return %EnqueueMicrotask(function() {
+          try {
+            var callbacks = CreateResolvingFunctions(promise);
+            %_Call(then, x, callbacks.resolve, callbacks.reject);
+          } catch (e) {
+            PromiseReject(promise, e);
+          }
+        });
+      }
+    }
+    PromiseDone(promise, +1, x, promiseOnResolveSymbol);
+  }
 }
 
 function PromiseReject(promise, r) {
   // Check promise status to confirm that this reject has an effect.
   // Call runtime for callbacks to the debugger or for unhandled reject.
   if (GET_PRIVATE(promise, promiseStatusSymbol) == 0) {
     var debug_is_active = DEBUG_IS_ACTIVE;
     if (debug_is_active ||
         !HAS_DEFINED_PRIVATE(promise, promiseHasHandlerSymbol)) {
       %PromiseRejectEvent(promise, r, debug_is_active);
     }
   }
   PromiseDone(promise, -1, r, promiseOnRejectSymbol)
 }
 
 // Convenience.
 
-function PromiseDeferred() {
-  if (this === GlobalPromise) {
+function NewPromiseCapability(C) {

[caitp (gmail), 2015/11/09 21:10:24]

Sort-of (but not quite) matches the spec concept "NewPromiseCapability()", and
allows getting rid of %_Call() to invoke it.

+  if (C === GlobalPromise) {
     // Optimized case, avoid extra closure.
     var promise = PromiseInit(new GlobalPromise(promiseRawSymbol));
+    var callbacks = CreateResolvingFunctions(promise);
     return {
       promise: promise,
-      resolve: function(x) { PromiseResolve(promise, x) },
-      reject: function(r) { PromiseReject(promise, r) }
+      resolve: callbacks.resolve,
+      reject: callbacks.reject
     };
   } else {
-    var result = {promise: UNDEFINED, reject: UNDEFINED, resolve: UNDEFINED};
-    result.promise = new this(function(resolve, reject) {
+    var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
+    result.promise = new C(function(resolve, reject) {
       result.resolve = resolve;
       result.reject = reject;
     });
     return result;
   }
 }
 
+function PromiseDeferred() {
+  return NewPromiseCapability(this);
+}
+
 function PromiseResolved(x) {
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
     return PromiseCreateAndSet(+1, x);
   } else {
     return new this(function(resolve, reject) { resolve(x) });
   }
 }
 
 function PromiseRejected(r) {
   var promise;
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
     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);
   } else {
     promise = new this(function(resolve, reject) { reject(r) });
   }
   return promise;
 }
 
 // Simple chaining.
 
-function PromiseChain(onResolve, onReject) {  // a.k.a. flatMap
+// PromiseChain a.k.a. flatMap
+function PromiseChainInternal(constructor, onResolve, onReject) {
   onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
   onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
-  var deferred = %_Call(PromiseDeferred, this.constructor);
+  var deferred = NewPromiseCapability(constructor);
   switch (GET_PRIVATE(this, promiseStatusSymbol)) {
     case UNDEFINED:
       throw MakeTypeError(kNotAPromise, this);
     case 0:  // Pending
       GET_PRIVATE(this, promiseOnResolveSymbol).push(onResolve, deferred);
       GET_PRIVATE(this, promiseOnRejectSymbol).push(onReject, deferred);
       break;
     case +1:  // Resolved
       PromiseEnqueue(GET_PRIVATE(this, promiseValueSymbol),
                      [onResolve, deferred],
@@ skipping 11 matching lines @@
       break;
   }
   // Mark this promise as having handler.
   SET_PRIVATE(this, promiseHasHandlerSymbol, true);
   if (DEBUG_IS_ACTIVE) {
     %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
   }
   return deferred.promise;
 }
 
+function PromiseChain(onResolve, onReject) {
+  return %_Call(PromiseChainInternal, this, this.constructor,

[caitp (gmail), 2015/11/09 21:10:24]

I think the goal is to get rid of this, but it's been re-arranged to minimize
the number of `Get(this, "constructor");` loads that occur

+                onResolve, onReject);
+}
+
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
   onResolve = IS_CALLABLE(onResolve) ? onResolve : PromiseIdResolveHandler;
   onReject = IS_CALLABLE(onReject) ? onReject : PromiseIdRejectHandler;
   var that = this;
   var constructor = this.constructor;
   return %_Call(
-    PromiseChain,
+    PromiseChainInternal,
     this,
+    constructor,
     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)) {
         return x.then(onResolve, onReject);
       } else {
         DEBUG_PREPARE_STEP_IN_IF_STEPPING(onResolve);
         return onResolve(x);
       }
     },
     onReject
   );
 }
 
 // Combinators.
 
 function PromiseCast(x) {
   if (IsPromise(x) && x.constructor === this) {
     return x;
   } else {
     return new this(function(resolve) { resolve(x) });
   }
 }
 
 function PromiseAll(iterable) {
-  var deferred = %_Call(PromiseDeferred, this);
+  var deferred = NewPromiseCapability(this);
   var resolutions = [];
   try {
     var count = 0;
     var i = 0;
     for (var value of iterable) {
       var reject = function(r) { deferred.reject(r) };
       this.resolve(value).then(
           // Nested scope to get closure over current i.
           // TODO(arv): Use an inner let binding once available.
           (function(i) {
@@ skipping 11 matching lines @@
       deferred.resolve(resolutions);
     }
 
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 function PromiseRace(iterable) {
-  var deferred = %_Call(PromiseDeferred, this);
+  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)
   }
   return deferred.promise;
@@ skipping 63 matching lines @@
 // This allows extras to create promises quickly without building extra
 // resolve/reject closures, and allows them to later resolve and reject any
 // promise without having to hold on to those closures forever.
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
   "resolvePromise", PromiseResolve,
   "rejectPromise", PromiseReject
 ]);
 
 })