[promises] dont create resolving closures in PromiseThen

src/js/promise.js

Index: src/js/promise.js
diff --git a/src/js/promise.js b/src/js/promise.js
index 793d60fb0a7fa29f5f828da7dee849d5d42dabb1..0308d379cfb82dcc94bc8ae55f1e989a263d48f6 100644
--- a/src/js/promise.js
+++ b/src/js/promise.js
@@ -169,9 +169,13 @@ function PromiseHandle(value, handler, deferred) {
   try {
     if (debug_is_active) %DebugPushPromise(deferred.promise);
     var result = handler(value);
-    deferred.resolve(result);
+    if (deferred.resolve) { deferred.resolve(result); }
+    else { ResolvePromise(deferred.promise, result); }
   } %catch (exception) {  // Natives syntax to mark this catch block.
-    try { deferred.reject(exception); } catch (e) { }
+    try {
+      if (deferred.reject) { deferred.reject(exception); }
+      else { RejectPromise(deferred.promise, exception, false); }
+    } catch (e) { }
   } finally {
     if (debug_is_active) %DebugPopPromise();
   }
@@ -369,13 +373,10 @@ function DoRejectPromise(promise, reason) {
 // NewPromiseCapability ( C )
 function NewPromiseCapability(C, debugEvent) {
   if (C === GlobalPromise) {
-    // Optimized case, avoid extra closure.
-    var promise = PromiseCreate();
-    var callbacks = CreateResolvingFunctions(promise, debugEvent);
     return {
-      promise: promise,
-      resolve: callbacks.resolve,
-      reject: callbacks.reject
+      promise: PromiseCreate(),
+      resolve: false,
+      reject: false,
     };
   }
 
@@ -474,16 +475,15 @@ function PromiseResolve(x) {
   }
   if (IsPromise(x) && x.constructor === this) return x;
 
-  // Avoid creating resolving functions.
+  // debugEvent is not so meaningful here as it will be resolved
+  var promiseCapability = NewPromiseCapability(this, true);
+
   if (this === GlobalPromise) {
-    var promise = PromiseCreate();
-    var resolveResult = ResolvePromise(promise, x);
-    return promise;
+    ResolvePromise(promiseCapability.promise, x);
+  } else {
+    %_Call(promiseCapability.resolve, UNDEFINED, x);
   }
 
-  // debugEvent is not so meaningful here as it will be resolved
-  var promiseCapability = NewPromiseCapability(this, true);
-  var resolveResult = %_Call(promiseCapability.resolve, UNDEFINED, x);
   return promiseCapability.promise;
 }
 
@@ -497,6 +497,11 @@ function PromiseAll(iterable) {
   // false debugEvent so that forwarding the rejection through all does not
   // trigger redundant ExceptionEvents
   var deferred = NewPromiseCapability(this, false);
+  if (this === GlobalPromise) {
+    var callbacks = CreateResolvingFunctions(deferred.promise, false);
+    deferred.resolve = callbacks.resolve;
+    deferred.reject = callbacks.reject;
+  }
   var resolutions = new InternalArray();
   var count;
 
@@ -509,7 +514,7 @@ function PromiseAll(iterable) {
 
   function CreateResolveElementFunction(index, values, promiseCapability) {
     var alreadyCalled = false;
-    return (x) => {
+    return function(x) {
       if (alreadyCalled === true) return;
       alreadyCalled = true;
       values[index] = x;
@@ -561,6 +566,11 @@ function PromiseRace(iterable) {
   // false debugEvent so that forwarding the rejection through race does not
   // trigger redundant ExceptionEvents
   var deferred = NewPromiseCapability(this, false);
+  if (this === GlobalPromise) {
+    var callbacks = CreateResolvingFunctions(deferred.promise, false);

[adamk, 2016/10/05 20:18:09]

Ah, I didn't realize some callers need the callbacks. If that's the case then I
agree this is worse.

+    deferred.resolve = callbacks.resolve;
+    deferred.reject = callbacks.reject;
+  }
 
   // For catch prediction, don't treat the .then calls as handling it;
   // instead, recurse outwards.