[async-iteration] add support for for-await-of loops in Async Functions

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 569 matching lines @@
       object_literals_(0, info->zone()),
       array_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()),
       prototype_string_(info->isolate()->factory()->prototype_string()),
       empty_fixed_array_(info->isolate()->factory()->empty_fixed_array()),
       undefined_string_(
           info->isolate()->ast_string_constants()->undefined_string()) {}
 
 Handle<BytecodeArray> BytecodeGenerator::FinalizeBytecode(Isolate* isolate) {
   AllocateDeferredConstants(isolate);
   if (HasStackOverflow()) return Handle<BytecodeArray>();
   return builder()->ToBytecodeArray(isolate);
 }
@@ skipping 2301 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();

[rmcilroy, 2017/01/20 10:34:01]

nit - could you name these async_load_slot, etc.

[caitp, 2017/01/20 20:17:19]

done

+    Register tmp = register_allocator()->NewRegister();

[rmcilroy, 2017/01/20 10:34:01]

Unused

[caitp, 2017/01/20 20:17:19]

It's gone

+    // Set method to GetMethod(obj, @@asyncIterator)
+    builder()->StoreAccumulatorInRegister(obj).LoadNamedProperty(
+        obj, async_iterator_symbol(), feedback_index(load_slot2));

[neis, 2017/01/20 14:38:15]

Nit: please format in the same style as below.

 
-  // 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);

[rmcilroy, 2017/01/20 10:34:01]

You could use TestUndetectable, JumpIfTrue here instead of two jumps. You could
also add a TODO to add a JumpIfUndetectable bytecode itself if it's useful in a
followup CL.

[caitp, 2017/01/20 20:17:19]

TestUndetectable checks for the Undetectable map bit (e.g. for
HTMLAllCollection, used to make `document.all == undefined` evaluate to true
even though it's not). All this bytecode seems to do is check fi the operand is
a HeapObject with the map bit set.

But, that's not the logic that makes sense in this case. A JumpIfNullOrUndefined
opcode would be convenient, though. This pattern is used elsewhere in the
bytecode-generator, see VisitForInStatement

[rmcilroy, 2017/01/25 09:20:44]

Ahh make sense, I forgot about the weird document.all behaviour. Could you add a
TODO about adding a JumpIfNullOrUndefined bytecode, thanks.

 
-  // 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);

[neis, 2017/01/20 14:38:15]

Shouldn't this be call_slot2 here? And in the Call below call_slot instead of
call_slot2?

[caitp, 2017/01/20 20:17:19]

Renamed these things to `load_iter_slot`, `call_iter_slot`,
`load_async_iter_slot`, and `call_async_iter_slot`, and use them in the right
places.

+
+    // 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];

[rmcilroy, 2017/01/20 10:34:01]

No need to allocate a register list for a single register, just pass allocate
sync_iterator with NewRegister and pass it into the overload for CallRuntime.

[caitp, 2017/01/20 20:17:19]

Something like this?

```
    // Return CreateAsyncFromSyncIterator(syncIterator)
    // alias `method` register as it's no longer used
    Register sync_iter = method;
    builder()
        ->StoreAccumulatorInRegister(sync_iter)
        .CallRuntime(Runtime::kInlineCreateAsyncFromSyncIterator, sync_iter);
```

or just allocate a new register?

[rmcilroy, 2017/01/25 09:20:44]

Yeah this is fine

+    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