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, expr->yield_type())
+        .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.
+    builder()
+        ->LoadLiteral(Smi::FromInt(expr->yield_id()))
+        .SuspendGenerator(generator, expr->yield_type())
+        .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::kInlineAsyncGeneratorGetAwaitInput, generator)
+          .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();
+    Register tmp = register_allocator()->NewRegister();
+    // Set method to GetMethod(obj, @@asyncIterator)
+    builder()->StoreAccumulatorInRegister(obj).LoadNamedProperty(
+        obj, async_iterator_symbol(), feedback_index(load_slot2));
 
-  // Let iterator be Call(method, obj).
-  builder()->Call(method, args, feedback_index(call_slot),
-                  Call::NAMED_PROPERTY_CALL);
+    BytecodeLabel async_iterator_undefined, async_iterator_null, done;
+    builder()->JumpIfUndefined(&async_iterator_undefined);
+    builder()->JumpIfNull(&async_iterator_null);
 
-  // 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);
+    // 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(&async_iterator_undefined);
+    builder()->Bind(&async_iterator_null);
+    // 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