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

runtime/vm/debugger.cc

Index: runtime/vm/debugger.cc
diff --git a/runtime/vm/debugger.cc b/runtime/vm/debugger.cc
index 7cce4af2d10ae90f839ab2cd35f4afc9d6d1e53f..ae1ca3ed1fa16d4cd811f3dcbccb5fa60f9318d8 100644
--- a/runtime/vm/debugger.cc
+++ b/runtime/vm/debugger.cc
@@ -1590,6 +1590,39 @@ void Debugger::Shutdown() {
 }
 
 
+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());
@@ -4102,6 +4135,23 @@ Breakpoint* Debugger::GetBreakpointById(intptr_t id) {
 }
 
 
+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) {