Fix stepping over await statements

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 "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 358 matching lines @@
 
 
 Breakpoint* BreakpointLocation::AddPerClosure(Debugger* dbg,
                                               const Instance& closure,
                                               bool for_over_await) {
   Breakpoint* bpt = breakpoints();
   while (bpt != NULL) {
     if (bpt->IsPerClosure() && bpt->closure() == closure.raw()) break;
     bpt = bpt->next();
   }
+  if (for_over_await &&
+      (bpt != NULL) &&
+      (bpt == dbg->synthetic_async_breakpoint_)) {
+    // If the debugger is paused after stepping over an await statement,

[Cutch, 2016/09/21 23:43:45]

I wonder if we could just do the following in this block:

if (for_over_await ....) {
  RemoveBreakpoint(bpt->id());
  remove_synthetic_async_breakpoint = false;   /* this controls whether or not
synthetic_async_breakpoint gets removed after the stepping */
  bpt = NULL;
}

...

This way we still create a new synthetic breakpoint.

[hausner, 2016/09/21 23:59:28]

Why is it important to create a new synthetic BP each time? Also, I think 
synthetic_async_breakpoint_ should be set to NULL if the breakpoint is refers to
is deleted.

+    // the synthetic breakpoint is temporarily kept in
+    // synthetic_async_breakpoint_ so it can be deleted when the step
+    // command resumes.
+    // If another step request over an async statement is issued, make
+    // sure the synthetic breakpoint does not get deleted.
+    dbg->synthetic_async_breakpoint_ = NULL;
+  }
   if (bpt == NULL) {
     bpt = new Breakpoint(dbg->nextId(), this);
     bpt->SetIsPerClosure(closure);
     bpt->set_is_synthetic_async(for_over_await);
     AddBreakpoint(bpt, dbg);
   }
   return bpt;
 }
 
 
@@ skipping 2317 matching lines @@
               String::Handle(frame->SourceUrl()).ToCString(),
               frame->LineNumber(),
               String::Handle(frame->QualifiedFunctionName()).ToCString(),
               frame->TokenPos().ToCString());
   }
 
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = CollectStackTrace();
   // If this step callback is part of stepping over an await statement,
   // we saved the synthetic async breakpoint in PauseBreakpoint. We report
   // that we are paused at that breakpoint and then delete it after continuing.

[Cutch, 2016/09/21 23:43:45]

remove_synthetic_async_breakpoint = true;

   SignalPausedEvent(frame, synthetic_async_breakpoint_);
   if (synthetic_async_breakpoint_ != NULL) {

[Cutch, 2016/09/21 23:43:45]

if (remove_synthetic_async_breakpoint && (synthetic_async_breakpoint_ != NULL))
{
}

     RemoveBreakpoint(synthetic_async_breakpoint_->id());
     synthetic_async_breakpoint_ = NULL;
   }
   HandleSteppingRequest(stack_trace_);
   stack_trace_ = NULL;
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error = Error::Handle(Thread::Current()->sticky_error());
   Thread::Current()->clear_sticky_error();
   return error.raw();
@@ skipping 597 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart