Implement debugger support for async step-out

runtime/vm/debugger.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/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "platform/address_sanitizer.h"
 
@@ skipping 695 matching lines @@
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
 
 RawObject* ActivationFrame::GetAsyncContextVariable(const String& name) {
-  if (!function_.IsAsyncClosure()) {
+  if (!function_.IsAsyncClosure() && !function_.IsAsyncGenClosure()) {
     return Object::null();
   }
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
   for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     if (var_descriptors_.GetName(i) == name.raw()) {
       const int8_t kind = var_info.kind();
       if (!live_frame_) {
@@ skipping 51 matching lines @@
   ASSERT(!stream_cls.IsNull());
   const Class& stream_impl_cls = Class::Handle(stream_cls.SuperClass());
   const Field& awaiter_field = Field::Handle(
       stream_impl_cls.LookupInstanceFieldAllowPrivate(Symbols::_Awaiter()));
   ASSERT(!awaiter_field.IsNull());
   return Instance::Cast(stream).GetField(awaiter_field);
 }
 
 
 RawObject* ActivationFrame::GetAsyncAwaiter() {
-  const Object& completer = Object::Handle(GetAsyncCompleter());
-  if (!completer.IsNull()) {
-    return GetAsyncCompleterAwaiter(completer);
-  }
   const Object& async_stream_controller_stream =
       Object::Handle(GetAsyncStreamControllerStream());
   if (!async_stream_controller_stream.IsNull()) {
     return GetAsyncStreamControllerStreamAwaiter(
         async_stream_controller_stream);
   }
+  const Object& completer = Object::Handle(GetAsyncCompleter());
+  if (!completer.IsNull()) {
+    return GetAsyncCompleterAwaiter(completer);
+  }
   return Object::null();
 }
 
 
 bool ActivationFrame::HandlesException(const Instance& exc_obj) {
   intptr_t try_index = TryIndex();
   if (try_index < 0) {
     return false;
   }
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
@@ skipping 2326 matching lines @@
   } else if (resume_action_ == kStepOver) {
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     skip_next_step_ = skip_next_step;
     ASSERT(stack_trace->Length() > 0);
     stepping_fp_ = stack_trace->FrameAt(0)->fp();
     if (FLAG_verbose_debug) {
       OS::Print("HandleSteppingRequest- kStepOver %" Px "\n", stepping_fp_);
     }
   } else if (resume_action_ == kStepOut) {
+    if (FLAG_async_debugger_stepping) {
+      if (stack_trace->FrameAt(0)->function().IsAsyncClosure() ||
+          stack_trace->FrameAt(0)->function().IsAsyncGenClosure()) {
+        // Request to step out of an async/async* closure.
+        const Object& async_op =
+            Object::Handle(stack_trace->FrameAt(0)->GetAsyncAwaiter());
+        if (!async_op.IsNull()) {
+          // Step out to the awaiter.
+          ASSERT(async_op.IsClosure());
+          AsyncStepInto(Closure::Cast(async_op));
+          return;
+        }
+      }
+    }
+    // Fall through to synchronous stepping.
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     // Find topmost caller that is debuggable.
     for (intptr_t i = 1; i < stack_trace->Length(); i++) {
       ActivationFrame* frame = stack_trace->FrameAt(i);
       if (frame->IsDebuggable()) {
         stepping_fp_ = frame->fp();
         break;
       }
     }
@@ skipping 949 matching lines @@
     loc = loc->next();
   }
   return NULL;
 }
 
 
 void Debugger::MaybeAsyncStepInto(const Closure& async_op) {
   if (FLAG_async_debugger_stepping && IsSingleStepping()) {
     // We are single stepping, set a breakpoint on the closure activation
     // and resume execution so we can hit the breakpoint.
-    SetBreakpointAtActivation(async_op, true);
-    Continue();
+    AsyncStepInto(async_op);
   }
 }
 
 
+void Debugger::AsyncStepInto(const Closure& async_op) {
+  SetBreakpointAtActivation(async_op, true);
+  Continue();
+}
+
+
 void Debugger::Continue() {
   SetResumeAction(kContinue);
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
 }
 
 
 BreakpointLocation* Debugger::GetLatentBreakpoint(const String& url,
                                                   intptr_t line,
                                                   intptr_t column) {
@@ skipping 24 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart