[promise] separate PerformPromiseThen from PromiseThen

src/js/harmony-async-await.js

 // Copyright 2016 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();
 
 // -------------------------------------------------------------------
 // Imports
 
 var AsyncFunctionNext;
 var AsyncFunctionThrow;
-var PromiseReject;
-var PromiseResolve;
-var PromiseThen;
+var GlobalPromise;
+var NewPromiseCapability;
+var PerformPromiseThen;
 
 utils.Import(function(from) {
   AsyncFunctionNext = from.AsyncFunctionNext;
   AsyncFunctionThrow = from.AsyncFunctionThrow;
-  PromiseReject = from.PromiseCreateRejected;
-  PromiseResolve = from.PromiseCreateResolved;
-  PromiseThen = from.PromiseThen;
+  GlobalPromise = from.GlobalPromise;
+  NewPromiseCapability = from.NewPromiseCapability;
+  PerformPromiseThen = from.PerformPromiseThen;
 });
 
 // -------------------------------------------------------------------
 
 function AsyncFunctionAwait(generator, value) {
-  return %_Call(
-      PromiseThen, PromiseResolve(value),
-      function(sentValue) {
-        return %_Call(AsyncFunctionNext, generator, sentValue);
-      },
-      function(sentError) {
-        return %_Call(AsyncFunctionThrow, generator, sentError);
-      });
+  // Promise.resolve(value).then(
+  //     value => AsyncFunctionNext(value),
+  //     error => AsyncFunctionThrow(error)
+  // );
+  var promiseCapability = NewPromiseCapability(GlobalPromise);
+  var resolveResult = %_Call(promiseCapability.resolve, UNDEFINED, value);
+  var onFulfilled =
+      (sentValue) => %_Call(AsyncFunctionNext, generator, sentValue);
+  var onRejected =
+      (sentError) => %_Call(AsyncFunctionThrow, generator, sentError);
+
+  var throwawayCapability = NewPromiseCapability(GlobalPromise);

[Dan Ehrenberg, 2016/08/02 20:20:56]

I'm a big fan of how this exactly mirrors the spec. Do you have any ideas for
how we may optimize away some of these allocations?

[caitp, 2016/08/02 20:40:20]

I assume that's meant to be "I'm not a big fan of ...", given the question?

Might be able to avoid some stuff for the Promise.resolve(), but the part
emulating Promise.prototype.then() needs all of it, I believe.

[Dan Ehrenberg, 2016/08/02 20:54:45]

Yeah, this does seem tricky. I definitely didn't mean the comment to delay
committing this change; it seems good to me as is.

+  return PerformPromiseThen(promiseCapability.promise, onFulfilled, onRejected,
+                            throwawayCapability);
 }
 
 %InstallToContext([ "async_function_await", AsyncFunctionAwait ]);
 
 })