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

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 1572 matching lines @@
     bpt->Disable();
     delete bpt;
   }
   if (NeedsIsolateEvents()) {
     ServiceEvent event(isolate_, ServiceEvent::kIsolateExit);
     InvokeEventHandler(&event);
   }
 }
 
 
+void Debugger::OnIsolateRunnable() {

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

This patching of well-known functions is similar to
Intrinsifier::InitializeState(), MethodRecognizer::InitializeState() and
ObjectStore::InitKnownObject().  Consider attaching this setup to where they are
called instead of the runnable event.

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

At the time these functions are called we haven't attached a debugger instance
to the isolate yet. I agree it makes sense to do this at the time we call those
other functions but I also think this logic should live in the debugger.

+  if (!FLAG_async_debugger_stepping) {
+    // We don't have async debugger stepping enabled.
+    return;
+  }
+  Thread::EnterIsolate(isolate_);
+  Thread* thread = Thread::Current();
+  ASSERT(thread != NULL);
+  {
+    StackZone zone(thread);
+    HandleScope handle_scope(thread);
+
+    const Library& async_lib = Library::Handle(Library::AsyncLibrary());
+    // Grab the _AsyncStarStreamController class.
+    const Class& controller_class =
+        Class::Handle(async_lib.LookupClassAllowPrivate(
+            Symbols::_AsyncStarStreamController()));
+    const Array& functions = Array::Handle(controller_class.functions());
+    Function& function = Function::Handle();
+    // Mark all functions as not debuggable or inlinable.
+    for (intptr_t i = 0; i < functions.Length(); i++) {
+      if (functions.At(i) == Function::null()) {
+        break;
+      }
+      function ^= functions.At(i);
+      function.set_is_debuggable(false);
+      function.set_is_inlinable(false);
+    }
+  }
+  Thread::ExitIsolate();
+}
+
+
 static RawFunction* ResolveLibraryFunction(const Library& library,
                                            const String& fname) {
   ASSERT(!library.IsNull());
   const Object& object = Object::Handle(library.ResolveName(fname));
   if (!object.IsNull() && object.IsFunction()) {
     return Function::Cast(object).raw();
   }
   return Function::null();
 }
 
@@ skipping 2492 matching lines @@
         return bpt;
       }
       bpt = bpt->next();
     }
     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();
+  }
+}
+
+
+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) {
   BreakpointLocation* bpt = latent_locations_;
   String& bpt_url = String::Handle();
   while (bpt != NULL) {
     bpt_url = bpt->url();
     if (bpt_url.Equals(url) && (bpt->requested_line_number() == line) &&
         (bpt->requested_column_number() == column)) {
       return bpt;
@@ skipping 17 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart