[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();
 
 // -------------------------------------------------------------------
 // Imports
 
 var InternalArray = utils.InternalArray;
 var MakeTypeError;
 var promiseCombinedDeferredSymbol =
     utils.ImportNow("promise_combined_deferred_symbol");
 var promiseHasHandlerSymbol =
     utils.ImportNow("promise_has_handler_symbol");
 var promiseOnRejectSymbol = utils.ImportNow("promise_on_reject_symbol");
 var promiseOnResolveSymbol =
     utils.ImportNow("promise_on_resolve_symbol");
 var promiseRawSymbol = utils.ImportNow("promise_raw_symbol");
 var promiseStatusSymbol = utils.ImportNow("promise_status_symbol");
 var promiseValueSymbol = utils.ImportNow("promise_value_symbol");
 var SpeciesConstructor;
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
-
+var AsyncFunctionNext;
+var AsyncFunctionThrow;
 utils.Import(function(from) {
   MakeTypeError = from.MakeTypeError;
   SpeciesConstructor = from.SpeciesConstructor;
+  AsyncFunctionNext = from.AsyncFunctionNext;
+  AsyncFunctionThrow = from.AsyncFunctionThrow;
 });
 
 // -------------------------------------------------------------------
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
 var lastMicrotaskId = 0;
 
 function CreateResolvingFunctions(promise) {
   var alreadyResolved = false;
 
@@ skipping 219 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);
+}
+
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
   var status = GET_PRIVATE(this, promiseStatusSymbol);
   if (IS_UNDEFINED(status)) {
     throw MakeTypeError(kNotAPromise, this);
   }
 
   var constructor = SpeciesConstructor(this, GlobalPromise);
   onResolve = IS_CALLABLE(onResolve) ? onResolve : PromiseIdResolveHandler;
@@ skipping 136 matching lines @@
   return false;
 }
 
 // Return whether the promise will be handled by a user-defined reject
 // handler somewhere down the promise chain. For this, we do a depth-first
 // search for a reject handler that's not the default PromiseIdRejectHandler.
 function PromiseHasUserDefinedRejectHandler() {
   return PromiseHasUserDefinedRejectHandlerRecursive(this);
 };
 
+// TODO(caitp): move me to a new file =)
+function AsyncFunctionResume(generator, sentValue, resumeFunc) {
+  try {
+    var result = resumeFunc(generator, sentValue);
+    if (result.done) return PromiseCreateResolved(result.value);
+  } catch (error) {
+    return PromiseCreateRejected(error);
+  }
+
+  %GlobalPrint("await...\n");
+  return %_Call(PromiseThen, PromiseCreateResolved(result.value),
+      function(value) { %GlobalPrint("resume normal...\n"); return AsyncFunctionResume(generator, value, AsyncFunctionNext); },

[caitp (gmail), 2016/04/16 18:33:03]

phantom edits from some debugging =)

+      function(error) { %GlobalPrint("resume throw...\n"); return AsyncFunctionResume(generator, error, AsyncFunctionThrow); });
+}
+
+function AsyncFunctionStart(generator) {
+  return AsyncFunctionResume(generator, UNDEFINED, AsyncFunctionNext);
+}
+
 // -------------------------------------------------------------------
 // Install exported functions.
 
 %AddNamedProperty(global, 'Promise', GlobalPromise, DONT_ENUM);
 %AddNamedProperty(GlobalPromise.prototype, toStringTagSymbol, "Promise",
                   DONT_ENUM | READ_ONLY);
 
 utils.InstallFunctions(GlobalPromise, DONT_ENUM, [
   "reject", PromiseRejected,
   "all", PromiseAll,
   "race", PromiseRace,
   "resolve", PromiseCast
 ]);
 
 utils.InstallFunctions(GlobalPromise.prototype, DONT_ENUM, [
   "then", PromiseThen,
   "catch", PromiseCatch
 ]);
 
 %InstallToContext([
   "promise_catch", PromiseCatch,
   "promise_chain", PromiseChain,
   "promise_create", PromiseCreate,
   "promise_has_user_defined_reject_handler", PromiseHasUserDefinedRejectHandler,
   "promise_reject", PromiseReject,
   "promise_resolve", PromiseResolve,
   "promise_then", PromiseThen,
+  "promise_create_rejected", PromiseCreateRejected,
+  "promise_create_resolved", PromiseCreateResolved,
+  "async_function_start", AsyncFunctionStart
 ]);
 
 // 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", PromiseResolve,
   "rejectPromise", PromiseReject
 ]);
 
 // TODO(v8:4567): Allow experimental natives to remove function prototype
 [PromiseChain, PromiseDeferred, PromiseResolved].forEach(
     fn => %FunctionRemovePrototype(fn));
 
 utils.Export(function(to) {
   to.PromiseChain = PromiseChain;
   to.PromiseDeferred = PromiseDeferred;
   to.PromiseResolved = PromiseResolved;
 });
 
 })