[promises] dont create resolving closures in PromiseThen

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 151 matching lines @@
     }
     PromiseSet(promise, status, value);
   }
 }
 
 function PromiseHandle(value, handler, deferred) {
   var debug_is_active = DEBUG_IS_ACTIVE;
   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();
   }
 }
 
 function PromiseEnqueue(value, tasks, deferreds, status) {
   var id, name, instrumenting = DEBUG_IS_ACTIVE;
   %EnqueueMicrotask(function() {
     if (instrumenting) {
       %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
@@ skipping 177 matching lines @@
 
 // Export to bindings
 function DoRejectPromise(promise, reason) {
   return RejectPromise(promise, reason, true);
 }
 
 // ES#sec-newpromisecapability
 // 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,
     };
   }
 
   var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
   result.promise = new C((resolve, reject) => {
     if (!IS_UNDEFINED(result.resolve) || !IS_UNDEFINED(result.reject))
         throw %make_type_error(kPromiseExecutorAlreadyInvoked);
     result.resolve = resolve;
     result.reject = reject;
   });
@@ skipping 78 matching lines @@
 // Combinators.
 
 // ES#sec-promise.resolve
 // Promise.resolve ( x )
 function PromiseResolve(x) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, PromiseResolve);
   }
   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;
 }
 
 // ES#sec-promise.all
 // Promise.all ( iterable )
 function PromiseAll(iterable) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, "Promise.all");
   }
 
   // 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;
 
   // For catch prediction, don't treat the .then calls as handling it;
   // instead, recurse outwards.
   var instrumenting = DEBUG_IS_ACTIVE;
   if (instrumenting) {
     SET_PRIVATE(deferred.reject, promiseForwardingHandlerSymbol, true);
   }
 
   function CreateResolveElementFunction(index, values, promiseCapability) {
     var alreadyCalled = false;
-    return (x) => {
+    return function(x) {
       if (alreadyCalled === true) return;
       alreadyCalled = true;
       values[index] = x;
       if (--count === 0) {
         var valuesArray = [];
         %MoveArrayContents(values, valuesArray);
         %_Call(promiseCapability.resolve, UNDEFINED, valuesArray);
       }
     };
   }
@@ skipping 31 matching lines @@
 // ES#sec-promise.race
 // Promise.race ( iterable )
 function PromiseRace(iterable) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, PromiseRace);
   }
 
   // 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.
   var instrumenting = DEBUG_IS_ACTIVE;
   if (instrumenting) {
     SET_PRIVATE(deferred.reject, promiseForwardingHandlerSymbol, true);
   }
 
   try {
     for (var value of iterable) {
@@ skipping 122 matching lines @@
   to.PromiseNextMicrotaskID = PromiseNextMicrotaskID;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })