[esnext] prototype runtime implementation for async functions

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 275 matching lines @@
     // which is usually simply noise. Do not trigger that debug event.
     %PromiseRejectEvent(promise, r, false);
     return promise;
   } else {
     var promiseCapability = NewPromiseCapability(this);
     %_Call(promiseCapability.reject, UNDEFINED, r);
     return promiseCapability.promise;
   }
 }
 
+// Shortcut Promise.reject and Promise.resolve() implementations, used by
+// Async Functions implementation.
+function PromiseCreateRejected(r) {
+  var promise = PromiseCreateAndSet(-1, r);
+  %PromiseRejectEvent(promise, r, false);
+  return promise;
+}
+
+function PromiseCreateResolved(x) {
+  if (IsPromise(x) && x.constructor === GlobalPromise) return x;
+  return PromiseCreateAndSet(+1, x);
+}

[Dan Ehrenberg, 2016/05/04 22:52:36]

This seems like a good optimization. Maybe in a separate patch, we could
refactor PromiseResolve and PromiseReject to use them if this === GlobalPromise.
That would make me a bit more comfortable with respect to testing, since there
are already a bunch of tests for those directly, both in mjsunit and test262.
Another alternative to the same end would be to just put PromiseResolve and
PromiseReject on the context (renaming the RejectPromise/FuifillPromise entries
appropriately) and call out to those directly. Either way, the testing surface
is reduced. Normally I wouldn't be so picky, but we had so many bugs with
Promise correctness.

+
 // 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 MakeTypeError(kNotAPromise, this);
   }
 
   var constructor = SpeciesConstructor(this, GlobalPromise);
@@ skipping 174 matching lines @@
 ]);
 
 %InstallToContext([
   "promise_catch", PromiseCatch,
   "promise_chain", PromiseChain,
   "promise_create", PromiseCreate,
   "promise_has_user_defined_reject_handler", PromiseHasUserDefinedRejectHandler,
   "promise_reject", RejectPromise,
   "promise_resolve", FulfillPromise,
   "promise_then", PromiseThen,
+  "promise_create_rejected", PromiseCreateRejected,
+  "promise_create_resolved", PromiseCreateResolved
 ]);
 
 // This allows extras to create promises quickly without building extra
 // resolve/reject closures, and allows them to later resolve and reject any
 // promise without having to hold on to those closures forever.
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
   "resolvePromise", FulfillPromise,
   "rejectPromise", RejectPromise
 ]);
 
 // TODO(v8:4567): Allow experimental natives to remove function prototype
 [PromiseChain, PromiseDefer, PromiseAccept].forEach(
     fn => %FunctionRemovePrototype(fn));
 
 utils.Export(function(to) {
   to.PromiseChain = PromiseChain;
   to.PromiseDefer = PromiseDefer;
   to.PromiseAccept = PromiseAccept;
+
+  to.PromiseCreateRejected = PromiseCreateRejected;
+  to.PromiseCreateResolved = PromiseCreateResolved;
+  to.PromiseThen = PromiseThen;
 });
 
 })