[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); }

[adamk, 2016/10/05 22:12:00]

And an explicit IS_UNDEFINED() check for these, just to make the boolean stuff
more explicit.

[gsathya, 2016/10/05 22:47:40]

Done.

+    else { ResolvePromise(deferred.promise, result); }

[adamk, 2016/10/05 22:12:00]

Please reformat this and the below into the usual

if {
} else {
}

style

[gsathya, 2016/10/05 22:47:40]

Done.

   } %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); }

[adamk, 2016/10/05 22:12:00]

This needs a comment for why false is the third argument; maybe just a copy of
the comment in PromiseThen.

[gsathya, 2016/10/05 22:47:40]

Done.

+    } 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 260 matching lines @@
 // ES#sec-promise.prototype.then
 // Promise.prototype.then ( onFulfilled, onRejected )
 // Multi-unwrapped chaining with thenable coercion.
 function PromiseThen(onResolve, onReject) {
   var status = GET_PRIVATE(this, promiseStateSymbol);
   if (IS_UNDEFINED(status)) {
     throw %make_type_error(kNotAPromise, this);
   }
 
   var constructor = SpeciesConstructor(this, GlobalPromise);
-  // Pass false for debugEvent so .then chaining does not trigger
-  // redundant ExceptionEvents.
-  var resultCapability = NewPromiseCapability(constructor, false);
+  var resultCapability;
+  if (constructor === GlobalPromise) {
+    resultCapability = {

[adamk, 2016/10/05 22:12:00]

Please add a comment here explaining this special case.

[gsathya, 2016/10/05 22:47:40]

Done.

+      promise: PromiseCreate(),
+      resolve: false,
+      reject: false

[adamk, 2016/10/05 22:12:00]

How about UNDEFINED for these falses...

[gsathya, 2016/10/05 22:47:40]

Done.

+    };
+  } else {
+    // Pass false for debugEvent so .then chaining does not trigger
+    // redundant ExceptionEvents.
+    resultCapability = NewPromiseCapability(constructor, false);
+  }
   return PerformPromiseThen(this, onResolve, onReject, resultCapability);
 }
 
 // ES#sec-promise.prototype.catch
 // Promise.prototype.catch ( onRejected )
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Combinators.
@@ skipping 228 matching lines @@
   to.PromiseNextMicrotaskID = PromiseNextMicrotaskID;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })