[promise] Make Promise.all match spec, and always respect [[AlreadyResolved]]

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 51 matching lines @@
 
 var GlobalPromise = function Promise(resolver) {
   if (resolver === promiseRawSymbol) {
     return %NewObject(GlobalPromise, new.target);
   }
   if (IS_UNDEFINED(new.target)) throw MakeTypeError(kNotAPromise, this);
   if (!IS_CALLABLE(resolver))
     throw MakeTypeError(kResolverNotAFunction, resolver);
 
   var promise = PromiseInit(%NewObject(GlobalPromise, new.target));
+  var callbacks = CreateResolvingFunctions(promise);
 
   try {
     %DebugPushPromise(promise, Promise);
-    var callbacks = CreateResolvingFunctions(promise);
     resolver(callbacks.resolve, callbacks.reject);
   } catch (e) {
-    PromiseReject(promise, e);
+    callbacks.reject(e);

[Dan Ehrenberg, 2016/01/04 02:49:15]

I think this needs to be %_Call(callbacks.reject, UNDEFINED, e)

   } finally {
     %DebugPopPromise();
   }
 
   return promise;
 }
 
 // Core functionality.
 
 function PromiseSet(promise, status, value, onResolve, onReject) {
@@ skipping 108 matching lines @@
     if (IS_RECEIVER(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() {
+          var callbacks = CreateResolvingFunctions(promise);
           try {
-            var callbacks = CreateResolvingFunctions(promise);
             %_Call(then, x, callbacks.resolve, callbacks.reject);
           } catch (e) {
-            PromiseReject(promise, e);
+            callbacks.reject(promise, e);

[Dan Ehrenberg, 2016/01/04 02:49:15]

Here too

           }
         });
       }
     }
     PromiseDone(promise, +1, x, promiseOnResolveSymbol);
   }
 }
 
 function PromiseReject(promise, r) {
   // Check promise status to confirm that this reject has an effect.
@@ skipping 133 matching lines @@
 
 function PromiseCast(x) {
   if (IsPromise(x) && x.constructor === this) {
     return x;
   } else {
     return new this(function(resolve) { resolve(x) });
   }
 }
 
 function PromiseAll(iterable) {
+  if (!IS_RECEIVER(this)) {
+    throw MakeTypeError(kCalledOnNonObject, "Promise.all");
+  }
+
   var deferred = NewPromiseCapability(this);
   var resolutions = [];
   try {
-    var count = 0;
+    var count = 1;
     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) {
-            return function(x) {
-              resolutions[i] = x;
-              if (--count === 0) deferred.resolve(resolutions);
-            }
-          })(i), reject);
-      SET_PRIVATE(reject, promiseCombinedDeferredSymbol, deferred);
+      resolutions[i] = UNDEFINED;
+      var nextPromise = this.resolve(value);
+      ++count;
+      nextPromise.then(
+          CreateResolveElementFunction(i, resolutions, deferred),
+          deferred.reject);
+      SET_PRIVATE(deferred.reject, promiseCombinedDeferredSymbol, deferred);
       ++i;
-      ++count;
     }
 
-    if (count === 0) {
+    // 6.d
+    if (--count === 0) {
       deferred.resolve(resolutions);
     }
 
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
+
+  function CreateResolveElementFunction(index, values, promiseCapability) {
+    var alreadyCalled = false;
+    return function(x) {
+      if (alreadyCalled === true) return;
+      alreadyCalled = true;
+      values[index] = x;
+      if (--count === 0) promiseCapability.resolve(values);
+    };
+  }
 }
 
 function PromiseRace(iterable) {
   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);
     }
@@ skipping 74 matching lines @@
 [PromiseChain, PromiseDeferred, PromiseResolved].forEach(
     fn => %FunctionRemovePrototype(fn));
 
 utils.Export(function(to) {
   to.PromiseChain = PromiseChain;
   to.PromiseDeferred = PromiseDeferred;
   to.PromiseResolved = PromiseResolved;
 });
 
 })