Track the 'awaiter return' call stack use it to detect uncaught exceptions in async functions

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 RUNTIME_VM_DEBUGGER_H_
 #define RUNTIME_VM_DEBUGGER_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/object.h"
@@ skipping 242 matching lines @@
 
 
 // ActivationFrame represents one dart function activation frame
 // on the call stack.
 class ActivationFrame : public ZoneAllocated {
  public:
   enum Kind {
     kRegular,
     kAsyncSuspensionMarker,
     kAsyncCausal,
+    kAsyncActivation,
   };
 
   ActivationFrame(uword pc,
                   uword fp,
                   uword sp,
                   const Code& code,
                   const Array& deopt_frame,
                   intptr_t deopt_frame_offset,
                   Kind kind = kRegular);
 
   ActivationFrame(uword pc, const Code& code);
 
   explicit ActivationFrame(Kind kind);
 
+  explicit ActivationFrame(const Closure& async_activation);
+
   uword pc() const { return pc_; }
   uword fp() const { return fp_; }
   uword sp() const { return sp_; }
   const Function& function() const {
     ASSERT(!function_.IsNull());
     return function_;
   }
   const Code& code() const {
     ASSERT(!code_.IsNull());
     return code_;
@@ skipping 38 matching lines @@
   const Context& GetSavedCurrentContext();
   RawObject* GetAsyncOperation();
 
   RawObject* Evaluate(const String& expr);
 
   // Print the activation frame into |jsobj|. if |full| is false, script
   // and local variable objects are only references. if |full| is true,
   // the complete script, function, and, local variable objects are included.
   void PrintToJSONObject(JSONObject* jsobj, bool full = false);
 
+  RawObject* GetAsyncAwaiter();
+
+  bool HandlesException(const Instance& exc_obj);
+
  private:
   void PrintToJSONObjectRegular(JSONObject* jsobj, bool full);
   void PrintToJSONObjectAsyncCausal(JSONObject* jsobj, bool full);
   void PrintToJSONObjectAsyncSuspensionMarker(JSONObject* jsobj, bool full);
 
   void PrintContextMismatchError(intptr_t ctx_slot,
                                  intptr_t frame_ctx_level,
                                  intptr_t var_ctx_level);
 
   intptr_t TryIndex();
   void GetPcDescriptors();
   void GetVarDescriptors();
   void GetDescIndices();
 
+  RawObject* GetAsyncStreamControllerStreamAwaiter(const Object& stream);
+  RawObject* GetAsyncStreamControllerStream();
+  RawObject* GetAsyncCompleterAwaiter(const Object& completer);
+  RawObject* GetAsyncCompleter();
+  void ExtractTokenPositionFromAsyncClosure();
+
   static const char* KindToCString(Kind kind) {
     switch (kind) {
       case kRegular:
         return "Regular";
       case kAsyncCausal:
         return "AsyncCausal";
       case kAsyncSuspensionMarker:
         return "AsyncSuspensionMarker";
       default:
         UNREACHABLE();
@@ skipping 261 matching lines @@
   BreakpointLocation* GetBreakpointLocation(const Script& script,
                                             TokenPosition token_pos,
                                             intptr_t requested_column);
   void MakeCodeBreakpointAt(const Function& func, BreakpointLocation* bpt);
   // Returns NULL if no breakpoint exists for the given address.
   CodeBreakpoint* GetCodeBreakpoint(uword breakpoint_address);
 
   void SyncBreakpointLocation(BreakpointLocation* loc);
 
   ActivationFrame* TopDartFrame() const;
-  static ActivationFrame* CollectDartFrame(Isolate* isolate,
-                                           uword pc,
-                                           StackFrame* frame,
-                                           const Code& code,
-                                           const Array& deopt_frame,
-                                           intptr_t deopt_frame_offset);
+  static ActivationFrame* CollectDartFrame(
+      Isolate* isolate,
+      uword pc,
+      StackFrame* frame,
+      const Code& code,
+      const Array& deopt_frame,
+      intptr_t deopt_frame_offset,
+      ActivationFrame::Kind kind = ActivationFrame::kRegular);
   static RawArray* DeoptimizeToArray(Thread* thread,
                                      StackFrame* frame,
                                      const Code& code);
   // Appends at least one stack frame. Multiple frames will be appended
   // if |code| at the frame's pc contains inlined functions.
   static void AppendCodeFrames(Thread* thread,
                                Isolate* isolate,
                                Zone* zone,
                                DebuggerStackTrace* stack_trace,
                                StackFrame* frame,
                                Code* code,
                                Code* inlined_code,
                                Array* deopt_frame);
   static DebuggerStackTrace* CollectStackTrace();
   static DebuggerStackTrace* CollectAsyncCausalStackTrace();
+  static DebuggerStackTrace* CollectAwaiterReturnStackTrace();
   void SignalPausedEvent(ActivationFrame* top_frame, Breakpoint* bpt);
 
   intptr_t nextId() { return next_id_++; }
 
+  bool ShouldPauseOnAsyncException(DebuggerStackTrace* stack_trace,
+                                   const Instance& exc);
+
   bool ShouldPauseOnException(DebuggerStackTrace* stack_trace,
                               const Instance& exc);
 
   void CollectLibraryFields(const GrowableObjectArray& field_list,
                             const Library& lib,
                             const String& prefix,
                             bool include_private_fields);
 
   // Handles any events which pause vm execution.  Breakpoints,
   // interrupts, etc.
@@ skipping 73 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEBUGGER_H_