WIP [esnext] implement async iteration proposal

src/builtins/builtins-promise.h

 // 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/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
 
 typedef compiler::Node Node;
 typedef CodeStubAssembler::ParameterMode ParameterMode;
 typedef compiler::CodeAssemblerState CodeAssemblerState;
 
 class PromiseBuiltinsAssembler : public CodeStubAssembler {
  public:
   explicit PromiseBuiltinsAssembler(CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
   // These allocate and initialize a promise with pending state and
   // undefined fields.
   //
   // This uses undefined as the parent promise for the promise init
   // hook.
   Node* AllocateAndInitJSPromise(Node* context);
   // This uses the given parent as the parent promise for the promise
   // init hook.
   Node* AllocateAndInitJSPromise(Node* context, Node* parent);
 
+  // Allocate and initialize a Promise with pending state and undefined fields,
+  // without invoking Promise Hooks. This is suitable for internal Promises
+  // not exposed to JS code.
+  Node* AllocateAndInitInternalJSPromise(Node* context);
+
   // This allocates and initializes a promise with the given state and
   // fields.
   Node* AllocateAndSetJSPromise(Node* context, Node* status, Node* result);
 
   Node* AllocatePromiseResolveThenableJobInfo(Node* result, Node* then,
                                               Node* resolve, Node* reject,
                                               Node* context);
 
   Node* ThrowIfNotJSReceiver(Node* context, Node* value,
                              MessageTemplate::Template msg_template,
@@ skipping 11 matching lines @@
 
   Node* InternalPromiseThen(Node* context, Node* promise, Node* on_resolve,
                             Node* on_reject);
 
   Node* InternalPerformPromiseThen(Node* context, Node* promise,
                                    Node* on_resolve, Node* on_reject,
                                    Node* deferred_promise,
                                    Node* deferred_on_resolve,
                                    Node* deferred_on_reject);
 
+  void FastPerformPromiseThen(Node* context, Node* promise,
+                              Node* on_resolve = nullptr,
+                              Node* on_reject = nullptr,
+                              Node* result_promise = nullptr);
+
   void InternalResolvePromise(Node* context, Node* promise, Node* result);
 
   void BranchIfFastPath(Node* context, Node* promise, Label* if_isunmodified,
                         Label* if_ismodified);
 
   void BranchIfFastPath(Node* native_context, Node* promise_fun, Node* promise,
                         Label* if_isunmodified, Label* if_ismodified);
 
   Node* CreatePromiseContext(Node* native_context, int slots);
   Node* CreatePromiseResolvingFunctionsContext(Node* promise, Node* debug_event,
@@ skipping 13 matching lines @@
 
  protected:
   void PromiseInit(Node* promise);
 
  private:
   Node* AllocateJSPromise(Node* context);
 };
 
 }  // namespace internal
 }  // namespace v8