Add step OverAwait to service protocol

runtime/vm/debugger.h

 // 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.
 
 #ifndef VM_DEBUGGER_H_
 #define VM_DEBUGGER_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/object.h"
@@ skipping 12 matching lines @@
 
 // A user-defined breakpoint, which either fires once, for a particular closure,
 // or always. The API's notion of a breakpoint corresponds to this object.
 class Breakpoint {
  public:
   Breakpoint(intptr_t id, BreakpointLocation* bpt_location)
     : id_(id),
       kind_(Breakpoint::kNone),
       next_(NULL),
       closure_(Instance::null()),
-      bpt_location_(bpt_location) {}
+      bpt_location_(bpt_location),
+      is_synthetic_async_(false) {}
 
   intptr_t id() const { return id_; }
   Breakpoint* next() const { return next_; }
   void set_next(Breakpoint* n) { next_ = n; }
 
   BreakpointLocation* bpt_location() const { return bpt_location_; }
   void set_bpt_location(BreakpointLocation* new_bpt_location);
 
   bool IsRepeated() const { return kind_ == kRepeated; }
   bool IsSingleShot() const { return kind_ == kSingleShot; }
   bool IsPerClosure() const { return kind_ == kPerClosure; }
   RawInstance* closure() const { return closure_; }
 
   void SetIsRepeated() {
     ASSERT(kind_ == kNone);
     kind_ = kRepeated;
   }
 
   void SetIsSingleShot() {
     ASSERT(kind_ == kNone);
     kind_ = kSingleShot;
   }
 
   void SetIsPerClosure(const Instance& closure) {
     ASSERT(kind_ == kNone);
     kind_ = kPerClosure;
     closure_ = closure.raw();
   }
 
+  // Mark that this breakpoint is a result of a step OverAwait request.
+  void set_is_synthetic_async(bool is_synthetic_async) {
+    is_synthetic_async_ = is_synthetic_async;
+  }
+  bool is_synthetic_async() const {
+    return is_synthetic_async_;
+  }
+
   void PrintJSON(JSONStream* stream);
 
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   enum ConditionKind {
     kNone,
     kRepeated,
     kSingleShot,
     kPerClosure,
   };
 
   intptr_t id_;
   ConditionKind kind_;
   Breakpoint* next_;
   RawInstance* closure_;
   BreakpointLocation* bpt_location_;
+  bool is_synthetic_async_;
 
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Breakpoint);
 };
 
 
 // BreakpointLocation represents a collection of breakpoint conditions at the
 // same token position in Dart source. There may be more than one CodeBreakpoint
 // object per BreakpointLocation.
 // An unresolved breakpoint is one where the underlying code has not
@@ skipping 31 matching lines @@
 
   intptr_t LineNumber();
   intptr_t ColumnNumber();
 
   void GetCodeLocation(Library* lib,
                        Script* script,
                        TokenPosition* token_pos) const;
 
   Breakpoint* AddRepeated(Debugger* dbg);
   Breakpoint* AddSingleShot(Debugger* dbg);
-  Breakpoint* AddPerClosure(Debugger* dbg, const Instance& closure);
+  Breakpoint* AddPerClosure(Debugger* dbg,
+                            const Instance& closure,
+                            bool for_over_await);
 
   bool AnyEnabled() const;
   bool IsResolved() const { return is_resolved_; }
   bool IsLatent() const { return !token_pos_.IsReal(); }
 
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   void SetResolved(const Function& func, TokenPosition token_pos);
 
@@ skipping 318 matching lines @@
   void NotifyCompilation(const Function& func);
   void NotifyDoneLoading();
 
   RawFunction* ResolveFunction(const Library& library,
                                const String& class_name,
                                const String& function_name);
 
   // Set breakpoint at closest location to function entry.
   Breakpoint* SetBreakpointAtEntry(const Function& target_function,
                                    bool single_shot);
-  Breakpoint* SetBreakpointAtActivation(const Instance& closure);
+  Breakpoint* SetBreakpointAtActivation(const Instance& closure,
+                                        bool for_over_await);
   Breakpoint* BreakpointAtActivation(const Instance& closure);
 
   // TODO(turnidge): script_url may no longer be specific enough.
   Breakpoint* SetBreakpointAtLine(const String& script_url,
                                   intptr_t line_number);
   Breakpoint* SetBreakpointAtLineCol(const String& script_url,
                                      intptr_t line_number,
                                      intptr_t column_number);
   RawError* OneTimeBreakAtEntry(const Function& target_function);
 
   BreakpointLocation* BreakpointLocationAtLineCol(const String& script_url,
                                                   intptr_t line_number,
                                                   intptr_t column_number);
 
 
   void RemoveBreakpoint(intptr_t bp_id);
   Breakpoint* GetBreakpointById(intptr_t id);
 
+  // Will return false if we are not at an await.
+  bool SetupStepOverAsyncSuspension();
   void SetStepOver();
   void SetSingleStep();
   void SetStepOut();
   bool IsStepping() const { return resume_action_ != kContinue; }
 
   bool IsPaused() const { return pause_event_ != NULL; }
 
   // Put the isolate into single stepping mode when Dart code next runs.
   //
   // This is used by the vm service to allow the user to step while
@@ skipping 81 matching lines @@
   enum ResumeAction {
     kContinue,
     kStepOver,
     kStepOut,
     kSingleStep
   };
 
   static bool HasAnyEventHandler();
   static bool HasDebugEventHandler();
   void InvokeEventHandler(DebuggerEvent* event);
-
+  bool IsAtAsyncJump(ActivationFrame* top_frame);
   void FindCompiledFunctions(const Script& script,
                              TokenPosition start_pos,
                              TokenPosition end_pos,
                              GrowableObjectArray* function_list);
   RawFunction* FindBestFit(const Script& script, TokenPosition token_pos);
   RawFunction* FindInnermostClosure(const Function& function,
                                     TokenPosition token_pos);
   TokenPosition ResolveBreakpointPos(const Function& func,
                                        TokenPosition requested_token_pos,
                                        TokenPosition last_token_pos,
@@ skipping 88 matching lines @@
   // When stepping through code, only pause the program if the top
   // frame corresponds to this fp value, or if the top frame is
   // lower on the stack.
   uword stepping_fp_;
 
   // If we step while at a breakpoint, we would hit the same pc twice.
   // We use this field to let us skip the next single-step after a
   // breakpoint.
   bool skip_next_step_;
 
+  // We keep this breakpoint alive until after the debugger does the step over
+  // async continuation machinery so that we can report that we've stopped
+  // at the breakpoint.
+  Breakpoint* synthetic_async_breakpoint_;
+
   Dart_ExceptionPauseInfo exc_pause_info_;
 
   static EventHandler* event_handler_;
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_