WIP [esnext] implement async iteration proposal

src/builtins/builtins-async.h

Index: src/builtins/builtins-async.h
diff --git a/src/builtins/builtins-async.h b/src/builtins/builtins-async.h
new file mode 100644
index 0000000000000000000000000000000000000000..56a438fa04d24cb6daabf7d72e04a32872767b24
--- /dev/null
+++ b/src/builtins/builtins-async.h
@@ -0,0 +1,67 @@
+// 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.
+
+#include "src/builtins/builtins-promise.h"
+
+namespace v8 {
+namespace internal {
+
+class AsyncBuiltinsAssembler : public PromiseBuiltinsAssembler {

[Dan Ehrenberg, 2017/01/13 19:41:09]

I'm a little surprised by this inheritance, and don't see other similar
examples, but I don't see anything else that is trying to compose code like
this. Stupid suggestion: private inheritance?

[caitp, 2017/01/13 20:11:52]

Would that make CSA methods private, or just PromiseBuiltinsAssembler methods?

[caitp, 2017/01/17 19:23:11]

This causes problems for the TF_BUILTIN pattern, it would need to be `protected
PromiseBuiltinAssembler` --- but I don't think doing this helps with anything

+ public:
+  explicit AsyncBuiltinsAssembler(CodeAssemblerState* state)
+      : PromiseBuiltinsAssembler(state) {}
+
+  // Async Generator:
+  void AsyncGeneratorResumeNext(Node* context, Node* generator,
+                                Node* continuation);
+  void AsyncGeneratorResumeNext(Node* context, Node* generator) {
+    Node* continuation =
+        LoadObjectField(generator, JSAsyncGeneratorObject::kContinuationOffset);
+    AsyncGeneratorResumeNext(context, generator, continuation);
+  }
+
+  Node* TakeFirstAsyncGeneratorRequestFromQueue(Node* generator);
+  void AddAsyncGeneratorRequestToQueue(Node* generator, Node* request);
+
+  Node* AllocateAsyncGeneratorRequest(
+      JSAsyncGeneratorObject::ResumeMode resume_mode, Node* resume_value,
+      Node* promise);
+
+  // Async Iterator
+  Node* AllocateAsyncIteratorValueUnwrapContext(Node* native_context,
+                                                Node* promise, Node* done);
+
+ protected:
+  // Async Generator shared
+  void AsyncGeneratorEnqueue(Node* context, Node* generator, Node* value,
+                             JSAsyncGeneratorObject::ResumeMode resume_mode,
+                             const char* method_name);
+
+  void AsyncGeneratorAwaitResumeClosure(
+      Node* context, Node* value,
+      JSAsyncGeneratorObject::ResumeMode resume_mode);
+
+  typedef std::function<Node*(Node*)> NodeGenerator1;
+
+  // Perform steps to resume generator after `value` is resolved.
+  // `on_reject_context_index` is an index into the Native Context, which should
+  // point to a SharedFunctioninfo instance used to create the closure. The
+  // value following the reject index should be a similar value for the resolve
+  // closure. Returns the Promise-wrapped `value`.
+  Node* Await(Node* context, Node* generator, Node* value, Node* outer_promise,
+              const NodeGenerator1& create_closure_context,
+              int on_reject_context_index, bool is_catchable);
+
+  // Shared implementation of the catchable and uncatchable variations of Await
+  // for AsyncGenerators.
+  void AsyncGeneratorAwait(bool is_catchable);
+
+ private:
+  // Async Generator private
+  void AsyncGeneratorResumeNextStep(Node* context, Node* generator, Node* req,
+                                    Node* continuation, Label* exit_loop);
+};
+
+}  // namespace internal
+}  // namespace v8