Implement async* functions in VM

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 1093 matching lines @@
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (HasContextScope()) {
     UnchainContexts(current_context_level);
   }
 
   AddReturnExit(node->token_pos(), return_value);
 
-  if ((function.IsAsyncClosure() || function.IsSyncGenClosure()) &&
+  if ((function.IsAsyncClosure() ||
+      function.IsSyncGenClosure() ||
+      function.IsAsyncGenClosure()) &&
       (node->return_type() == ReturnNode::kContinuationTarget)) {
     JoinEntryInstr* const join = new(I) JoinEntryInstr(
         owner()->AllocateBlockId(), owner()->try_index());
     owner()->await_joins()->Add(join);
     exit_ = join;
   }
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
@@ skipping 351 matching lines @@
   return new(I) AssertAssignableInstr(token_pos,
                                       value,
                                       instantiator,
                                       instantiator_type_arguments,
                                       dst_type,
                                       dst_name,
                                       deopt_id);
 }
 
 
-void EffectGraphVisitor::BuildYieldJump(LocalVariable* old_context,
-                                        LocalVariable* iterator_param,
-                                        const intptr_t old_ctx_level,
-                                        JoinEntryInstr* target) {
+void EffectGraphVisitor::BuildSyncYieldJump(LocalVariable* old_context,
+                                            LocalVariable* iterator_param,
+                                            const intptr_t old_ctx_level,
+                                            JoinEntryInstr* target) {
   // Building a jump consists of the following actions:
   // * Load the generator body's iterator parameter (:iterator)
   //   from the current context into a temporary.
   // * Restore the old context from :await_cxt_var.
   // * Copy the iterator saved above into the restored context.
   // * Append a Goto to the target's join.
   ASSERT((iterator_param != NULL) && iterator_param->is_captured());
   ASSERT((old_context != NULL) && old_context->is_captured());
   // Before restoring the context we need to temporarily save the
   // iterator parameter.
@@ skipping 32 matching lines @@
   Do(store);
 
   Do(ExitTempLocalScope(temp_context_var));
   Do(ExitTempLocalScope(temp_iterator_var));
 
   // Goto saved join.
   Goto(target);
 }
 
 
-void EffectGraphVisitor::BuildAwaitJump(LocalVariable* old_context,
+void EffectGraphVisitor::BuildAsyncJump(LocalVariable* old_context,
                                         LocalVariable* continuation_result,
                                         LocalVariable* continuation_error,
                                         LocalVariable* continuation_stack_trace,
                                         const intptr_t old_ctx_level,
                                         JoinEntryInstr* target) {
   // Building a jump consists of the following actions:
   // * Load the current continuation result parameter (:async_result)
   //   and continuation error parameter (:async_error_param) from
   //   the current context into temporaries.
   // * Restore the old context from :await_cxt_var.
@@ skipping 2322 matching lines @@
       pos++;
     }
   }
 
   // Continuation part:
   // If this node sequence is the body of a function with continuations,
   // leave room for a preamble.
   // The preamble is generated after visiting the body.
   GotoInstr* preamble_start = NULL;
   if (is_top_level_sequence &&
-      (function.IsAsyncClosure() || function.IsSyncGenClosure())) {
+      (function.IsAsyncClosure() ||
+          function.IsSyncGenClosure() ||
+          function.IsAsyncGenClosure())) {
     JoinEntryInstr* preamble_end = new(I) JoinEntryInstr(
         owner()->AllocateBlockId(), owner()->try_index());
     ASSERT(exit() != NULL);
     exit()->Goto(preamble_end);
     ASSERT(exit()->next()->IsGoto());
     preamble_start = exit()->next()->AsGoto();
     ASSERT(preamble_start->IsGoto());
     exit_ = preamble_end;
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
     }
   }
 
   // Continuation part:
   // After generating the CFG for the body we can create the preamble
   // because we know exactly how many continuation states we need.
   if (is_top_level_sequence &&
-      (function.IsAsyncClosure() || function.IsSyncGenClosure())) {
+      (function.IsAsyncClosure() ||
+          function.IsSyncGenClosure() ||
+          function.IsAsyncGenClosure())) {
     ASSERT(preamble_start != NULL);
     // We are at the top level. Fetch the corresponding scope.
     LocalScope* top_scope = node->scope();
     LocalVariable* jump_var = top_scope->LookupVariable(
         Symbols::AwaitJumpVar(), false);
     ASSERT(jump_var != NULL && jump_var->is_captured());
     Instruction* saved_entry = entry_;
     Instruction* saved_exit = exit_;
     entry_ = NULL;
     exit_ = NULL;
@@ skipping 10 matching lines @@
           Scanner::kNoSourcePos,
           Token::kEQ,
           load_jump_count,
           new(I) LiteralNode(
               Scanner::kNoSourcePos, Smi::ZoneHandle(I, Smi::New(i))));
       TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
       check_jump_count->Visit(&for_test);
       EffectGraphVisitor for_true(owner());
       EffectGraphVisitor for_false(owner());
 
-      if (function.IsAsyncClosure()) {
+      if (function.IsAsyncClosure() || function.IsAsyncGenClosure()) {
         LocalVariable* result_param =
             top_scope->LookupVariable(Symbols::AsyncOperationParam(), false);
         LocalVariable* error_param =
             top_scope->LookupVariable(Symbols::AsyncOperationErrorParam(),
                                       false);
         LocalVariable* stack_trace_param =
             top_scope->LookupVariable(Symbols::AsyncOperationStackTraceParam(),
                                       false);
-        for_true.BuildAwaitJump(old_context,
+        for_true.BuildAsyncJump(old_context,
                                 result_param,
                                 error_param,
                                 stack_trace_param,
                                 (*owner()->await_levels())[i],
                                 (*owner()->await_joins())[i]);
       } else {
         ASSERT(function.IsSyncGenClosure());
         LocalVariable* iterator_param =
             top_scope->LookupVariable(Symbols::IteratorParameter(), false);
-        for_true.BuildYieldJump(old_context,
-                                iterator_param,
-                                (*owner()->await_levels())[i],
-                                (*owner()->await_joins())[i]);
+        for_true.BuildSyncYieldJump(old_context,
+                                    iterator_param,
+                                    (*owner()->await_levels())[i],
+                                    (*owner()->await_joins())[i]);
       }
 
       Join(for_test, for_true, for_false);
       if (i == 0) {
         // Manually link up the preamble start.
         preamble_start->previous()->set_next(for_test.entry());
         for_test.entry()->set_previous(preamble_start->previous());
       }
       if (i == (num_await_states - 1)) {
         // Link up preamble end.
@@ skipping 383 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart