Sane asynchronous debugging and stack traces

runtime/vm/parser.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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 3450 matching lines @@
     func.set_modifier(func_modifier);
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& generated_body_closure = Function::ZoneHandle(Z);
   if (func.IsAsyncFunction()) {
     ASSERT(!func.is_generated_body());
     // The code of an async function is synthesized. Disable debugging.
     func.set_is_debuggable(false);
+    // In order to produce sane asynchronous stacks we rely on this function
+    // not being inlined.
+    func.set_is_inlinable(false);
     generated_body_closure = OpenAsyncFunction(func.token_pos());
   } else if (func.IsAsyncClosure()) {
     // The closure containing the body of an async function is debuggable.
     ASSERT(func.is_debuggable());
     OpenAsyncClosure();
   } else if (func.IsSyncGenerator()) {
     // The code of a sync generator is synthesized. Disable debugging.
     func.set_is_debuggable(false);
     generated_body_closure = OpenSyncGeneratorFunction(func.token_pos());
   } else if (func.IsSyncGenClosure()) {
@@ skipping 3320 matching lines @@
   } else {
     // Create the closure containing the body of this async function.
     const String& async_func_name =
         String::Handle(Z, innermost_function().name());
     String& closure_name =
         String::Handle(Z, Symbols::NewFormatted(T, "<%s_async_body>",
                                                 async_func_name.ToCString()));
     closure = Function::NewClosureFunction(closure_name, innermost_function(),
                                            async_func_pos);
     closure.set_is_generated_body(true);
+    // In order to generate sane asynchronous stacks we rely on this function
+    // not being inlined.
+    closure.set_is_inlinable(false);
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
   AddAsyncClosureParameters(&closure_params);
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
 
@@ skipping 33 matching lines @@
   current_block_->scope->AddVariable(await_ctx_var);
 }
 
 
 void Parser::AddAsyncClosureVariables() {
   // Add to current block's scope:
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   //   var :async_completer;
+  //   var :async_stack_trace;
   LocalVariable* async_op_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::AsyncOperation(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_op_var);
   LocalVariable* async_then_callback_var = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncThenCallback(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncCatchErrorCallback(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_catch_error_callback_var);
   LocalVariable* async_completer =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::AsyncCompleter(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_completer);
+  LocalVariable* async_stack_trace = new (Z)
+      LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                    Symbols::AsyncStackTraceVar(), Object::dynamic_type());
+  current_block_->scope->AddVariable(async_stack_trace);
 }
 
 
 void Parser::AddAsyncGeneratorVariables() {
   // Add to current block's scope:
   //   var :controller;
   // The :controller variable is used by the async generator closure to
   // store the StreamController object to which the yielded expressions
   // are added.
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
+  //   var :async_stack_trace;
+  //   var :controller_stream
   // These variables are used to store the async generator closure containing
   // the body of the async* function. They are used by the await operator.
   LocalVariable* controller_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::Controller(), Object::dynamic_type());
   current_block_->scope->AddVariable(controller_var);
   LocalVariable* async_op_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::AsyncOperation(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_op_var);
   LocalVariable* async_then_callback_var = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncThenCallback(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncCatchErrorCallback(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_catch_error_callback_var);
+  LocalVariable* async_stack_trace = new (Z)
+      LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                    Symbols::AsyncStackTraceVar(), Object::dynamic_type());
+  current_block_->scope->AddVariable(async_stack_trace);
+  LocalVariable* controller_stream = new (Z)
+      LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                    Symbols::ControllerStream(), Object::dynamic_type());
+  current_block_->scope->AddVariable(controller_stream);
 }
 
 
 RawFunction* Parser::OpenAsyncGeneratorFunction(TokenPosition async_func_pos) {
   TRACE_PARSER("OpenAsyncGeneratorFunction");
   AddContinuationVariables();
   AddAsyncGeneratorVariables();
 
   Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
   // this async generator has already been created by a previous
   // compilation of this function.
   const Function& found_func = Function::Handle(
       Z, I->LookupClosureFunction(innermost_function(), async_func_pos));
   if (!found_func.IsNull()) {
     ASSERT(found_func.IsAsyncGenClosure());
     closure = found_func.raw();
   } else {
     // Create the closure containing the body of this async generator function.
     const String& async_generator_name =
         String::Handle(Z, innermost_function().name());
     const String& closure_name = String::Handle(
         Z, Symbols::NewFormatted(T, "<%s_async_gen_body>",
                                  async_generator_name.ToCString()));
     closure = Function::NewClosureFunction(closure_name, innermost_function(),
                                            async_func_pos);
     closure.set_is_generated_body(true);
+    closure.set_is_inlinable(false);
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddAsyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
@@ skipping 20 matching lines @@
 //   var :controller;
 //   var :await_jump_var = -1;
 //   var :await_context_var;
 //   f_async_body() {
 //     ... source code of f ...
 //   }
 //   var :async_op = f_async_body;
 //   var :async_then_callback = _asyncThenWrapperHelper(:async_op);
 //   var :async_catch_error_callback = _asyncCatchErrorWrapperHelper(:async_op);
 //   :controller = new _AsyncStarStreamController(:async_op);
-//   return :controller.stream;
+//   var :controller_stream = :controller.stream;
+//   return :controller_stream;
 // }
 SequenceNode* Parser::CloseAsyncGeneratorFunction(const Function& closure_func,
                                                   SequenceNode* closure_body) {
   TRACE_PARSER("CloseAsyncGeneratorFunction");
   ASSERT(!closure_func.IsNull());
   ASSERT(closure_body != NULL);
 
   // Explicitly reference variables of the async genenerator function from the
   // closure body in order to mark them as captured.
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::Controller(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AsyncOperation(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
       Symbols::AsyncThenCallback(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
       Symbols::AsyncCatchErrorCallback(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
+  existing_var = closure_body->scope()->LookupVariable(
+      Symbols::AsyncStackTraceVar(), false);
+  ASSERT((existing_var != NULL) && existing_var->is_captured());
+  existing_var =
+      closure_body->scope()->LookupVariable(Symbols::ControllerStream(), false);
+  ASSERT((existing_var != NULL) && existing_var->is_captured());
 
   const Library& async_lib = Library::Handle(Library::AsyncLibrary());
 
   const Class& controller_class = Class::Handle(
       Z,
       async_lib.LookupClassAllowPrivate(Symbols::_AsyncStarStreamController()));
   ASSERT(!controller_class.IsNull());
   const Function& controller_constructor = Function::ZoneHandle(
       Z, controller_class.LookupConstructorAllowPrivate(
              Symbols::_AsyncStarStreamControllerConstructor()));
 
+  TokenPosition token_pos = TokenPosition::kNoSource;
+
   // :await_jump_var = -1;
   LocalVariable* jump_var =
       current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
   LiteralNode* init_value = new (Z)
       LiteralNode(TokenPosition::kNoSource, Smi::ZoneHandle(Smi::New(-1)));
   current_block_->statements->Add(
       new (Z) StoreLocalNode(TokenPosition::kNoSource, jump_var, init_value));
 
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
   LocalVariable* async_op_var =
       current_block_->scope->LookupVariable(Symbols::AsyncOperation(), false);
   ClosureNode* closure_obj = new (Z) ClosureNode(
       TokenPosition::kNoSource, closure_func, NULL, closure_body->scope());
   StoreLocalNode* store_async_op = new (Z)
       StoreLocalNode(TokenPosition::kNoSource, async_op_var, closure_obj);
 
   current_block_->statements->Add(store_async_op);
 
+  // Add to AST:
+  //   :async_stack_trace = _asyncStackTraceHelper(:async_op);
+  const Function& async_stack_trace_helper = Function::ZoneHandle(
+      Z,
+      async_lib.LookupFunctionAllowPrivate(Symbols::AsyncStackTraceHelper()));
+  ASSERT(!async_stack_trace_helper.IsNull());
+  ArgumentListNode* async_stack_trace_helper_args =
+      new (Z) ArgumentListNode(TokenPosition::kNoSource);
+  async_stack_trace_helper_args->Add(
+      new (Z) LoadLocalNode(TokenPosition::kNoSource, async_op_var));
+  StaticCallNode* async_stack_trace_helper_call = new (Z) StaticCallNode(
+      token_pos, async_stack_trace_helper, async_stack_trace_helper_args);
+  LocalVariable* async_stack_trace_var = current_block_->scope->LookupVariable(
+      Symbols::AsyncStackTraceVar(), false);
+  StoreLocalNode* store_async_stack_trace = new (Z) StoreLocalNode(
+      token_pos, async_stack_trace_var, async_stack_trace_helper_call);
+  current_block_->statements->Add(store_async_stack_trace);
+
   // :async_then_callback = _asyncThenWrapperHelper(:async_op)
   const Function& async_then_wrapper_helper = Function::ZoneHandle(
       Z,
       async_lib.LookupFunctionAllowPrivate(Symbols::AsyncThenWrapperHelper()));
   ASSERT(!async_then_wrapper_helper.IsNull());
   ArgumentListNode* async_then_wrapper_helper_args =
       new (Z) ArgumentListNode(TokenPosition::kNoSource);
   async_then_wrapper_helper_args->Add(
       new (Z) LoadLocalNode(TokenPosition::kNoSource, async_op_var));
   StaticCallNode* then_wrapper_call = new (Z)
@@ skipping 36 matching lines @@
   ConstructorCallNode* controller_constructor_call =
       new (Z) ConstructorCallNode(TokenPosition::kNoSource,
                                   TypeArguments::ZoneHandle(Z),
                                   controller_constructor, arguments);
   LocalVariable* controller_var =
       current_block_->scope->LookupVariable(Symbols::Controller(), false);
   StoreLocalNode* store_controller = new (Z) StoreLocalNode(
       TokenPosition::kNoSource, controller_var, controller_constructor_call);
   current_block_->statements->Add(store_controller);
 
-  // return :controller.stream;
+  // Grab :controller.stream
+  InstanceGetterNode* controller_stream = new (Z) InstanceGetterNode(
+      TokenPosition::kNoSource,
+      new (Z) LoadLocalNode(TokenPosition::kNoSource, controller_var),
+      Symbols::Stream());
+
+  // Store :controller.stream into :controller_stream inside the closure.
+  // We have to remember the stream because a new instance is generated for
+  // each getter invocation and in order to recreate the linkage, we need the
+  // awaited on instance.
+  LocalVariable* controller_stream_var =
+      current_block_->scope->LookupVariable(Symbols::ControllerStream(), false);
+  ASSERT(controller_stream_var != NULL);
+
+  StoreLocalNode* store_controller_stream = new (Z) StoreLocalNode(
+      TokenPosition::kNoSource, controller_stream_var, controller_stream);
+  current_block_->statements->Add(store_controller_stream);
+
+  // return :controller_stream;
   ReturnNode* return_node = new (Z) ReturnNode(
       TokenPosition::kNoSource,
-      new (Z) InstanceGetterNode(
-          TokenPosition::kNoSource,
-          new (Z) LoadLocalNode(TokenPosition::kNoSource, controller_var),
-          Symbols::Stream()));
+      new (Z) LoadLocalNode(TokenPosition::kNoSource, controller_stream_var));
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::OpenAsyncGeneratorClosure() {
   async_temp_scope_ = current_block_->scope;
   OpenAsyncTryBlock();
 }
 
@@ skipping 49 matching lines @@
   // closure body in order to mark them as captured.
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
+  existing_var = closure_body->scope()->LookupVariable(
+      Symbols::AsyncStackTraceVar(), false);
+  ASSERT((existing_var != NULL) && existing_var->is_captured());
 
   // Create and return a new future that executes a closure with the current
   // body.
 
   // No need to capture parameters or other variables, since they have already
   // been captured in the corresponding scope as the body has been parsed within
   // a nested block (contained in the async function's block).
   const Class& future = Class::ZoneHandle(Z, I->object_store()->future_class());
   ASSERT(!future.IsNull());
   const Function& constructor = Function::ZoneHandle(
       Z, future.LookupFunction(Symbols::FutureMicrotask()));
   ASSERT(!constructor.IsNull());
   const Class& completer =
       Class::ZoneHandle(Z, I->object_store()->completer_class());
   ASSERT(!completer.IsNull());
   const Function& completer_constructor = Function::ZoneHandle(
       Z, completer.LookupFunction(Symbols::CompleterSyncConstructor()));
   ASSERT(!completer_constructor.IsNull());
 
+  const Library& async_lib = Library::Handle(Library::AsyncLibrary());
+
   LocalVariable* async_completer =
       current_block_->scope->LookupVariable(Symbols::AsyncCompleter(), false);
 
   const TokenPosition token_pos = ST(closure_body->token_pos());
   // Add to AST:
   //   :async_completer = new Completer.sync();
   ArgumentListNode* empty_args = new (Z) ArgumentListNode(token_pos);
   ConstructorCallNode* completer_constructor_node =
       new (Z) ConstructorCallNode(token_pos, TypeArguments::ZoneHandle(Z),
                                   completer_constructor, empty_args);
@@ skipping 12 matching lines @@
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
   LocalVariable* async_op_var =
       current_block_->scope->LookupVariable(Symbols::AsyncOperation(), false);
   ClosureNode* cn =
       new (Z) ClosureNode(token_pos, closure, NULL, closure_body->scope());
   StoreLocalNode* store_async_op =
       new (Z) StoreLocalNode(token_pos, async_op_var, cn);
   current_block_->statements->Add(store_async_op);
 
-  const Library& async_lib = Library::Handle(Library::AsyncLibrary());
+  // Add to AST:
+  //   :async_stack_trace = _asyncStackTraceHelper(:async_op);
+  const Function& async_stack_trace_helper = Function::ZoneHandle(
+      Z,
+      async_lib.LookupFunctionAllowPrivate(Symbols::AsyncStackTraceHelper()));
+  ASSERT(!async_stack_trace_helper.IsNull());
+  ArgumentListNode* async_stack_trace_helper_args =
+      new (Z) ArgumentListNode(token_pos);
+  async_stack_trace_helper_args->Add(
+      new (Z) LoadLocalNode(token_pos, async_op_var));
+  StaticCallNode* async_stack_trace_helper_call = new (Z) StaticCallNode(
+      token_pos, async_stack_trace_helper, async_stack_trace_helper_args);
+  LocalVariable* async_stack_trace_var = current_block_->scope->LookupVariable(
+      Symbols::AsyncStackTraceVar(), false);
+  StoreLocalNode* store_async_stack_trace = new (Z) StoreLocalNode(
+      token_pos, async_stack_trace_var, async_stack_trace_helper_call);
+  current_block_->statements->Add(store_async_stack_trace);
+
   // :async_then_callback = _asyncThenWrapperHelper(:async_op)
   const Function& async_then_wrapper_helper = Function::ZoneHandle(
       Z,
       async_lib.LookupFunctionAllowPrivate(Symbols::AsyncThenWrapperHelper()));
   ASSERT(!async_then_wrapper_helper.IsNull());
   ArgumentListNode* async_then_wrapper_helper_args =
       new (Z) ArgumentListNode(token_pos);
   async_then_wrapper_helper_args->Add(
       new (Z) LoadLocalNode(token_pos, async_op_var));
   StaticCallNode* then_wrapper_call = new (Z) StaticCallNode(
@@ skipping 1541 matching lines @@
   // contexts and if they have a matching token position range,
   // it can be an issue (cf. bug 26941).
   OpenBlock();
   const Block* await_for_block = current_block_;
 
   const TokenPosition stream_expr_pos = TokenPos();
   AstNode* stream_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
 
+  // Create :stream to store the stream into temporarily.
+  LocalVariable* stream_var =
+      new (Z) LocalVariable(stream_expr_pos, stream_expr_pos,
+                            Symbols::ColonStream(), Object::dynamic_type());
+  current_block_->scope->AddVariable(stream_var);
+
+  // Store the stream expression into a variable.
+  StoreLocalNode* store_stream_var =
+      new (Z) StoreLocalNode(stream_expr_pos, stream_var, stream_expr);
+  current_block_->statements->Add(store_stream_var);
+
+  // Register the awaiter on the stream by invoking `_asyncStarListenHelper`.
+  const Library& async_lib = Library::Handle(Library::AsyncLibrary());
+  const Function& async_star_listen_helper = Function::ZoneHandle(
+      Z,
+      async_lib.LookupFunctionAllowPrivate(Symbols::_AsyncStarListenHelper()));
+  ASSERT(!async_star_listen_helper.IsNull());
+  LocalVariable* async_op_var =
+      current_block_->scope->LookupVariable(Symbols::AsyncOperation(), false);
+  ASSERT(async_op_var != NULL);
+  ArgumentListNode* async_star_listen_helper_args =
+      new (Z) ArgumentListNode(stream_expr_pos);
+  async_star_listen_helper_args->Add(
+      new (Z) LoadLocalNode(stream_expr_pos, stream_var));
+  async_star_listen_helper_args->Add(
+      new (Z) LoadLocalNode(stream_expr_pos, async_op_var));
+  StaticCallNode* async_star_listen_helper_call = new (Z) StaticCallNode(
+      stream_expr_pos, async_star_listen_helper, async_star_listen_helper_args);
+  current_block_->statements->Add(async_star_listen_helper_call);
+
   // Build creation of implicit StreamIterator.
   // var :for-in-iter = new StreamIterator(stream_expr).
   const Class& stream_iterator_cls =
       Class::ZoneHandle(Z, I->object_store()->stream_iterator_class());
   ASSERT(!stream_iterator_cls.IsNull());
   const Function& iterator_ctor = Function::ZoneHandle(
       Z,
       stream_iterator_cls.LookupFunction(Symbols::StreamIteratorConstructor()));
   ASSERT(!iterator_ctor.IsNull());
   ArgumentListNode* ctor_args = new (Z) ArgumentListNode(stream_expr_pos);
-  ctor_args->Add(stream_expr);
+  ctor_args->Add(new (Z) LoadLocalNode(stream_expr_pos, stream_var));
   ConstructorCallNode* ctor_call = new (Z) ConstructorCallNode(
       stream_expr_pos, TypeArguments::ZoneHandle(Z), iterator_ctor, ctor_args);
   const AbstractType& iterator_type = Object::dynamic_type();
   LocalVariable* iterator_var = new (Z) LocalVariable(
       stream_expr_pos, stream_expr_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
   AstNode* iterator_init =
       new (Z) StoreLocalNode(stream_expr_pos, iterator_var, ctor_call);
   current_block_->statements->Add(iterator_init);
 
@@ skipping 24 matching lines @@
   LocalVariable* saved_try_ctx;
   LocalVariable* async_saved_try_ctx;
   LocalVariable* outer_saved_try_ctx;
   LocalVariable* outer_async_saved_try_ctx;
   CheckAsyncOpInTryBlock(&saved_try_ctx, &async_saved_try_ctx,
                          &outer_saved_try_ctx, &outer_async_saved_try_ctx);
   ArgumentListNode* no_args = new (Z) ArgumentListNode(stream_expr_pos);
   AstNode* iterator_moveNext = new (Z) InstanceCallNode(
       stream_expr_pos, new (Z) LoadLocalNode(stream_expr_pos, iterator_var),
       Symbols::MoveNext(), no_args);
+
   OpenBlock();
+  // Give the debugger an opportunity to 'step into' the generator by
+  // calling '_asyncStarMoveNextHelper'.
+  const Function& async_star_move_next_helper =
+      Function::ZoneHandle(Z, async_lib.LookupFunctionAllowPrivate(
+                                  Symbols::_AsyncStarMoveNextHelper()));
+  ASSERT(!async_star_move_next_helper.IsNull());
+  ASSERT(async_op_var != NULL);
+  ArgumentListNode* async_star_move_next_helper_args =
+      new (Z) ArgumentListNode(stream_expr_pos);
+  async_star_move_next_helper_args->Add(
+      new (Z) LoadLocalNode(stream_expr_pos, stream_var));
+  StaticCallNode* async_star_move_next_helper_call =
+      new (Z) StaticCallNode(stream_expr_pos, async_star_move_next_helper,
+                             async_star_move_next_helper_args);
+  current_block_->statements->Add(async_star_move_next_helper_call);
   AstNode* await_moveNext = new (Z) AwaitNode(
       stream_expr_pos, iterator_moveNext, saved_try_ctx, async_saved_try_ctx,
       outer_saved_try_ctx, outer_async_saved_try_ctx, current_block_->scope);
   AwaitTransformer at(current_block_->statements, async_temp_scope_);
   await_moveNext = at.Transform(await_moveNext);
   SequenceNode* await_preamble = CloseBlock();
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
@@ skipping 5820 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME