WIP [esnext] implement async iteration proposal

src/builtins/builtins-promise.cc

 // 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"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
@@ skipping 33 matching lines @@
 
   Label out(this);
   GotoUnless(IsPromiseHookEnabled(), &out);
   CallRuntime(Runtime::kPromiseHookInit, context, instance, parent);
   Goto(&out);
 
   Bind(&out);
   return instance;
 }
 
+Node* PromiseBuiltinsAssembler::AllocateAndInitInternalJSPromise(
+    Node* context) {

[caitp, 2017/01/10 04:19:33]

This seemed more useful earlier today, but after discussion with Domenic about
fixing async-from-sync Iterator, it's probably safe to get rid of it.

The main idea was to not report Promise Hook events for an intermediate Promise
allocated by Async-from-Sync iterator methods, which makes sense to me.

Sathya wdyt?

[gsathya, 2017/01/10 17:47:24]

The Async-from-Sync iterator methods seems to use NewPromiseCapability so we
should fire the hooks. The hooks are expected to fire for all promises including
intermediate promises. We  do the same for async-await.

[caitp, 2017/01/10 17:48:54]

sgtm

+  Node* const instance = AllocateJSPromise(context);
+  PromiseInit(instance);
+  return instance;
+}
+
 Node* PromiseBuiltinsAssembler::AllocateAndSetJSPromise(Node* context,
                                                         Node* status,
                                                         Node* result) {
   CSA_ASSERT(this, TaggedIsSmi(status));
 
   Node* const instance = AllocateJSPromise(context);
 
   StoreObjectFieldNoWriteBarrier(instance, JSPromise::kStatusOffset, status);
   StoreObjectFieldNoWriteBarrier(instance, JSPromise::kResultOffset, result);
   StoreObjectFieldNoWriteBarrier(instance, JSPromise::kFlagsOffset,
@@ skipping 534 matching lines @@
         }
       }
     }
   }
 
   Bind(&out);
   PromiseSetHasHandler(promise);
   return deferred_promise;
 }
 
+void PromiseBuiltinsAssembler::FastPerformPromiseThen(Node* context,
+                                                      Node* promise,
+                                                      Node* on_resolve,
+                                                      Node* on_reject,
+                                                      Node* result_promise) {
+  CSA_SLOW_ASSERT(this, HasInstanceType(promise, JS_PROMISE_TYPE));

[caitp, 2017/01/10 04:13:41]

Basically just a slightly smaller version of InternalPerformPromiseThen(), with
assertions about being an internal Promise. Downside of code duplication might
not be worth my expected code size reduction

+  if (result_promise != nullptr) {
+    CSA_SLOW_ASSERT(this, HasInstanceType(result_promise, JS_PROMISE_TYPE));
+  }
+
+  if (on_resolve == nullptr) {
+    on_resolve = LoadContextElement(LoadNativeContext(context),
+                                    Context::PROMISE_ID_RESOLVE_HANDLER_INDEX);
+  } else if (on_reject == nullptr) {
+    on_reject = LoadContextElement(LoadNativeContext(context),
+                                   Context::PROMISE_ID_REJECT_HANDLER_INDEX);
+  }
+  CSA_SLOW_ASSERT(this, IsJSFunction(on_resolve));
+  CSA_SLOW_ASSERT(this, IsJSFunction(on_reject));
+
+  Label if_ispending(this), if_isfulfilled(this), merge(this);
+
+  Node* const status = LoadObjectField(promise, JSPromise::kStatusOffset);
+  Branch(SmiEqual(status, SmiConstant(v8::Promise::kPending)), &if_ispending,
+         &if_isfulfilled);
+
+  Bind(&if_ispending);
+  {
+    // Assert: There are no callbacks attached.
+    CSA_SLOW_ASSERT(this, IsUndefined(LoadObjectField(
+                              promise, JSPromise::kDeferredPromiseOffset)));
+
+    // Store callbacks directly in the slots.
+    StoreObjectField(promise, JSPromise::kDeferredPromiseOffset,
+                     result_promise ? result_promise : UndefinedConstant());
+    StoreObjectField(promise, JSPromise::kFulfillReactionsOffset, on_resolve);
+    StoreObjectField(promise, JSPromise::kRejectReactionsOffset, on_reject);
+    Goto(&merge);
+  }
+
+  Bind(&if_isfulfilled);
+  {
+    Node* const handler =
+        Select(SmiEqual(status, SmiConstant(v8::Promise::kFulfilled)),
+               [&]() -> Node* { return on_resolve; },
+               [&]() -> Node* {
+                 Label done(this);
+                 GotoIf(PromiseHasHandler(promise), &done);
+                 // TODO(gsathya): Fold these runtime calls and move to TF.
+                 CallRuntime(Runtime::kPromiseRevokeReject, context, promise);
+                 Goto(&done);
+                 Bind(&done);
+                 return on_reject;
+               },
+               MachineRepresentation::kTagged);
+
+    Node* const result = LoadObjectField(promise, JSPromise::kResultOffset);
+    Node* info = AllocatePromiseReactionJobInfo(
+        promise, result, handler,
+        result_promise ? result_promise : UndefinedConstant(),
+        UndefinedConstant(), UndefinedConstant(), context);
+    // TODO(gsathya): Move this to TF
+    CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info, status);
+    Goto(&merge);
+  }
+
+  Bind(&merge);
+}
+
 // Promise fast path implementations rely on unmodified JSPromise instances.
 // We use a fairly coarse granularity for this and simply check whether both
 // the promise itself is unmodified (i.e. its map has not changed) and its
 // prototype is unmodified.
 // TODO(gsathya): Refactor this out to prevent code dupe with builtins-regexp
 void PromiseBuiltinsAssembler::BranchIfFastPath(Node* context, Node* promise,
                                                 Label* if_isunmodified,
                                                 Label* if_ismodified) {
   Node* const native_context = LoadNativeContext(context);
   Node* const promise_fun =
@@ skipping 443 matching lines @@
 }
 
 TF_BUILTIN(PerformPromiseThen, PromiseBuiltinsAssembler) {
   Node* const promise = Parameter(1);
   Node* const on_resolve = Parameter(2);
   Node* const on_reject = Parameter(3);
   Node* const deferred_promise = Parameter(4);
   Node* const context = Parameter(7);
 
   // No deferred_on_resolve/deferred_on_reject because this is just an
-  // internal promise created by async-await.
+  // internal promise created by async-await / async-iteration.
   Node* const result = InternalPerformPromiseThen(
       context, promise, on_resolve, on_reject, deferred_promise,
       UndefinedConstant(), UndefinedConstant());
 
   // TODO(gsathya): This is unused, but value is returned according to spec.
   Return(result);
 }
 
 // ES#sec-promise.prototype.then
 // Promise.prototype.catch ( onFulfilled, onRejected )
@@ skipping 359 matching lines @@
 
     // 5. Return promiseCapability.[[Promise]].
     Node* const promise =
         LoadObjectField(capability, JSPromiseCapability::kPromiseOffset);
     Return(promise);
   }
 }
 
 }  // namespace internal
 }  // namespace v8