Debugger support for step-into async and async* functions.

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 7243 matching lines @@
   // :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));
 
   TokenPosition token_pos = TokenPosition::kNoSource;
 
+
+  // 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);
+
   if (FLAG_causal_async_stacks) {
     // Add to AST:
     //   :async_stack_trace = _asyncStackTraceHelper();
     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);
   }
 
-
-  // 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);
-
   // :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 192 matching lines @@
 
   if (FLAG_causal_async_stacks) {
     // Add to AST:
     //   :async_stack_trace = _asyncStackTraceHelper();
     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);
   }
 
@@ skipping 1710 matching lines @@
   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();
+  // Call '_asyncStarMoveNextHelper' so that the debugger can intercept and

[rmacnak, 2017/03/23 20:20:18]

if (FLAG_support_debugger) {

[Cutch, 2017/03/23 21:24:51]

Done.

+  // handle single stepping into a async* generator.
+  const Function& async_star_move_next_helper = Function::ZoneHandle(
+      Z, isolate()->object_store()->async_star_move_next_helper());
+  ASSERT(!async_star_move_next_helper.IsNull());
+  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 5950 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