WIP [esnext] implement async iteration proposal

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-stubs.h"
@@ skipping 567 matching lines @@
       function_literals_(0, info->zone()),
       native_function_literals_(0, info->zone()),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       generator_resume_points_(info->literal()->yield_count(), info->zone()),
       generator_state_(),
       loop_depth_(0),
       home_object_symbol_(info->isolate()->factory()->home_object_symbol()),
       iterator_symbol_(info->isolate()->factory()->iterator_symbol()),
+      async_iterator_symbol_(
+          info->isolate()->factory()->async_iterator_symbol()),
       empty_fixed_array_(info->isolate()->factory()->empty_fixed_array()) {
   AstValueFactory* ast_value_factory = info->parse_info()->ast_value_factory();
   const AstRawString* prototype_string = ast_value_factory->prototype_string();
   ast_value_factory->Internalize(info->isolate());
   prototype_string_ = prototype_string->string();
   undefined_string_ = ast_value_factory->undefined_string();
 }
 
 Handle<BytecodeArray> BytecodeGenerator::FinalizeBytecode(Isolate* isolate) {
   AllocateDeferredConstants();
@@ skipping 1639 matching lines @@
     }
   }
 }
 
 void BytecodeGenerator::VisitYield(Yield* expr) {
   builder()->SetExpressionPosition(expr);
   Register value = VisitForRegisterValue(expr->expression());
 
   Register generator = VisitForRegisterValue(expr->generator_object());
 
-  // Save context, registers, and state. Then return.
-  builder()
-      ->LoadLiteral(Smi::FromInt(expr->yield_id()))
-      .SuspendGenerator(generator)
-      .LoadAccumulatorWithRegister(value)
-      .Return();  // Hard return (ignore any finally blocks).
+  const bool kIsAsyncGenerator =
+      IsAsyncGeneratorFunction(scope()->function_kind());
+
+  if (kIsAsyncGenerator && expr->yield_id() > 0 &&
+      expr->yield_type() != Yield::kAwait) {
+    RegisterList args = register_allocator()->NewRegisterList(2);
+
+    int context_index = Context::ASYNC_GENERATOR_YIELD;
+    if (expr->yield_type() == Yield::kDelegate) {
+      // Avoid wrapping in iterator result for yield* yields
+      context_index = Context::ASYNC_GENERATOR_RAW_YIELD;
+    }
+
+    builder()
+        ->LoadLiteral(Smi::FromInt(expr->yield_id()))
+        .SuspendGenerator(generator)
+        .MoveRegister(generator, args[0])
+        .MoveRegister(value, args[1])
+        .CallJSRuntime(context_index, args)
+        .Return();  // Hard return (ignore any finally blocks).
+  } else {
+    // Save context, registers, and state. Then return.
+    if (IsAsyncGeneratorFunction(scope()->function_kind()) &&
+        expr->yield_type() == Yield::kAwait) {
+      // For Await expressions in async generators, store the original
+      // generator input in the await input position, so it can be restored
+      // later. The first Yield can never be an Await.
+      DCHECK_GE(expr->yield_id(), 1);
+      builder()->CallRuntime(Runtime::kInlineGeneratorSaveInputForAwait,
+                             generator);
+    }
+
+    builder()
+        ->LoadLiteral(Smi::FromInt(expr->yield_id()))
+        .SuspendGenerator(generator)
+        .LoadAccumulatorWithRegister(value)
+        .Return();  // Hard return (ignore any finally blocks).
+  }
 
   builder()->Bind(&(generator_resume_points_[expr->yield_id()]));
   // Upon resume, we continue here.
 
   {
     RegisterAllocationScope register_scope(this);
 
     // Update state to indicate that we have finished resuming. Loop headers
     // rely on this.
     builder()
         ->LoadLiteral(Smi::FromInt(JSGeneratorObject::kGeneratorExecuting))
         .StoreAccumulatorInRegister(generator_state_);
 
     Register input = register_allocator()->NewRegister();
-    builder()
-        ->CallRuntime(Runtime::kInlineGeneratorGetInputOrDebugPos, generator)
-        .StoreAccumulatorInRegister(input);
+    if (!kIsAsyncGenerator || expr->yield_type() != Yield::kAwait) {
+      builder()
+          ->CallRuntime(Runtime::kInlineGeneratorGetInputOrDebugPos, generator)
+          .StoreAccumulatorInRegister(input);
+    } else {
+      // When resuming from an Await expression, the sent value is in the
+      // await input slot.
+      builder()
+          ->CallRuntime(Runtime::kInlineGeneratorGetAwaitInput, generator)

[Dan Ehrenberg, 2017/01/14 00:48:38]

Nit: 'GeneratorGetAwaitInput' is a sort of funny name; we are getting the input
for the last yield *across* an await, right? How about
AsyncGeneratorGetYieldInput (and, correspondingly,
AsyncGeneratorStoreYieldInput)?

Idle thought: Will TF be able to realize that, if you have multiple awaits, then
some of the reads and writes to this slot are dead? Probably this will not be
the bottleneck anytime soon, though, given that you have to go through a Promise
to get from one step to the next.

+          .StoreAccumulatorInRegister(input);
+    }
 
     Register resume_mode = register_allocator()->NewRegister();
     builder()
         ->CallRuntime(Runtime::kInlineGeneratorGetResumeMode, generator)
         .StoreAccumulatorInRegister(resume_mode);
 
     // Now dispatch on resume mode.
 
     BytecodeLabel resume_with_next;
     BytecodeLabel resume_with_return;
@@ skipping 601 matching lines @@
 void BytecodeGenerator::VisitGetIterator(GetIterator* expr) {
   FeedbackVectorSlot load_slot = expr->IteratorPropertyFeedbackSlot();
   FeedbackVectorSlot call_slot = expr->IteratorCallFeedbackSlot();
 
   RegisterList args = register_allocator()->NewRegisterList(1);
   Register method = register_allocator()->NewRegister();
   Register obj = args[0];
 
   VisitForAccumulatorValue(expr->iterable());
 
-  // Let method be GetMethod(obj, @@iterator).
-  builder()
-      ->StoreAccumulatorInRegister(obj)
-      .LoadNamedProperty(obj, iterator_symbol(), feedback_index(load_slot))
-      .StoreAccumulatorInRegister(method);
+  if (expr->hint() == GetIterator::kAsync) {
+    FeedbackVectorSlot load_slot2 = expr->AsyncIteratorPropertyFeedbackSlot();
+    FeedbackVectorSlot call_slot2 = expr->AsyncIteratorCallFeedbackSlot();
 
-  // Let iterator be Call(method, obj).
-  builder()->Call(method, args, feedback_index(call_slot),
-                  Call::NAMED_PROPERTY_CALL);
+    // Set method to GetMethod(obj, @@asyncIterator)
+    builder()->StoreAccumulatorInRegister(obj).LoadNamedProperty(
+        obj, async_iterator_symbol(), feedback_index(load_slot2));
 
-  // If Type(iterator) is not Object, throw a TypeError exception.
-  BytecodeLabel no_type_error;
-  builder()->JumpIfJSReceiver(&no_type_error);
-  builder()->CallRuntime(Runtime::kThrowSymbolIteratorInvalid);
-  builder()->Bind(&no_type_error);
+    BytecodeLabel create_async_from_sync, done;
+    builder()->JumpIfUndefined(&create_async_from_sync);
+
+    // Let iterator be Call(method, obj)
+    builder()->StoreAccumulatorInRegister(method).Call(
+        method, args, feedback_index(call_slot), Call::NAMED_PROPERTY_CALL);
+
+    // If Type(iterator) is not Object, throw a TypeError exception.
+    builder()->JumpIfJSReceiver(&done);
+    builder()->CallRuntime(Runtime::kThrowSymbolAsyncIteratorInvalid);
+
+    builder()->Bind(&create_async_from_sync);
+    // If method is undefined,
+    //     Let syncMethod be GetMethod(obj, @@iterator)
+    builder()
+        ->LoadNamedProperty(obj, iterator_symbol(), feedback_index(load_slot))
+        .StoreAccumulatorInRegister(method);
+
+    //     Let syncIterator be Call(syncMethod, obj)
+    builder()->Call(method, args, feedback_index(call_slot2),
+                    Call::NAMED_PROPERTY_CALL);
+
+    // Return CreateAsyncFromSyncIterator(syncIterator)
+    RegisterList args = register_allocator()->NewRegisterList(1);
+    Register sync_iterator = args[0];
+    builder()
+        ->StoreAccumulatorInRegister(sync_iterator)
+        .CallRuntime(Runtime::kInlineCreateAsyncFromSyncIterator, args);
+
+    builder()->Bind(&done);
+  } else {
+    // Let method be GetMethod(obj, @@iterator).
+    builder()
+        ->StoreAccumulatorInRegister(obj)
+        .LoadNamedProperty(obj, iterator_symbol(), feedback_index(load_slot))
+        .StoreAccumulatorInRegister(method);
+
+    // Let iterator be Call(method, obj).
+    builder()->Call(method, args, feedback_index(call_slot),
+                    Call::NAMED_PROPERTY_CALL);
+
+    // If Type(iterator) is not Object, throw a TypeError exception.
+    BytecodeLabel no_type_error;
+    builder()->JumpIfJSReceiver(&no_type_error);
+    builder()->CallRuntime(Runtime::kThrowSymbolIteratorInvalid);
+    builder()->Bind(&no_type_error);
+  }
 }
 
 void BytecodeGenerator::VisitThisFunction(ThisFunction* expr) {
   builder()->LoadAccumulatorWithRegister(Register::function_closure());
 }
 
 void BytecodeGenerator::VisitSuperCallReference(SuperCallReference* expr) {
   // Handled by VisitCall().
   UNREACHABLE();
 }
@@ skipping 405 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8