WIP [esnext] implement async iteration proposal

src/interpreter/interpreter-intrinsics.cc

Index: src/interpreter/interpreter-intrinsics.cc
diff --git a/src/interpreter/interpreter-intrinsics.cc b/src/interpreter/interpreter-intrinsics.cc
index 81ce5563f8202c059bf1ddc8d8f2b825de2e69e7..0c0a73023f223ebe767986cc7dc0f8a80c02bf31 100644
--- a/src/interpreter/interpreter-intrinsics.cc
+++ b/src/interpreter/interpreter-intrinsics.cc
@@ -383,6 +383,42 @@ Node* IntrinsicsHelper::ClassOf(Node* args_reg, Node* arg_count,
   return return_value.value();
 }
 
+Node* IntrinsicsHelper::CreateAsyncFromSyncIterator(Node* args_reg,
+                                                    Node* arg_count,
+                                                    Node* context) {
+  InterpreterAssembler::Label not_receiver(
+      assembler_, InterpreterAssembler::Label::kDeferred);
+  InterpreterAssembler::Label done(assembler_);
+  InterpreterAssembler::Variable return_value(assembler_,
+                                              MachineRepresentation::kTagged);
+
+  Node* sync_iterator = __ LoadRegister(args_reg);

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

This seems better than calling a runtime function to me, but for async iteration
it probably isn't really a bottleneck. Thoughts?

[Dan Ehrenberg, 2017/01/13 19:41:08]

Eh, seems like a good idea to me. I don't really see a downside; this code is
not hard to understand or maintain. You might have a short iterable where the
perf here becomes visible (`for await (let _ of []) {}` will run way faster!)

+
+  __ GotoIf(__ TaggedIsSmi(sync_iterator), &not_receiver);
+  __ GotoUnless(__ IsJSReceiver(sync_iterator), &not_receiver);
+
+  Node* const native_context = __ LoadNativeContext(context);
+  Node* const map = __ LoadContextElement(
+      native_context, Context::INITIAL_ASYNC_FROM_SYNC_ITERATOR_MAP_INDEX);
+  Node* const iterator = __ AllocateJSObjectFromMap(map);
+
+  __ StoreObjectFieldNoWriteBarrier(
+      iterator, JSAsyncFromSyncIterator::kSyncIteratorOffset, sync_iterator);
+
+  return_value.Bind(iterator);
+  __ Goto(&done);
+
+  __ Bind(&not_receiver);
+  {
+    return_value.Bind(
+        __ CallRuntime(Runtime::kThrowSymbolIteratorInvalid, context));
+    __ Goto(&done);
+  }
+
+  __ Bind(&done);
+  return return_value.value();
+}
+
 void IntrinsicsHelper::AbortIfArgCountMismatch(int expected, Node* actual) {
   InterpreterAssembler::Label match(assembler_);
   Node* comparison = __ Word32Equal(actual, __ Int32Constant(expected));