[async-await] Don't create resolving callbacks for throwaway promises

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 114 matching lines @@
     if (debug_is_active) %DebugPushPromise(deferred.promise);
     var result = handler(value);
     if (IS_UNDEFINED(deferred.resolve)) {
       ResolvePromise(deferred.promise, result);
     } else {
       %_Call(deferred.resolve, UNDEFINED, result);
     }
   } %catch (exception) {  // Natives syntax to mark this catch block.
     try {
       if (IS_UNDEFINED(deferred.reject)) {
         // Pass false for debugEvent so .then chaining does not trigger

[Dan Ehrenberg, 2016/11/18 12:54:52]

Note: this undefined case also includes async/await. False is appropriate for
the same reason, but maybe the comment should be updated.

[gsathya, 2016/11/18 15:39:48]

Done.

         // redundant ExceptionEvents.
         %PromiseReject(deferred.promise, exception, false);
         PromiseSet(deferred.promise, kRejected, exception);
       } else {
         %_Call(deferred.reject, UNDEFINED, exception);
       }
     } catch (e) { }
   } finally {
     if (debug_is_active) %DebugPopPromise();
   }
@@ skipping 138 matching lines @@
   %PromiseReject(promise, reason, debugEvent);
   PromiseSet(promise, kRejected, reason);
 }
 
 // Export to bindings
 function DoRejectPromise(promise, reason) {
   %PromiseReject(promise, reason, true);
   PromiseSet(promise, kRejected, reason);
 }
 
+// The resultCapability.promise is only ever fulfilled internally,
+// so we don't need the closures to protect against accidentally
+// calling them multiple times.
+function NewPromiseCapabilityWithoutCallbacks() {

[Dan Ehrenberg, 2016/11/18 12:54:52]

Name suggestion: CreatePromiseCapability

[gsathya, 2016/11/18 15:39:48]

Doesn't seem to convey the difference between NewPromiseCapability and this. I'd
rather leave it as such as it's descriptive.

[caitp, 2016/11/18 15:42:28]

"CreateInternalPromiseCapability"?

+  return {
+    promise: PromiseCreate(),
+    resolve: UNDEFINED,
+    reject: UNDEFINED
+  };
+}
+
 // ES#sec-newpromisecapability
 // NewPromiseCapability ( C )
 function NewPromiseCapability(C, debugEvent) {
   if (C === GlobalPromise) {
     // Optimized case, avoid extra closure.
     var promise = PromiseCreate();
     // TODO(gsathya): Remove container for callbacks when this is
     // moved to CPP/TF.
     var callbacks = %create_resolving_functions(promise, debugEvent);
     return {
@@ skipping 70 matching lines @@
 // 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);
   var resultCapability;
-
-  // The resultCapability.promise is only ever fulfilled internally,
-  // so we don't need the closures to protect against accidentally
-  // calling them multiple times.
   if (constructor === GlobalPromise) {
-    // TODO(gsathya): Combine this into NewPromiseCapability.
-    resultCapability = {
-      promise: PromiseCreate(),
-      resolve: UNDEFINED,
-      reject: UNDEFINED
-    };
+    resultCapability = NewPromiseCapabilityWithoutCallbacks();
   } else {
     // Pass false for debugEvent so .then chaining does not trigger
     // redundant ExceptionEvents.
     resultCapability = NewPromiseCapability(constructor, false);
   }
+

[Dan Ehrenberg, 2016/11/18 12:54:52]

Nit: consider reverting the irrelevant whitespace change

[gsathya, 2016/11/18 15:39:48]

Done.

   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 224 matching lines @@
   "resolvePromise", ResolvePromise,
   "rejectPromise", DoRejectPromise
 ]);
 
 utils.Export(function(to) {
   to.IsPromise = IsPromise;
   to.PromiseCreate = PromiseCreate;
   to.PromiseThen = PromiseThen;
 
   to.GlobalPromise = GlobalPromise;
-  to.NewPromiseCapability = NewPromiseCapability;
+  to.NewPromiseCapabilityWithoutCallbacks =
+      NewPromiseCapabilityWithoutCallbacks;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })