[esnext] prototype runtime implementation for async functions

src/js/harmony-async-await.js

Index: src/js/harmony-async-await.js
diff --git a/src/js/harmony-async-await.js b/src/js/harmony-async-await.js
new file mode 100644
index 0000000000000000000000000000000000000000..1a7910ff4951729eff6ca8d93f59619ff1c7047b
--- /dev/null
+++ b/src/js/harmony-async-await.js
@@ -0,0 +1,37 @@
+// 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;
+
+utils.Import(function(from) {
+  AsyncFunctionNext = from.AsyncFunctionNext;
+  AsyncFunctionThrow = from.AsyncFunctionThrow;
+  PromiseReject = from.PromiseCreateRejected;
+  PromiseResolve = from.PromiseCreateResolved;
+  PromiseThen = from.PromiseThen;
+});
+
+function AsyncFunctionAwait(generator, value) {

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

I like this way of defining the function. We may want to optimize the closures
later, but it seems like a good way to start.

If we have to worry about AsyncFunctionNext/Throw showing up on the stack, then
maybe we also have to worry about these anonymous functions here also showing
up. However, I'm not sure we do have to worry about any of that, because
shouldn't both this and AsyncFunctionNext/Throw only be on the stack just before
resuming? I can't understand when you'd ever observe it.

Nit: Avoid confusingly reusing/shadowing `value`.

+  return %_Call(
+      PromiseThen, PromiseResolve(value),
+      function(value) { return %_Call(AsyncFunctionNext, generator, value); },
+      function(error) { return %_Call(AsyncFunctionThrow, generator, error); });
+}
+
+%InstallToContext([ "async_function_await", AsyncFunctionAwait ]);
+
+})