VM: Re-format to use at most one newline between 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 18 matching lines @@
 #include "vm/service_isolate.h"
 #include "vm/stack_frame.h"
 #include "vm/stack_trace.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/thread_interrupter.h"
 #include "vm/timeline.h"
 #include "vm/token_position.h"
 #include "vm/visitor.h"
 
-
 namespace dart {
 
 DEFINE_FLAG(bool,
             show_invisible_frames,
             false,
             "Show invisible frames in debugger stack traces");
 DEFINE_FLAG(bool,
             trace_debugger_stacktrace,
             false,
             "Trace debugger stacktrace collection");
 DEFINE_FLAG(bool, trace_rewind, false, "Trace frame rewind");
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
 DEFINE_FLAG(bool,
             steal_breakpoints,
             false,
             "Intercept breakpoints and other pause events before they "
             "are sent to the embedder and use a generic VM breakpoint "
             "handler instead.  This handler dispatches breakpoints to "
             "the VM service.");
 
 DECLARE_FLAG(bool, warn_on_pause_with_no_debugger);
 
-
 #ifndef PRODUCT
 
 Debugger::EventHandler* Debugger::event_handler_ = NULL;
 
-
 class RemoteObjectCache : public ZoneAllocated {
  public:
   explicit RemoteObjectCache(intptr_t initial_size);
   intptr_t AddObject(const Object& obj);
   RawObject* GetObj(intptr_t obj_id) const;
   bool IsValidId(intptr_t obj_id) const { return obj_id < objs_->Length(); }
 
  private:
   GrowableObjectArray* objs_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteObjectCache);
 };
 
-
 // Create an unresolved breakpoint in given token range and script.
 BreakpointLocation::BreakpointLocation(const Script& script,
                                        TokenPosition token_pos,
                                        TokenPosition end_token_pos,
                                        intptr_t requested_line_number,
                                        intptr_t requested_column_number)
     : script_(script.raw()),
       url_(script.url()),
       token_pos_(token_pos),
       end_token_pos_(end_token_pos),
@@ skipping 21 matching lines @@
       next_(NULL),
       conditions_(NULL),
       requested_line_number_(requested_line_number),
       requested_column_number_(requested_column_number),
       function_(Function::null()),
       line_number_(-1),
       column_number_(-1) {
   ASSERT(requested_line_number_ >= 0);
 }
 
-
 BreakpointLocation::~BreakpointLocation() {
   Breakpoint* bpt = breakpoints();
   while (bpt != NULL) {
     Breakpoint* temp = bpt;
     bpt = bpt->next();
     delete temp;
   }
 }
 
-
 bool BreakpointLocation::AnyEnabled() const {
   return breakpoints() != NULL;
 }
 
-
 void BreakpointLocation::SetResolved(const Function& func,
                                      TokenPosition token_pos) {
   ASSERT(!IsLatent());
   ASSERT(func.script() == script_);
   ASSERT((func.token_pos() <= token_pos) &&
          (token_pos <= func.end_token_pos()));
   ASSERT(func.is_debuggable());
   function_ = func.raw();
   token_pos_ = token_pos;
   end_token_pos_ = token_pos;
   is_resolved_ = true;
 }
 
-
 // TODO(hausner): Get rid of library parameter. A source breakpoint location
 // does not imply a library, since the same source code can be included
 // in more than one library, e.g. the text location of mixin functions.
 void BreakpointLocation::GetCodeLocation(Library* lib,
                                          Script* script,
                                          TokenPosition* pos) const {
   if (IsLatent()) {
     *lib = Library::null();
     *script = Script::null();
     *pos = TokenPosition::kNoSource;
   } else {
     *script = this->script();
     *pos = token_pos_;
     if (IsResolved()) {
       const Function& func = Function::Handle(function_);
       ASSERT(!func.IsNull());
       const Class& cls = Class::Handle(func.origin());
       *lib = cls.library();
     } else {
       *lib = Library::null();
     }
   }
 }
 
-
 intptr_t BreakpointLocation::LineNumber() {
   ASSERT(IsResolved());
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(this->script());
     script.GetTokenLocation(token_pos_, &line_number_, NULL);
   }
   return line_number_;
 }
 
-
 intptr_t BreakpointLocation::ColumnNumber() {
   ASSERT(IsResolved());
   // Compute column number lazily since it causes scanning of the script.
   if (column_number_ < 0) {
     const Script& script = Script::Handle(this->script());
     script.GetTokenLocation(token_pos_, &line_number_, &column_number_);
   }
   return column_number_;
 }
 
-
 void Breakpoint::set_bpt_location(BreakpointLocation* new_bpt_location) {
   // Only latent breakpoints can be moved.
   ASSERT((new_bpt_location == NULL) || bpt_location_->IsLatent());
   bpt_location_ = new_bpt_location;
 }
 
-
 void Breakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&closure_));
 }
 
-
 void BreakpointLocation::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&script_));
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&url_));
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 
   Breakpoint* bpt = conditions_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
 }
 
-
 void Breakpoint::PrintJSON(JSONStream* stream) {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Breakpoint");
 
   jsobj.AddFixedServiceId("breakpoints/%" Pd "", id());
   jsobj.AddProperty("breakpointNumber", id());
   if (is_synthetic_async()) {
     jsobj.AddProperty("isSyntheticAsyncContinuation", is_synthetic_async());
   }
   jsobj.AddProperty("resolved", bpt_location_->IsResolved());
   if (bpt_location_->IsResolved()) {
     jsobj.AddLocation(bpt_location_);
   } else {
     jsobj.AddUnresolvedLocation(bpt_location_);
   }
 }
 
-
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&code_));
 #if !defined(TARGET_ARCH_DBC)
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&saved_value_));
 #endif
 }
 
-
 ActivationFrame::ActivationFrame(uword pc,
                                  uword fp,
                                  uword sp,
                                  const Code& code,
                                  const Array& deopt_frame,
                                  intptr_t deopt_frame_offset,
                                  ActivationFrame::Kind kind)
     : pc_(pc),
       fp_(fp),
       sp_(sp),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle(code.raw())),
       function_(Function::ZoneHandle(code.function())),
       live_frame_((kind == kRegular) || (kind == kAsyncActivation)),
       token_pos_initialized_(false),
       token_pos_(TokenPosition::kNoSource),
       try_index_(-1),
       deopt_id_(Thread::kNoDeoptId),
       line_number_(-1),
       column_number_(-1),
       context_level_(-1),
       deopt_frame_(Array::ZoneHandle(deopt_frame.raw())),
       deopt_frame_offset_(deopt_frame_offset),
       kind_(kind),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {}
 
-
 ActivationFrame::ActivationFrame(Kind kind)
     : pc_(0),
       fp_(0),
       sp_(0),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle()),
       function_(Function::ZoneHandle()),
       live_frame_(kind == kRegular),
       token_pos_initialized_(false),
       token_pos_(TokenPosition::kNoSource),
       try_index_(-1),
       line_number_(-1),
       column_number_(-1),
       context_level_(-1),
       deopt_frame_(Array::ZoneHandle()),
       deopt_frame_offset_(0),
       kind_(kind),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {}
 
-
 ActivationFrame::ActivationFrame(const Closure& async_activation)
     : pc_(0),
       fp_(0),
       sp_(0),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle()),
       function_(Function::ZoneHandle()),
       live_frame_(false),
       token_pos_initialized_(false),
       token_pos_(TokenPosition::kNoSource),
@@ skipping 10 matching lines @@
       pc_desc_(PcDescriptors::ZoneHandle()) {
   // Extract the function and the code from the asynchronous activation.
   function_ = async_activation.function();
   function_.EnsureHasCompiledUnoptimizedCode();
   code_ = function_.unoptimized_code();
   ctx_ = async_activation.context();
   ASSERT(fp_ == 0);
   ASSERT(!ctx_.IsNull());
 }
 
-
 bool Debugger::NeedsIsolateEvents() {
   return ((isolate_ != Dart::vm_isolate()) &&
           !ServiceIsolate::IsServiceIsolateDescendant(isolate_) &&
           ((event_handler_ != NULL) || Service::isolate_stream.enabled()));
 }
 
-
 bool Debugger::NeedsDebugEvents() {
   ASSERT(isolate_ != Dart::vm_isolate() &&
          !ServiceIsolate::IsServiceIsolateDescendant(isolate_));
   return (FLAG_warn_on_pause_with_no_debugger || (event_handler_ != NULL) ||
           Service::debug_stream.enabled());
 }
 
-
 void Debugger::InvokeEventHandler(ServiceEvent* event) {
   ASSERT(!event->IsPause());  // For pause events, call Pause instead.
   Service::HandleEvent(event);
 
   // Call the embedder's event handler, if it exists.
   if (event_handler_ != NULL) {
     TransitionVMToNative transition(Thread::Current());
     (*event_handler_)(event);
   }
 }
 
-
 RawError* Debugger::PauseInterrupted() {
   return PauseRequest(ServiceEvent::kPauseInterrupted);
 }
 
-
 RawError* Debugger::PausePostRequest() {
   return PauseRequest(ServiceEvent::kPausePostRequest);
 }
 
-
 RawError* Debugger::PauseRequest(ServiceEvent::EventKind kind) {
   if (ignore_breakpoints_ || IsPaused()) {
     // We don't let the isolate get interrupted if we are already
     // paused or ignoring breakpoints.
     return Error::null();
   }
   ServiceEvent event(isolate_, kind);
   DebuggerStackTrace* trace = CollectStackTrace();
   if (trace->Length() > 0) {
     event.set_top_frame(trace->FrameAt(0));
   }
   CacheStackTraces(trace, CollectAsyncCausalStackTrace(),
                    CollectAwaiterReturnStackTrace());
   resume_action_ = kContinue;
   Pause(&event);
   HandleSteppingRequest(trace);
   ClearCachedStackTraces();
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error = Error::Handle(Thread::Current()->sticky_error());
   ASSERT(error.IsNull() || error.IsUnwindError());
   Thread::Current()->clear_sticky_error();
   return error.raw();
 }
 
-
 void Debugger::SendBreakpointEvent(ServiceEvent::EventKind kind,
                                    Breakpoint* bpt) {
   if (NeedsDebugEvents()) {
     // TODO(turnidge): Currently we send single-shot breakpoint events
     // to the vm service.  Do we want to change this?
     ServiceEvent event(isolate_, kind);
     event.set_breakpoint(bpt);
     InvokeEventHandler(&event);
   }
 }
 
-
 void BreakpointLocation::AddBreakpoint(Breakpoint* bpt, Debugger* dbg) {
   bpt->set_next(breakpoints());
   set_breakpoints(bpt);
 
   dbg->SyncBreakpointLocation(this);
   dbg->SendBreakpointEvent(ServiceEvent::kBreakpointAdded, bpt);
 }
 
-
 Breakpoint* BreakpointLocation::AddRepeated(Debugger* dbg) {
   Breakpoint* bpt = breakpoints();
   while (bpt != NULL) {
     if (bpt->IsRepeated()) break;
     bpt = bpt->next();
   }
   if (bpt == NULL) {
     bpt = new Breakpoint(dbg->nextId(), this);
     bpt->SetIsRepeated();
     AddBreakpoint(bpt, dbg);
   }
   return bpt;
 }
 
-
 Breakpoint* BreakpointLocation::AddSingleShot(Debugger* dbg) {
   Breakpoint* bpt = breakpoints();
   while (bpt != NULL) {
     if (bpt->IsSingleShot()) break;
     bpt = bpt->next();
   }
   if (bpt == NULL) {
     bpt = new Breakpoint(dbg->nextId(), this);
     bpt->SetIsSingleShot();
     AddBreakpoint(bpt, dbg);
   }
   return bpt;
 }
 
-
 Breakpoint* BreakpointLocation::AddPerClosure(Debugger* dbg,
                                               const Instance& closure,
                                               bool for_over_await) {
   Breakpoint* bpt = NULL;
   // Do not reuse existing breakpoints for stepping over await clauses.
   // A second async step-over command will set a new breakpoint before
   // the existing one gets deleted when first async step-over resumes.
   if (!for_over_await) {
     bpt = breakpoints();
     while (bpt != NULL) {
       if (bpt->IsPerClosure() && (bpt->closure() == closure.raw())) break;
       bpt = bpt->next();
     }
   }
   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;
 }
 
-
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.Owner());
   String& class_name = String::Handle(func_class.Name());
 
   return OS::SCreate(Thread::Current()->zone(), "%s%s%s",
                      func_class.IsTopLevel() ? "" : class_name.ToCString(),
                      func_class.IsTopLevel() ? "" : ".", func_name.ToCString());
 }
 
-
 // Returns true if the function |func| overlaps the token range
 // [|token_pos|, |end_token_pos|] in |script|.
 static bool FunctionOverlaps(const Function& func,
                              const Script& script,
                              TokenPosition token_pos,
                              TokenPosition end_token_pos) {
   TokenPosition func_start = func.token_pos();
   if (((func_start <= token_pos) && (token_pos <= func.end_token_pos())) ||
       ((token_pos <= func_start) && (func_start <= end_token_pos))) {
     // Check script equality second because it allocates
     // handles as a side effect.
     return func.script() == script.raw();
   }
   return false;
 }
 
-
 static bool IsImplicitFunction(const Function& func) {
   switch (func.kind()) {
     case RawFunction::kImplicitGetter:
     case RawFunction::kImplicitSetter:
     case RawFunction::kImplicitStaticFinalGetter:
     case RawFunction::kMethodExtractor:
     case RawFunction::kNoSuchMethodDispatcher:
     case RawFunction::kInvokeFieldDispatcher:
     case RawFunction::kIrregexpFunction:
       return true;
     default:
       if (func.token_pos() == func.end_token_pos()) {
         // |func| could be an implicit constructor for example.
         return true;
       }
   }
   return false;
 }
 
-
 bool Debugger::HasBreakpoint(const Function& func, Zone* zone) {
   if (!func.HasCode()) {
     // If the function is not compiled yet, just check whether there
     // is a user-defined breakpoint that falls into the token
     // range of the function. This may be a false positive: the breakpoint
     // might be inside a local closure.
     Script& script = Script::Handle(zone);
     BreakpointLocation* sbpt = breakpoint_locations_;
     while (sbpt != NULL) {
       script = sbpt->script();
       if (FunctionOverlaps(func, script, sbpt->token_pos(),
                            sbpt->end_token_pos())) {
         return true;
       }
       sbpt = sbpt->next_;
     }
     return false;
   }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     if (func.raw() == cbpt->function()) {
       return true;
     }
     cbpt = cbpt->next_;
   }
   return false;
 }
 
-
 bool Debugger::HasBreakpoint(const Code& code) {
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     if (code.raw() == cbpt->code_) {
       return true;
     }
     cbpt = cbpt->next_;
   }
   return false;
 }
 
-
 void Debugger::PrintBreakpointsToJSONArray(JSONArray* jsarr) const {
   PrintBreakpointsListToJSONArray(breakpoint_locations_, jsarr);
   PrintBreakpointsListToJSONArray(latent_locations_, jsarr);
 }
 
-
 void Debugger::PrintBreakpointsListToJSONArray(BreakpointLocation* sbpt,
                                                JSONArray* jsarr) const {
   while (sbpt != NULL) {
     Breakpoint* bpt = sbpt->breakpoints();
     while (bpt != NULL) {
       jsarr->AddValue(bpt);
       bpt = bpt->next();
     }
     sbpt = sbpt->next_;
   }
 }
 
-
 void Debugger::PrintSettingsToJSONObject(JSONObject* jsobj) const {
   // This won't cut it when we support filtering by class, etc.
   switch (GetExceptionPauseInfo()) {
     case kNoPauseOnExceptions:
       jsobj->AddProperty("_exceptions", "none");
       break;
     case kPauseOnAllExceptions:
       jsobj->AddProperty("_exceptions", "all");
       break;
     case kPauseOnUnhandledExceptions:
       jsobj->AddProperty("_exceptions", "unhandled");
       break;
     default:
       UNREACHABLE();
   }
 }
 
-
 RawString* ActivationFrame::QualifiedFunctionName() {
   return String::New(Debugger::QualifiedFunctionName(function()));
 }
 
-
 RawString* ActivationFrame::SourceUrl() {
   const Script& script = Script::Handle(SourceScript());
   return script.url();
 }
 
-
 RawScript* ActivationFrame::SourceScript() {
   return function().script();
 }
 
-
 RawLibrary* ActivationFrame::Library() {
   const Class& cls = Class::Handle(function().origin());
   return cls.library();
 }
 
-
 void ActivationFrame::GetPcDescriptors() {
   if (pc_desc_.IsNull()) {
     pc_desc_ = code().pc_descriptors();
     ASSERT(!pc_desc_.IsNull());
   }
 }
 
-
 // Compute token_pos_ and try_index_ and token_pos_initialized_.
 TokenPosition ActivationFrame::TokenPos() {
   if (!token_pos_initialized_) {
     token_pos_initialized_ = true;
     token_pos_ = TokenPosition::kNoSource;
     GetPcDescriptors();
     PcDescriptors::Iterator iter(pc_desc_, RawPcDescriptors::kAnyKind);
     uword pc_offset = pc_ - code().PayloadStart();
     while (iter.MoveNext()) {
       if (iter.PcOffset() == pc_offset) {
         try_index_ = iter.TryIndex();
         token_pos_ = iter.TokenPos();
         deopt_id_ = iter.DeoptId();
         break;
       }
     }
   }
   return token_pos_;
 }
 
-
 intptr_t ActivationFrame::TryIndex() {
   if (!token_pos_initialized_) {
     TokenPos();  // Side effect: computes token_pos_initialized_, try_index_.
   }
   return try_index_;
 }
 
-
 intptr_t ActivationFrame::DeoptId() {
   if (!token_pos_initialized_) {
     TokenPos();  // Side effect: computes token_pos_initialized_, try_index_.
   }
   return deopt_id_;
 }
 
-
 intptr_t ActivationFrame::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if ((line_number_ < 0) && TokenPos().IsSourcePosition()) {
     const TokenPosition token_pos = TokenPos().SourcePosition();
     const Script& script = Script::Handle(SourceScript());
     script.GetTokenLocation(token_pos, &line_number_, NULL);
   }
   return line_number_;
 }
 
-
 intptr_t ActivationFrame::ColumnNumber() {
   // Compute column number lazily since it causes scanning of the script.
   if ((column_number_ < 0) && TokenPos().IsSourcePosition()) {
     const TokenPosition token_pos = TokenPos().SourcePosition();
     const Script& script = Script::Handle(SourceScript());
     if (script.HasSource()) {
       script.GetTokenLocation(token_pos, &line_number_, &column_number_);
     } else {
       column_number_ = -1;
     }
   }
   return column_number_;
 }
 
-
 void ActivationFrame::GetVarDescriptors() {
   if (var_descriptors_.IsNull()) {
     Code& unoptimized_code = Code::Handle(function().unoptimized_code());
     if (unoptimized_code.IsNull()) {
       Thread* thread = Thread::Current();
       Zone* zone = thread->zone();
       const Error& error = Error::Handle(
           zone, Compiler::EnsureUnoptimizedCode(thread, function()));
       if (!error.IsNull()) {
         Exceptions::PropagateError(error);
       }
       unoptimized_code ^= function().unoptimized_code();
     }
     ASSERT(!unoptimized_code.IsNull());
     var_descriptors_ = unoptimized_code.GetLocalVarDescriptors();
     ASSERT(!var_descriptors_.IsNull());
   }
 }
 
-
 bool ActivationFrame::IsDebuggable() const {
   return Debugger::IsDebuggable(function());
 }
 
-
 void ActivationFrame::PrintDescriptorsError(const char* message) {
   OS::PrintErr("Bad descriptors: %s\n", message);
   OS::PrintErr("function %s\n", function().ToQualifiedCString());
   OS::PrintErr("pc_ %" Px "\n", pc_);
   OS::PrintErr("deopt_id_ %" Px "\n", deopt_id_);
   OS::PrintErr("context_level_ %" Px "\n", context_level_);
   DisassembleToStdout formatter;
   code().Disassemble(&formatter);
   PcDescriptors::Handle(code().pc_descriptors()).Print();
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
                             Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = frames.NextFrame();
   while (frame != NULL) {
     OS::PrintErr("%s\n", frame->ToCString());
     frame = frames.NextFrame();
   }
   OS::Abort();
 }
 
-
 // Calculate the context level at the current token index of the frame.
 intptr_t ActivationFrame::ContextLevel() {
   const Context& ctx = GetSavedCurrentContext();
   if (context_level_ < 0 && !ctx.IsNull()) {
     ASSERT(!code_.is_optimized());
 
     GetVarDescriptors();
     intptr_t deopt_id = DeoptId();
     if (deopt_id == Thread::kNoDeoptId) {
       PrintDescriptorsError("Missing deopt id");
@@ skipping 13 matching lines @@
       }
     }
     if (!found) {
       PrintDescriptorsError("Missing context level");
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
-
 RawObject* ActivationFrame::GetAsyncContextVariable(const String& name) {
   if (!function_.IsAsyncClosure() && !function_.IsAsyncGenClosure()) {
     return Object::null();
   }
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
   for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     if (var_descriptors_.GetName(i) == name.raw()) {
       const int8_t kind = var_info.kind();
       if (!live_frame_) {
         ASSERT(kind == RawLocalVarDescriptors::kContextVar);
       }
       if (kind == RawLocalVarDescriptors::kStackVar) {
         return GetStackVar(var_info.index());
       } else {
         ASSERT(kind == RawLocalVarDescriptors::kContextVar);
         if (!live_frame_) {
           ASSERT(!ctx_.IsNull());
           return ctx_.At(var_info.index());
         }
         return GetContextVar(var_info.scope_id, var_info.index());
       }
     }
   }
   return Object::null();
 }
 
-
 RawObject* ActivationFrame::GetAsyncCompleter() {
   return GetAsyncContextVariable(Symbols::AsyncCompleter());
 }
 
-
 RawObject* ActivationFrame::GetAsyncCompleterAwaiter(const Object& completer) {
   const Class& sync_completer_cls = Class::Handle(completer.clazz());
   ASSERT(!sync_completer_cls.IsNull());
   const Class& completer_cls = Class::Handle(sync_completer_cls.SuperClass());
   const Field& future_field =
       Field::Handle(completer_cls.LookupInstanceFieldAllowPrivate(
           Symbols::CompleterFuture()));
   ASSERT(!future_field.IsNull());
   Instance& future = Instance::Handle();
   future ^= Instance::Cast(completer).GetField(future_field);
   if (future.IsNull()) {
     // The completer object may not be fully initialized yet.
     return Object::null();
   }
   const Class& future_cls = Class::Handle(future.clazz());
   ASSERT(!future_cls.IsNull());
   const Field& awaiter_field = Field::Handle(
       future_cls.LookupInstanceFieldAllowPrivate(Symbols::_Awaiter()));
   ASSERT(!awaiter_field.IsNull());
   return future.GetField(awaiter_field);
 }
 
-
 RawObject* ActivationFrame::GetAsyncStreamControllerStream() {
   return GetAsyncContextVariable(Symbols::ControllerStream());
 }
 
-
 RawObject* ActivationFrame::GetAsyncStreamControllerStreamAwaiter(
     const Object& stream) {
   const Class& stream_cls = Class::Handle(stream.clazz());
   ASSERT(!stream_cls.IsNull());
   const Class& stream_impl_cls = Class::Handle(stream_cls.SuperClass());
   const Field& awaiter_field = Field::Handle(
       stream_impl_cls.LookupInstanceFieldAllowPrivate(Symbols::_Awaiter()));
   ASSERT(!awaiter_field.IsNull());
   return Instance::Cast(stream).GetField(awaiter_field);
 }
 
-
 RawObject* ActivationFrame::GetAsyncAwaiter() {
   const Object& async_stream_controller_stream =
       Object::Handle(GetAsyncStreamControllerStream());
   if (!async_stream_controller_stream.IsNull()) {
     return GetAsyncStreamControllerStreamAwaiter(
         async_stream_controller_stream);
   }
   const Object& completer = Object::Handle(GetAsyncCompleter());
   if (!completer.IsNull()) {
     return GetAsyncCompleterAwaiter(completer);
   }
   return Object::null();
 }
 
-
 RawObject* ActivationFrame::GetCausalStack() {
   return GetAsyncContextVariable(Symbols::AsyncStackTraceVar());
 }
 
-
 bool ActivationFrame::HandlesException(const Instance& exc_obj) {
   if ((kind_ == kAsyncSuspensionMarker) || (kind_ == kAsyncCausal)) {
     // These frames are historical.
     return false;
   }
   intptr_t try_index = TryIndex();
   if (try_index < 0) {
     return false;
   }
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
@@ skipping 27 matching lines @@
                                  Object::null_type_arguments(), NULL)) {
           return true;
         }
       }
     }
     try_index = handlers.OuterTryIndex(try_index);
   }
   return false;
 }
 
-
 void ActivationFrame::ExtractTokenPositionFromAsyncClosure() {
   // Attempt to determine the token position from the async closure.
   ASSERT(function_.IsAsyncGenClosure() || function_.IsAsyncClosure());
   // This should only be called on frames that aren't active on the stack.
   ASSERT(fp() == 0);
   const Array& await_to_token_map =
       Array::Handle(code_.await_token_positions());
   if (await_to_token_map.IsNull()) {
     // No mapping.
     return;
@@ skipping 33 matching lines @@
       // TODO(johnmccutchan): Is this heuristic precise enough?
       if (iter.TryIndex() != CatchClauseNode::kInvalidTryIndex) {
         if ((try_index_ == -1) || (iter.TryIndex() < try_index_)) {
           try_index_ = iter.TryIndex();
         }
       }
     }
   }
 }
 
-
 bool ActivationFrame::IsAsyncMachinery() const {
   Isolate* isolate = Isolate::Current();
   if (function_.raw() == isolate->object_store()->complete_on_async_return()) {
     // We are completing an async function's completer.
     return true;
   }
   if (function_.Owner() ==
       isolate->object_store()->async_star_stream_controller()) {
     // We are inside the async* stream controller code.
     return true;
   }
   return false;
 }
 
-
 // Get the saved current context of this activation.
 const Context& ActivationFrame::GetSavedCurrentContext() {
   if (!ctx_.IsNull()) return ctx_;
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
   Object& obj = Object::Handle();
   for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     const int8_t kind = var_info.kind();
@@ skipping 12 matching lines @@
         ctx_ ^= Context::Cast(obj).raw();
       } else {
         ASSERT(obj.IsNull());
       }
       return ctx_;
     }
   }
   return ctx_;
 }
 
-
 RawObject* ActivationFrame::GetAsyncOperation() {
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
   for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     if (var_descriptors_.GetName(i) == Symbols::AsyncOperation().raw()) {
       const int8_t kind = var_info.kind();
       if (kind == RawLocalVarDescriptors::kStackVar) {
         return GetStackVar(var_info.index());
       } else {
         ASSERT(kind == RawLocalVarDescriptors::kContextVar);
         return GetContextVar(var_info.scope_id, var_info.index());
       }
     }
   }
   return Object::null();
 }
 
-
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
   for (intptr_t frame_index = 0; frame_index < Length(); frame_index++) {
     ActivationFrame* frame = FrameAt(frame_index);
     if (frame->HandlesException(exc_obj)) {
       return frame;
     }
   }
   return NULL;
 }
 
-
 void ActivationFrame::GetDescIndices() {
   if (vars_initialized_) {
     return;
   }
   GetVarDescriptors();
 
   TokenPosition activation_token_pos = TokenPos();
   if (!activation_token_pos.IsDebugPause() || !live_frame_) {
     // We don't have a token position for this frame, so can't determine
     // which variables are visible.
@@ skipping 55 matching lines @@
         // No duplicate name found. Add the current descriptor index to the
         // list of visible variables.
         desc_indices_.Add(cur_idx);
         var_names.Add(&var_name);
       }
     }
   }
   vars_initialized_ = true;
 }
 
-
 intptr_t ActivationFrame::NumLocalVariables() {
   GetDescIndices();
   return desc_indices_.length();
 }
 
-
 DART_FORCE_INLINE static RawObject* GetVariableValue(uword addr) {
   return *reinterpret_cast<RawObject**>(addr);
 }
 
-
 RawObject* ActivationFrame::GetParameter(intptr_t index) {
   intptr_t num_parameters = function().num_fixed_parameters();
   ASSERT(0 <= index && index < num_parameters);
 
   if (function().NumOptionalParameters() > 0) {
     // If the function has optional parameters, the first positional parameter
     // can be in a number of places in the caller's frame depending on how many
     // were actually supplied at the call site, but they are copied to a fixed
     // place in the callee's frame.
     return GetVariableValue(
         LocalVarAddress(fp(), (kFirstLocalSlotFromFp - index)));
   } else {
     intptr_t reverse_index = num_parameters - index;
     return GetVariableValue(ParamAddress(fp(), reverse_index));
   }
 }
 
-
 RawObject* ActivationFrame::GetClosure() {
   ASSERT(function().IsClosureFunction());
   return GetParameter(0);
 }
 
-
 RawObject* ActivationFrame::GetStackVar(intptr_t slot_index) {
   if (deopt_frame_.IsNull()) {
     return GetVariableValue(LocalVarAddress(fp(), slot_index));
   } else {
     return deopt_frame_.At(LocalVarIndex(deopt_frame_offset_, slot_index));
   }
 }
 
-
 bool ActivationFrame::IsRewindable() const {
   if (deopt_frame_.IsNull()) {
     return true;
   }
   // TODO(turnidge): This is conservative.  It looks at all values in
   // the deopt_frame_ even though some of them may correspond to other
   // inlined frames.
   Object& obj = Object::Handle();
   for (int i = 0; i < deopt_frame_.Length(); i++) {
     obj = deopt_frame_.At(i);
     if (obj.raw() == Symbols::OptimizedOut().raw()) {
       return false;
     }
   }
   return true;
 }
 
-
 void ActivationFrame::PrintContextMismatchError(intptr_t ctx_slot,
                                                 intptr_t frame_ctx_level,
                                                 intptr_t var_ctx_level) {
   OS::PrintErr(
       "-------------------------\n"
       "Encountered context mismatch\n"
       "\tctx_slot: %" Pd
       "\n"
       "\tframe_ctx_level: %" Pd
       "\n"
@@ skipping 28 matching lines @@
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   intptr_t num = 0;
   while ((frame != NULL)) {
     OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
     frame = iterator.NextFrame();
   }
 }
 
-
 void ActivationFrame::VariableAt(intptr_t i,
                                  String* name,
                                  TokenPosition* declaration_token_pos,
                                  TokenPosition* visible_start_token_pos,
                                  TokenPosition* visible_end_token_pos,
                                  Object* value) {
   GetDescIndices();
   ASSERT(i < desc_indices_.length());
   intptr_t desc_index = desc_indices_[i];
   ASSERT(name != NULL);
@@ skipping 11 matching lines @@
   ASSERT(value != NULL);
   const int8_t kind = var_info.kind();
   if (kind == RawLocalVarDescriptors::kStackVar) {
     *value = GetStackVar(var_info.index());
   } else {
     ASSERT(kind == RawLocalVarDescriptors::kContextVar);
     *value = GetContextVar(var_info.scope_id, var_info.index());
   }
 }
 
-
 RawObject* ActivationFrame::GetContextVar(intptr_t var_ctx_level,
                                           intptr_t ctx_slot) {
   const Context& ctx = GetSavedCurrentContext();
   ASSERT(!ctx.IsNull());
 
   // The context level at the PC/token index of this activation frame.
   intptr_t frame_ctx_level = ContextLevel();
 
   intptr_t level_diff = frame_ctx_level - var_ctx_level;
   if (level_diff == 0) {
@@ skipping 12 matching lines @@
     if (var_ctx.IsNull() || (ctx_slot < 0) ||
         (ctx_slot >= var_ctx.num_variables())) {
       PrintContextMismatchError(ctx_slot, frame_ctx_level, var_ctx_level);
     }
     ASSERT(!var_ctx.IsNull());
     ASSERT((ctx_slot >= 0) && (ctx_slot < var_ctx.num_variables()));
     return var_ctx.At(ctx_slot);
   }
 }
 
-
 RawArray* ActivationFrame::GetLocalVariables() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
   String& var_name = String::Handle();
   Object& value = Instance::Handle();
   const Array& list = Array::Handle(Array::New(2 * num_variables));
   for (intptr_t i = 0; i < num_variables; i++) {
     TokenPosition ignore;
     VariableAt(i, &var_name, &ignore, &ignore, &ignore, &value);
     list.SetAt(2 * i, var_name);
     list.SetAt((2 * i) + 1, value);
   }
   return list.raw();
 }
 
-
 RawObject* ActivationFrame::GetReceiver() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
   String& var_name = String::Handle();
   Instance& value = Instance::Handle();
   for (intptr_t i = 0; i < num_variables; i++) {
     TokenPosition ignore;
     VariableAt(i, &var_name, &ignore, &ignore, &ignore, &value);
     if (var_name.Equals(Symbols::This())) {
       return value.raw();
     }
   }
   return Symbols::OptimizedOut().raw();
 }
 
-
 static bool IsSyntheticVariableName(const String& var_name) {
   return (var_name.Length() >= 1) && (var_name.CharAt(0) == ':');
 }
 
-
 static bool IsPrivateVariableName(const String& var_name) {
   return (var_name.Length() >= 1) && (var_name.CharAt(0) == '_');
 }
 
-
 RawObject* ActivationFrame::Evaluate(const String& expr,
                                      const GrowableObjectArray& param_names,
                                      const GrowableObjectArray& param_values) {
   GetDescIndices();
   String& name = String::Handle();
   String& existing_name = String::Handle();
   Object& value = Instance::Handle();
   intptr_t num_variables = desc_indices_.length();
   for (intptr_t i = 0; i < num_variables; i++) {
     TokenPosition ignore;
@@ skipping 34 matching lines @@
     }
     const Instance& inst = Instance::Cast(receiver);
     return inst.Evaluate(method_cls, expr,
                          Array::Handle(Array::MakeFixedLength(param_names)),
                          Array::Handle(Array::MakeFixedLength(param_values)));
   }
   UNREACHABLE();
   return Object::null();
 }
 
-
 const char* ActivationFrame::ToCString() {
   const String& url = String::Handle(SourceUrl());
   intptr_t line = LineNumber();
   const char* func_name = Debugger::QualifiedFunctionName(function());
   return Thread::Current()->zone()->PrintToString(
       "[ Frame pc(0x%" Px ") fp(0x%" Px ") sp(0x%" Px
       ")\n"
       "\tfunction = %s\n"
       "\turl = %s\n"
       "\tline = %" Pd
       "\n"
       "\tcontext = %s\n"
       "\tcontext level = %" Pd " ]\n",
       pc(), fp(), sp(), func_name, url.ToCString(), line, ctx_.ToCString(),
       ContextLevel());
 }
 
-
 void ActivationFrame::PrintToJSONObject(JSONObject* jsobj, bool full) {
   if (kind_ == kRegular) {
     PrintToJSONObjectRegular(jsobj, full);
   } else if (kind_ == kAsyncCausal) {
     PrintToJSONObjectAsyncCausal(jsobj, full);
   } else if (kind_ == kAsyncSuspensionMarker) {
     PrintToJSONObjectAsyncSuspensionMarker(jsobj, full);
   } else if (kind_ == kAsyncActivation) {
     PrintToJSONObjectAsyncActivation(jsobj, full);
   } else {
     UNIMPLEMENTED();
   }
 }
 
-
 void ActivationFrame::PrintToJSONObjectRegular(JSONObject* jsobj, bool full) {
   const Script& script = Script::Handle(SourceScript());
   jsobj->AddProperty("type", "Frame");
   jsobj->AddProperty("kind", KindToCString(kind_));
   const TokenPosition pos = TokenPos().SourcePosition();
   jsobj->AddLocation(script, pos);
   jsobj->AddProperty("function", function(), !full);
   jsobj->AddProperty("code", code());
   if (full) {
     // TODO(cutch): The old "full" script usage no longer fits
@@ skipping 26 matching lines @@
         jsvar.AddProperty("declarationTokenPos", declaration_token_pos);
         // When the variable becomes visible to the scope.
         jsvar.AddProperty("scopeStartTokenPos", visible_start_token_pos);
         // When the variable stops being visible to the scope.
         jsvar.AddProperty("scopeEndTokenPos", visible_end_token_pos);
       }
     }
   }
 }
 
-
 void ActivationFrame::PrintToJSONObjectAsyncCausal(JSONObject* jsobj,
                                                    bool full) {
   jsobj->AddProperty("type", "Frame");
   jsobj->AddProperty("kind", KindToCString(kind_));
   const Script& script = Script::Handle(SourceScript());
   const TokenPosition pos = TokenPos().SourcePosition();
   jsobj->AddLocation(script, pos);
   jsobj->AddProperty("function", function(), !full);
   jsobj->AddProperty("code", code());
   if (full) {
     // TODO(cutch): The old "full" script usage no longer fits
     // in the world where we pass the script as part of the
     // location.
     jsobj->AddProperty("script", script, !full);
   }
 }
 
-
 void ActivationFrame::PrintToJSONObjectAsyncSuspensionMarker(JSONObject* jsobj,
                                                              bool full) {
   jsobj->AddProperty("type", "Frame");
   jsobj->AddProperty("kind", KindToCString(kind_));
   jsobj->AddProperty("marker", "AsynchronousSuspension");
 }
 
-
 void ActivationFrame::PrintToJSONObjectAsyncActivation(JSONObject* jsobj,
                                                        bool full) {
   jsobj->AddProperty("type", "Frame");
   jsobj->AddProperty("kind", KindToCString(kind_));
   const Script& script = Script::Handle(SourceScript());
   const TokenPosition pos = TokenPos().SourcePosition();
   jsobj->AddLocation(script, pos);
   jsobj->AddProperty("function", function(), !full);
   jsobj->AddProperty("code", code());
   if (full) {
     // TODO(cutch): The old "full" script usage no longer fits
     // in the world where we pass the script as part of the
     // location.
     jsobj->AddProperty("script", script, !full);
   }
 }
 
-
 static bool IsFunctionVisible(const Function& function) {
   return FLAG_show_invisible_frames || function.is_visible();
 }
 
-
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   if (IsFunctionVisible(frame->function())) {
     trace_.Add(frame);
   }
 }
 
-
 void DebuggerStackTrace::AddMarker(ActivationFrame::Kind marker) {
   ASSERT(marker == ActivationFrame::kAsyncSuspensionMarker);
   trace_.Add(new ActivationFrame(marker));
 }
 
-
 void DebuggerStackTrace::AddAsyncCausalFrame(uword pc, const Code& code) {
   trace_.Add(new ActivationFrame(pc, 0, 0, code, Array::Handle(), 0,
                                  ActivationFrame::kAsyncCausal));
 }
 
-
 const uint8_t kSafepointKind = RawPcDescriptors::kIcCall |
                                RawPcDescriptors::kUnoptStaticCall |
                                RawPcDescriptors::kRuntimeCall;
 
-
 CodeBreakpoint::CodeBreakpoint(const Code& code,
                                TokenPosition token_pos,
                                uword pc,
                                RawPcDescriptors::Kind kind)
     : code_(code.raw()),
       token_pos_(token_pos),
       pc_(pc),
       line_number_(-1),
       is_enabled_(false),
       bpt_location_(NULL),
       next_(NULL),
       breakpoint_kind_(kind),
 #if !defined(TARGET_ARCH_DBC)
       saved_value_(Code::null())
 #else
       saved_value_(Bytecode::kTrap),
       saved_value_fastsmi_(Bytecode::kTrap)
 #endif
 {
   ASSERT(!code.IsNull());
   ASSERT(token_pos_.IsReal());
   ASSERT(pc_ != 0);
   ASSERT((breakpoint_kind_ & kSafepointKind) != 0);
 }
 
-
 CodeBreakpoint::~CodeBreakpoint() {
   // Make sure we don't leave patched code behind.
   ASSERT(!IsEnabled());
 // Poison the data so we catch use after free errors.
 #ifdef DEBUG
   code_ = Code::null();
   pc_ = 0ul;
   bpt_location_ = NULL;
   next_ = NULL;
   breakpoint_kind_ = RawPcDescriptors::kOther;
 #endif
 }
 
-
 RawFunction* CodeBreakpoint::function() const {
   return Code::Handle(code_).function();
 }
 
-
 RawScript* CodeBreakpoint::SourceCode() {
   const Function& func = Function::Handle(this->function());
   return func.script();
 }
 
-
 RawString* CodeBreakpoint::SourceUrl() {
   const Script& script = Script::Handle(SourceCode());
   return script.url();
 }
 
-
 intptr_t CodeBreakpoint::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceCode());
     script.GetTokenLocation(token_pos_, &line_number_, NULL);
   }
   return line_number_;
 }
 
-
 void CodeBreakpoint::Enable() {
   if (!is_enabled_) {
     PatchCode();
   }
   ASSERT(is_enabled_);
 }
 
-
 void CodeBreakpoint::Disable() {
   if (is_enabled_) {
     RestoreCode();
   }
   ASSERT(!is_enabled_);
 }
 
-
 RemoteObjectCache::RemoteObjectCache(intptr_t initial_size) {
   objs_ =
       &GrowableObjectArray::ZoneHandle(GrowableObjectArray::New(initial_size));
 }
 
-
 intptr_t RemoteObjectCache::AddObject(const Object& obj) {
   intptr_t len = objs_->Length();
   for (intptr_t i = 0; i < len; i++) {
     if (objs_->At(i) == obj.raw()) {
       return i;
     }
   }
   objs_->Add(obj);
   return len;
 }
 
-
 RawObject* RemoteObjectCache::GetObj(intptr_t obj_id) const {
   ASSERT(IsValidId(obj_id));
   return objs_->At(obj_id);
 }
 
-
 Debugger::Debugger()
     : isolate_(NULL),
       isolate_id_(ILLEGAL_ISOLATE_ID),
       initialized_(false),
       next_id_(1),
       latent_locations_(NULL),
       breakpoint_locations_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       resume_frame_index_(-1),
       post_deopt_frame_index_(-1),
       ignore_breakpoints_(false),
       pause_event_(NULL),
       obj_cache_(NULL),
       stack_trace_(NULL),
       async_causal_stack_trace_(NULL),
       awaiter_stack_trace_(NULL),
       stepping_fp_(0),
       async_stepping_fp_(0),
       top_frame_awaiter_(Object::null()),
       skip_next_step_(false),
       needs_breakpoint_cleanup_(false),
       synthetic_async_breakpoint_(NULL),
       exc_pause_info_(kNoPauseOnExceptions) {}
 
-
 Debugger::~Debugger() {
   isolate_id_ = ILLEGAL_ISOLATE_ID;
   ASSERT(!IsPaused());
   ASSERT(latent_locations_ == NULL);
   ASSERT(breakpoint_locations_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
   ASSERT(stack_trace_ == NULL);
   ASSERT(async_causal_stack_trace_ == NULL);
   ASSERT(obj_cache_ == NULL);
   ASSERT(synthetic_async_breakpoint_ == NULL);
 }
 
-
 void Debugger::Shutdown() {
   // TODO(johnmccutchan): Do not create a debugger for isolates that don't need
   // them. Then, assert here that isolate_ is not one of those isolates.
   if ((isolate_ == Dart::vm_isolate()) ||
       ServiceIsolate::IsServiceIsolateDescendant(isolate_)) {
     return;
   }
   while (breakpoint_locations_ != NULL) {
     BreakpointLocation* bpt = breakpoint_locations_;
     breakpoint_locations_ = breakpoint_locations_->next();
     delete bpt;
   }
   while (latent_locations_ != NULL) {
     BreakpointLocation* bpt = latent_locations_;
     latent_locations_ = latent_locations_->next();
     delete bpt;
   }
   while (code_breakpoints_ != NULL) {
     CodeBreakpoint* bpt = code_breakpoints_;
     code_breakpoints_ = code_breakpoints_->next();
     bpt->Disable();
     delete bpt;
   }
   if (NeedsIsolateEvents()) {
     ServiceEvent event(isolate_, ServiceEvent::kIsolateExit);
     InvokeEventHandler(&event);
   }
 }
 
-
 void Debugger::OnIsolateRunnable() {}
 
-
 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();
 }
 
-
 bool Debugger::SetupStepOverAsyncSuspension(const char** error) {
   ActivationFrame* top_frame = TopDartFrame();
   if (!IsAtAsyncJump(top_frame)) {
     // Not at an async operation.
     if (error) {
       *error = "Isolate must be paused at an async suspension point";
     }
     return false;
   }
   Object& closure = Object::Handle(top_frame->GetAsyncOperation());
   ASSERT(!closure.IsNull());
   ASSERT(closure.IsInstance());
   ASSERT(Instance::Cast(closure).IsClosure());
   Breakpoint* bpt = SetBreakpointAtActivation(Instance::Cast(closure), true);
   if (bpt == NULL) {
     // Unable to set the breakpoint.
     if (error) {
       *error = "Unable to set breakpoint at async suspension point";
     }
     return false;
   }
   return true;
 }
 
-
 bool Debugger::SetResumeAction(ResumeAction action,
                                intptr_t frame_index,
                                const char** error) {
   if (error) {
     *error = NULL;
   }
   resume_frame_index_ = -1;
   switch (action) {
     case kStepInto:
     case kStepOver:
     case kStepOut:
     case kContinue:
       resume_action_ = action;
       return true;
     case kStepRewind:
       if (!CanRewindFrame(frame_index, error)) {
         return false;
       }
       resume_action_ = kStepRewind;
       resume_frame_index_ = frame_index;
       return true;
     case kStepOverAsyncSuspension:
       return SetupStepOverAsyncSuspension(error);
     default:
       UNREACHABLE();
       return false;
   }
 }
 
-
 RawFunction* Debugger::ResolveFunction(const Library& library,
                                        const String& class_name,
                                        const String& function_name) {
   ASSERT(!library.IsNull());
   ASSERT(!class_name.IsNull());
   ASSERT(!function_name.IsNull());
   if (class_name.Length() == 0) {
     return ResolveLibraryFunction(library, function_name);
   }
   const Class& cls = Class::Handle(library.LookupClass(class_name));
   Function& function = Function::Handle();
   if (!cls.IsNull()) {
     function = cls.LookupStaticFunction(function_name);
     if (function.IsNull()) {
       function = cls.LookupDynamicFunction(function_name);
     }
   }
   return function.raw();
 }
 
-
 // Deoptimize all functions in the isolate.
 // TODO(hausner): Actually we only need to deoptimize those functions
 // that inline the function that contains the newly created breakpoint.
 // We currently don't have this info so we deoptimize all functions.
 void Debugger::DeoptimizeWorld() {
   BackgroundCompiler::Stop(isolate_);
   DeoptimizeFunctionsOnStack();
   // Iterate over all classes, deoptimize functions.
   // TODO(hausner): Could possibly be combined with RemoveOptimizedCode()
   const ClassTable& class_table = *isolate_->class_table();
@@ skipping 33 matching lines @@
   const intptr_t num_closures = closures.Length();
   for (intptr_t pos = 0; pos < num_closures; pos++) {
     function ^= closures.At(pos);
     ASSERT(!function.IsNull());
     if (function.HasOptimizedCode()) {
       function.SwitchToUnoptimizedCode();
     }
   }
 }
 
-
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code,
                                             const Array& deopt_frame,
                                             intptr_t deopt_frame_offset,
                                             ActivationFrame::Kind kind) {
   ASSERT(code.ContainsInstructionAt(pc));
   ActivationFrame* activation =
       new ActivationFrame(pc, frame->fp(), frame->sp(), code, deopt_frame,
                           deopt_frame_offset, kind);
   if (FLAG_trace_debugger_stacktrace) {
     const Context& ctx = activation->GetSavedCurrentContext();
     OS::PrintErr("\tUsing saved context: %s\n", ctx.ToCString());
   }
   if (FLAG_trace_debugger_stacktrace) {
     OS::PrintErr("\tLine number: %" Pd "\n", activation->LineNumber());
   }
   return activation;
 }
 
-
 RawArray* Debugger::DeoptimizeToArray(Thread* thread,
                                       StackFrame* frame,
                                       const Code& code) {
   ASSERT(code.is_optimized());
   Isolate* isolate = thread->isolate();
   // Create the DeoptContext for this deoptimization.
   DeoptContext* deopt_context =
       new DeoptContext(frame, code, DeoptContext::kDestIsAllocated, NULL, NULL,
                        true, false /* deoptimizing_code */);
   isolate->set_deopt_context(deopt_context);
 
   deopt_context->FillDestFrame();
   deopt_context->MaterializeDeferredObjects();
   const Array& dest_frame =
       Array::Handle(thread->zone(), deopt_context->DestFrameAsArray());
 
   isolate->set_deopt_context(NULL);
   delete deopt_context;
 
   return dest_frame.raw();
 }
 
-
 DebuggerStackTrace* Debugger::CollectStackTrace() {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
   Code& code = Code::Handle(zone);
   Code& inlined_code = Code::Handle(zone);
@@ skipping 39 matching lines @@
       stack_trace->AddActivation(CollectDartFrame(isolate, it.pc(), frame,
                                                   *inlined_code, *deopt_frame,
                                                   deopt_frame_offset));
     }
   } else {
     stack_trace->AddActivation(CollectDartFrame(
         isolate, frame->pc(), frame, *code, Object::null_array(), 0));
   }
 }
 
-
 DebuggerStackTrace* Debugger::CollectAsyncCausalStackTrace() {
   if (!FLAG_causal_async_stacks) {
     return NULL;
   }
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
 
   Code& code = Code::Handle(zone);
@@ skipping 65 matching lines @@
         }
       }
     }
     // Follow the link.
     async_stack_trace = async_stack_trace.async_link();
   }
 
   return stack_trace;
 }
 
-
 DebuggerStackTrace* Debugger::CollectAwaiterReturnStackTrace() {
   if (!FLAG_async_debugger) {
     return NULL;
   }
   // Causal async stacks are not supported in the AOT runtime.
   ASSERT(!FLAG_precompiled_runtime);
 
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
@@ skipping 126 matching lines @@
         }
       }
     }
     // Follow the link.
     async_stack_trace = async_stack_trace.async_link();
   }
 
   return stack_trace;
 }
 
-
 ActivationFrame* Debugger::TopDartFrame() const {
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   while ((frame != NULL) && !frame->IsDartFrame()) {
     frame = iterator.NextFrame();
   }
   Code& code = Code::Handle(frame->LookupDartCode());
   ActivationFrame* activation = new ActivationFrame(
       frame->pc(), frame->fp(), frame->sp(), code, Object::null_array(), 0);
   return activation;
 }
 
-
 DebuggerStackTrace* Debugger::StackTrace() {
   return (stack_trace_ != NULL) ? stack_trace_ : CollectStackTrace();
 }
 
-
 DebuggerStackTrace* Debugger::CurrentStackTrace() {
   return CollectStackTrace();
 }
 
-
 DebuggerStackTrace* Debugger::AsyncCausalStackTrace() {
   return (async_causal_stack_trace_ != NULL) ? async_causal_stack_trace_
                                              : CollectAsyncCausalStackTrace();
 }
 
-
 DebuggerStackTrace* Debugger::CurrentAsyncCausalStackTrace() {
   return CollectAsyncCausalStackTrace();
 }
 
-
 DebuggerStackTrace* Debugger::AwaiterStackTrace() {
   return (awaiter_stack_trace_ != NULL) ? awaiter_stack_trace_
                                         : CollectAwaiterReturnStackTrace();
 }
 
-
 DebuggerStackTrace* Debugger::CurrentAwaiterStackTrace() {
   return CollectAwaiterReturnStackTrace();
 }
 
-
 DebuggerStackTrace* Debugger::StackTraceFrom(const class StackTrace& ex_trace) {
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   Function& function = Function::Handle();
   Code& code = Code::Handle();
 
   const uword fp = 0;
   const uword sp = 0;
   const Array& deopt_frame = Array::Handle();
   const intptr_t deopt_frame_offset = -1;
 
@@ skipping 32 matching lines @@
           ActivationFrame* activation = new ActivationFrame(
               pc, fp, sp, code, deopt_frame, deopt_frame_offset);
           stack_trace->AddActivation(activation);
         }
       }
     }
   }
   return stack_trace;
 }
 
-
 void Debugger::SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info) {
   ASSERT((pause_info == kNoPauseOnExceptions) ||
          (pause_info == kPauseOnUnhandledExceptions) ||
          (pause_info == kPauseOnAllExceptions));
   exc_pause_info_ = pause_info;
 }
 
-
 Dart_ExceptionPauseInfo Debugger::GetExceptionPauseInfo() const {
   return exc_pause_info_;
 }
 
-
 bool Debugger::ShouldPauseOnException(DebuggerStackTrace* stack_trace,
                                       const Instance& exception) {
   if (exc_pause_info_ == kNoPauseOnExceptions) {
     return false;
   }
   if (exc_pause_info_ == kPauseOnAllExceptions) {
     return true;
   }
   ASSERT(exc_pause_info_ == kPauseOnUnhandledExceptions);
   ActivationFrame* handler_frame = stack_trace->GetHandlerFrame(exception);
   if (handler_frame == NULL) {
     // Did not find an exception handler that catches this exception.
     // Note that this check is not precise, since we can't check
     // uninstantiated types, i.e. types containing type parameters.
     // Thus, we may report an exception as unhandled when in fact
     // it will be caught once we unwind the stack.
     return true;
   }
   return false;
 }
 
-
 void Debugger::PauseException(const Instance& exc) {
   if (FLAG_stress_async_stacks) {
     CollectAwaiterReturnStackTrace();
   }
   // We ignore this exception event when the VM is executing code invoked
   // by the debugger to evaluate variables values, when we see a nested
   // breakpoint or exception event, or if the debugger is not
   // interested in exception events.
   if (ignore_breakpoints_ || IsPaused() ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
@@ skipping 15 matching lines @@
   if (stack_trace->Length() > 0) {
     event.set_top_frame(stack_trace->FrameAt(0));
   }
   CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace(),
                    CollectAwaiterReturnStackTrace());
   Pause(&event);
   HandleSteppingRequest(stack_trace_);  // we may get a rewind request
   ClearCachedStackTraces();
 }
 
-
 static TokenPosition LastTokenOnLine(Zone* zone,
                                      const TokenStream& tokens,
                                      TokenPosition pos) {
   TokenStream::Iterator iter(zone, tokens, pos,
                              TokenStream::Iterator::kAllTokens);
   ASSERT(iter.IsValid());
   TokenPosition last_pos = pos;
   while ((iter.CurrentTokenKind() != Token::kNEWLINE) &&
          (iter.CurrentTokenKind() != Token::kEOS)) {
     last_pos = iter.CurrentPosition();
     iter.Advance();
   }
   return last_pos;
 }
 
-
 // Returns the best fit token position for a breakpoint.
 //
 // Takes a range of tokens [requested_token_pos, last_token_pos] and
 // an optional column (requested_column).  The range of tokens usually
 // represents one line of the program text, but can represent a larger
 // range on recursive calls.
 //
 // The best fit is found in two passes.
 //
 // The first pass finds a candidate token which:
@@ skipping 162 matching lines @@
   // find a safe point in the remaining source code of the function.
   // Since we have moved to the next line of the function, we no
   // longer are requesting a specific column number.
   if (last_token_pos < func.end_token_pos()) {
     return ResolveBreakpointPos(func, last_token_pos, func.end_token_pos(),
                                 -1 /* no column */);
   }
   return TokenPosition::kNoSource;
 }
 
-
 void Debugger::MakeCodeBreakpointAt(const Function& func,
                                     BreakpointLocation* loc) {
   ASSERT(loc->token_pos_.IsReal());
   ASSERT((loc != NULL) && loc->IsResolved());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   uword lowest_pc_offset = kUwordMax;
   RawPcDescriptors::Kind lowest_kind = RawPcDescriptors::kAnyKind;
@@ skipping 18 matching lines @@
     code_bpt =
         new CodeBreakpoint(code, loc->token_pos_, lowest_pc, lowest_kind);
     RegisterCodeBreakpoint(code_bpt);
   }
   code_bpt->set_bpt_location(loc);
   if (loc->AnyEnabled()) {
     code_bpt->Enable();
   }
 }
 
-
 void Debugger::FindCompiledFunctions(const Script& script,
                                      TokenPosition start_pos,
                                      TokenPosition end_pos,
                                      GrowableObjectArray* function_list) {
   Zone* zone = Thread::Current()->zone();
   Class& cls = Class::Handle(zone);
   Array& functions = Array::Handle(zone);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(zone);
   Function& function = Function::Handle(zone);
 
@@ skipping 52 matching lines @@
                 function_list->Add(function);
               }
             }
           }
         }
       }
     }
   }
 }
 
-
 static void SelectBestFit(Function* best_fit, Function* func) {
   if (best_fit->IsNull()) {
     *best_fit = func->raw();
   } else {
     if ((func->token_pos() > best_fit->token_pos()) &&
         ((func->end_token_pos() <= best_fit->end_token_pos()))) {
       *best_fit = func->raw();
     }
   }
 }
 
-
 // Returns true if a best fit is found. A best fit can either be a function
 // or a field. If it is a function, then the best fit function is returned
 // in |best_fit|. If a best fit is a field, it means that a latent
 // breakpoint can be set in the range |token_pos| to |last_token_pos|.
 bool Debugger::FindBestFit(const Script& script,
                            TokenPosition token_pos,
                            TokenPosition last_token_pos,
                            Function* best_fit) {
   Zone* zone = Thread::Current()->zone();
   Class& cls = Class::Handle(zone);
@@ skipping 87 matching lines @@
               (token_pos <= start && start <= last_token_pos)) {
             return true;
           }
         }
       }
     }
   }
   return false;
 }
 
-
 BreakpointLocation* Debugger::SetBreakpoint(const Script& script,
                                             TokenPosition token_pos,
                                             TokenPosition last_token_pos,
                                             intptr_t requested_line,
                                             intptr_t requested_column) {
   Function& func = Function::Handle();
   if (!FindBestFit(script, token_pos, last_token_pos, &func)) {
     return NULL;
   }
   if (!func.IsNull()) {
@@ skipping 68 matching lines @@
   BreakpointLocation* bpt =
       GetBreakpointLocation(script, token_pos, requested_column);
   if (bpt == NULL) {
     bpt = new BreakpointLocation(script, token_pos, last_token_pos,
                                  requested_line, requested_column);
     RegisterBreakpointLocation(bpt);
   }
   return bpt;
 }
 
-
 // Synchronize the enabled/disabled state of all code breakpoints
 // associated with the breakpoint location loc.
 void Debugger::SyncBreakpointLocation(BreakpointLocation* loc) {
   bool any_enabled = loc->AnyEnabled();
 
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     if (loc == cbpt->bpt_location()) {
       if (any_enabled) {
         cbpt->Enable();
       } else {
         cbpt->Disable();
       }
     }
     cbpt = cbpt->next();
   }
 }
 
-
 RawError* Debugger::OneTimeBreakAtEntry(const Function& target_function) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     SetBreakpointAtEntry(target_function, true);
     return Error::null();
   } else {
     return Thread::Current()->sticky_error();
   }
 }
 
-
 Breakpoint* Debugger::SetBreakpointAtEntry(const Function& target_function,
                                            bool single_shot) {
   ASSERT(!target_function.IsNull());
   if (!target_function.is_debuggable()) {
     return NULL;
   }
   const Script& script = Script::Handle(target_function.script());
   BreakpointLocation* bpt_location = SetBreakpoint(
       script, target_function.token_pos(), target_function.end_token_pos(), -1,
       -1 /* no requested line/col */);
   if (single_shot) {
     return bpt_location->AddSingleShot(this);
   } else {
     return bpt_location->AddRepeated(this);
   }
 }
 
-
 Breakpoint* Debugger::SetBreakpointAtActivation(const Instance& closure,
                                                 bool for_over_await) {
   if (!closure.IsClosure()) {
     return NULL;
   }
   const Function& func = Function::Handle(Closure::Cast(closure).function());
   const Script& script = Script::Handle(func.script());
   BreakpointLocation* bpt_location = SetBreakpoint(
       script, func.token_pos(), func.end_token_pos(), -1, -1 /* no line/col */);
   return bpt_location->AddPerClosure(this, closure, for_over_await);
 }
 
-
 Breakpoint* Debugger::BreakpointAtActivation(const Instance& closure) {
   if (!closure.IsClosure()) {
     return NULL;
   }
 
   BreakpointLocation* loc = breakpoint_locations_;
   while (loc != NULL) {
     Breakpoint* bpt = loc->breakpoints();
     while (bpt != NULL) {
       if (bpt->IsPerClosure()) {
         if (closure.raw() == bpt->closure()) {
           return bpt;
         }
       }
       bpt = bpt->next();
     }
     loc = loc->next();
   }
 
   return NULL;
 }
 
-
 Breakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
                                           intptr_t line_number) {
   // Prevent future tests from calling this function in the wrong
   // execution state.  If you hit this assert, consider using
   // Dart_SetBreakpoint instead.
   ASSERT(Thread::Current()->execution_state() == Thread::kThreadInVM);
 
   BreakpointLocation* loc =
       BreakpointLocationAtLineCol(script_url, line_number, -1 /* no column */);
   if (loc != NULL) {
     return loc->AddRepeated(this);
   }
   return NULL;
 }
 
-
 Breakpoint* Debugger::SetBreakpointAtLineCol(const String& script_url,
                                              intptr_t line_number,
                                              intptr_t column_number) {
   // Prevent future tests from calling this function in the wrong
   // execution state.  If you hit this assert, consider using
   // Dart_SetBreakpoint instead.
   ASSERT(Thread::Current()->execution_state() == Thread::kThreadInVM);
 
   BreakpointLocation* loc =
       BreakpointLocationAtLineCol(script_url, line_number, column_number);
   if (loc != NULL) {
     return loc->AddRepeated(this);
   }
   return NULL;
 }
 
-
 BreakpointLocation* Debugger::BreakpointLocationAtLineCol(
     const String& script_url,
     intptr_t line_number,
     intptr_t column_number) {
   Zone* zone = Thread::Current()->zone();
   Library& lib = Library::Handle(zone);
   Script& script = Script::Handle(zone);
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   const GrowableObjectArray& scripts =
@@ skipping 50 matching lines @@
                         column_number);
     first_token_idx.Next();
   }
   if ((bpt == NULL) && FLAG_verbose_debug) {
     OS::Print("No executable code at line %" Pd " in '%s'\n", line_number,
               script_url.ToCString());
   }
   return bpt;
 }
 
-
 intptr_t Debugger::CacheObject(const Object& obj) {
   ASSERT(obj_cache_ != NULL);
   return obj_cache_->AddObject(obj);
 }
 
-
 bool Debugger::IsValidObjectId(intptr_t obj_id) {
   ASSERT(obj_cache_ != NULL);
   return obj_cache_->IsValidId(obj_id);
 }
 
-
 RawObject* Debugger::GetCachedObject(intptr_t obj_id) {
   ASSERT(obj_cache_ != NULL);
   return obj_cache_->GetObj(obj_id);
 }
 
 // TODO(hausner): Merge some of this functionality with the code in
 // dart_api_impl.cc.
 RawObject* Debugger::GetInstanceField(const Class& cls,
                                       const String& field_name,
                                       const Instance& object) {
@@ skipping 10 matching lines @@
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, object);
     result = DartEntry::InvokeFunction(getter_func, args);
   } else {
     result = Thread::Current()->sticky_error();
   }
   ignore_breakpoints_ = saved_ignore_flag;
   return result.raw();
 }
 
-
 RawObject* Debugger::GetStaticField(const Class& cls,
                                     const String& field_name) {
   const Field& fld =
       Field::Handle(cls.LookupStaticFieldAllowPrivate(field_name));
   if (!fld.IsNull()) {
     // Return the value in the field if it has been initialized already.
     const Instance& value = Instance::Handle(fld.StaticValue());
     ASSERT(value.raw() != Object::transition_sentinel().raw());
     if (value.raw() != Object::sentinel().raw()) {
       return value.raw();
@@ skipping 14 matching lines @@
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     result = DartEntry::InvokeFunction(getter_func, Object::empty_array());
   } else {
     result = Thread::Current()->sticky_error();
   }
   ignore_breakpoints_ = saved_ignore_flag;
   return result.raw();
 }
 
-
 RawArray* Debugger::GetInstanceFields(const Instance& obj) {
   Class& cls = Class::Handle(obj.clazz());
   Array& fields = Array::Handle();
   Field& field = Field::Handle();
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   String& field_name = String::Handle();
   PassiveObject& field_value = PassiveObject::Handle();
   // Iterate over fields in class hierarchy to count all instance fields.
   while (!cls.IsNull()) {
     fields = cls.fields();
     for (intptr_t i = 0; i < fields.Length(); i++) {
       field ^= fields.At(i);
       if (!field.is_static()) {
         field_name = field.name();
         field_list.Add(field_name);
         field_value = GetInstanceField(cls, field_name, obj);
         field_list.Add(field_value);
       }
     }
     cls = cls.SuperClass();
   }
   return Array::MakeFixedLength(field_list);
 }
 
-
 RawArray* Debugger::GetStaticFields(const Class& cls) {
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   String& field_name = String::Handle();
   PassiveObject& field_value = PassiveObject::Handle();
   for (intptr_t i = 0; i < fields.Length(); i++) {
     field ^= fields.At(i);
     if (field.is_static()) {
       field_name = field.name();
       field_value = GetStaticField(cls, field_name);
       field_list.Add(field_name);
       field_list.Add(field_value);
     }
   }
   return Array::MakeFixedLength(field_list);
 }
 
-
 void Debugger::CollectLibraryFields(const GrowableObjectArray& field_list,
                                     const Library& lib,
                                     const String& prefix,
                                     bool include_private_fields) {
   DictionaryIterator it(lib);
   Zone* zone = Thread::Current()->zone();
   Object& entry = Object::Handle(zone);
   Field& field = Field::Handle(zone);
   String& field_name = String::Handle(zone);
   PassiveObject& field_value = PassiveObject::Handle(zone);
@@ skipping 18 matching lines @@
       }
       if (!prefix.IsNull()) {
         field_name = String::Concat(prefix, field_name);
       }
       field_list.Add(field_name);
       field_list.Add(field_value);
     }
   }
 }
 
-
 RawArray* Debugger::GetLibraryFields(const Library& lib) {
   Zone* zone = Thread::Current()->zone();
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   CollectLibraryFields(field_list, lib, String::Handle(zone), true);
   return Array::MakeFixedLength(field_list);
 }
 
-
 RawArray* Debugger::GetGlobalFields(const Library& lib) {
   Zone* zone = Thread::Current()->zone();
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New(8));
   String& prefix_name = String::Handle(zone);
   CollectLibraryFields(field_list, lib, prefix_name, true);
   Library& imported = Library::Handle(zone);
   intptr_t num_imports = lib.num_imports();
   for (intptr_t i = 0; i < num_imports; i++) {
     imported = lib.ImportLibraryAt(i);
     ASSERT(!imported.IsNull());
     CollectLibraryFields(field_list, imported, prefix_name, false);
   }
   LibraryPrefix& prefix = LibraryPrefix::Handle(zone);
   LibraryPrefixIterator it(lib);
   while (it.HasNext()) {
     prefix = it.GetNext();
     prefix_name = prefix.name();
     ASSERT(!prefix_name.IsNull());
     prefix_name = String::Concat(prefix_name, Symbols::Dot());
     for (int32_t i = 0; i < prefix.num_imports(); i++) {
       imported = prefix.GetLibrary(i);
       CollectLibraryFields(field_list, imported, prefix_name, false);
     }
   }
   return Array::MakeFixedLength(field_list);
 }
 
-
 // static
 void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   ASSERT(visitor != NULL);
   BreakpointLocation* bpt = breakpoint_locations_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
   bpt = latent_locations_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     cbpt->VisitObjectPointers(visitor);
     cbpt = cbpt->next();
   }
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&top_frame_awaiter_));
 }
 
-
 // static
 void Debugger::SetEventHandler(EventHandler* handler) {
   event_handler_ = handler;
 }
 
-
 void Debugger::Pause(ServiceEvent* event) {
   ASSERT(event->IsPause());      // Should call InvokeEventHandler instead.
   ASSERT(!ignore_breakpoints_);  // We shouldn't get here when ignoring bpts.
   ASSERT(!IsPaused());           // No recursive pausing.
   ASSERT(obj_cache_ == NULL);
 
   pause_event_ = event;
   pause_event_->UpdateTimestamp();
   obj_cache_ = new RemoteObjectCache(64);
 
@@ skipping 32 matching lines @@
     }
   }
 
   if (needs_breakpoint_cleanup_) {
     RemoveUnlinkedCodeBreakpoints();
   }
   pause_event_ = NULL;
   obj_cache_ = NULL;  // Zone allocated
 }
 
-
 void Debugger::EnterSingleStepMode() {
   ResetSteppingFramePointers();
   DeoptimizeWorld();
   isolate_->set_single_step(true);
 }
 
-
 void Debugger::ResetSteppingFramePointers() {
   stepping_fp_ = 0;
   async_stepping_fp_ = 0;
 }
 
-
 bool Debugger::SteppedForSyntheticAsyncBreakpoint() const {
   return synthetic_async_breakpoint_ != NULL;
 }
 
-
 void Debugger::CleanupSyntheticAsyncBreakpoint() {
   if (synthetic_async_breakpoint_ != NULL) {
     RemoveBreakpoint(synthetic_async_breakpoint_->id());
     synthetic_async_breakpoint_ = NULL;
   }
 }
 
-
 void Debugger::RememberTopFrameAwaiter() {
   if (!FLAG_async_debugger) {
     return;
   }
   if (stack_trace_->Length() > 0) {
     top_frame_awaiter_ = stack_trace_->FrameAt(0)->GetAsyncAwaiter();
   } else {
     top_frame_awaiter_ = Object::null();
   }
 }
 
-
 void Debugger::SetAsyncSteppingFramePointer() {
   if (!FLAG_async_debugger) {
     return;
   }
   if (stack_trace_->FrameAt(0)->function().IsAsyncClosure() ||
       stack_trace_->FrameAt(0)->function().IsAsyncGenClosure()) {
     async_stepping_fp_ = stack_trace_->FrameAt(0)->fp();
   } else {
     async_stepping_fp_ = 0;
   }
 }
 
-
 void Debugger::HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                                      bool skip_next_step) {
   ResetSteppingFramePointers();
   RememberTopFrameAwaiter();
   if (resume_action_ == kStepInto) {
     // When single stepping, we need to deoptimize because we might be
     // stepping into optimized code.  This happens in particular if
     // the isolate has been interrupted, but can happen in other cases
     // as well.  We need to deoptimize the world in case we are about
     // to call an optimized function.
@@ skipping 57 matching lines @@
       while ((frame != NULL)) {
         OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
         frame = iterator.NextFrame();
       }
     }
     RewindToFrame(resume_frame_index_);
     UNREACHABLE();
   }
 }
 
-
 void Debugger::CacheStackTraces(DebuggerStackTrace* stack_trace,
                                 DebuggerStackTrace* async_causal_stack_trace,
                                 DebuggerStackTrace* awaiter_stack_trace) {
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   ASSERT(async_causal_stack_trace_ == NULL);
   async_causal_stack_trace_ = async_causal_stack_trace;
   ASSERT(awaiter_stack_trace_ == NULL);
   awaiter_stack_trace_ = awaiter_stack_trace;
 }
 
-
 void Debugger::ClearCachedStackTraces() {
   stack_trace_ = NULL;
   async_causal_stack_trace_ = NULL;
   awaiter_stack_trace_ = NULL;
 }
 
-
 static intptr_t FindNextRewindFrameIndex(DebuggerStackTrace* stack,
                                          intptr_t frame_index) {
   for (intptr_t i = frame_index + 1; i < stack->Length(); i++) {
     ActivationFrame* frame = stack->FrameAt(i);
     if (frame->IsRewindable()) {
       return i;
     }
   }
   return -1;
 }
 
-
 // Can the top frame be rewound?
 bool Debugger::CanRewindFrame(intptr_t frame_index, const char** error) const {
   // check rewind pc is found
   DebuggerStackTrace* stack = Isolate::Current()->debugger()->StackTrace();
   intptr_t num_frames = stack->Length();
   if (frame_index < 1 || frame_index >= num_frames) {
     if (error) {
       *error = Thread::Current()->zone()->PrintToString(
           "Frame must be in bounds [1..%" Pd
           "]: "
@@ skipping 21 matching lines @@
           "optimizations. "
           "Run the vm with --no-prune-dead-locals to disallow these "
           "optimizations.",
           frame_index);
     }
     return false;
   }
   return true;
 }
 
-
 // Given a return address pc, find the "rewind" pc, which is the pc
 // before the corresponding call.
 static uword LookupRewindPc(const Code& code, uword pc) {
   ASSERT(!code.is_optimized());
   ASSERT(code.ContainsInstructionAt(pc));
 
   uword pc_offset = pc - code.PayloadStart();
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(code.pc_descriptors());
   PcDescriptors::Iterator iter(
       descriptors, RawPcDescriptors::kRewind | RawPcDescriptors::kIcCall |
                        RawPcDescriptors::kUnoptStaticCall);
   intptr_t rewind_deopt_id = -1;
   uword rewind_pc = 0;
   while (iter.MoveNext()) {
     if (iter.Kind() == RawPcDescriptors::kRewind) {
       // Remember the last rewind so we don't need to iterator twice.
       rewind_pc = code.PayloadStart() + iter.PcOffset();
       rewind_deopt_id = iter.DeoptId();
     }
     if ((pc_offset == iter.PcOffset()) && (iter.DeoptId() == rewind_deopt_id)) {
       return rewind_pc;
     }
   }
   return 0;
 }
 
-
 void Debugger::RewindToFrame(intptr_t frame_index) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Code& code = Code::Handle(zone);
   Function& function = Function::Handle(zone);
 
   // Find the requested frame.
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
@@ skipping 24 matching lines @@
           RewindToUnoptimizedFrame(frame, code);
           UNREACHABLE();
         }
         current_frame++;
       }
     }
   }
   UNIMPLEMENTED();
 }
 
-
 void Debugger::RewindToUnoptimizedFrame(StackFrame* frame, const Code& code) {
   // We will be jumping out of the debugger rather than exiting this
   // function, so prepare the debugger state.
   ClearCachedStackTraces();
   resume_action_ = kContinue;
   resume_frame_index_ = -1;
   EnterSingleStepMode();
 
   uword rewind_pc = LookupRewindPc(code, frame->pc());
   if (FLAG_trace_rewind && rewind_pc == 0) {
     OS::PrintErr("Unable to find rewind pc for pc(%" Px ")\n", frame->pc());
   }
   ASSERT(rewind_pc != 0);
   if (FLAG_trace_rewind) {
     OS::PrintErr(
         "===============================\n"
         "Rewinding to unoptimized frame:\n"
         "    rewind_pc(0x%" Px ") sp(0x%" Px ") fp(0x%" Px
         ")\n"
         "===============================\n",
         rewind_pc, frame->sp(), frame->fp());
   }
   Exceptions::JumpToFrame(Thread::Current(), rewind_pc, frame->sp(),
                           frame->fp(), true /* clear lazy deopt at target */);
   UNREACHABLE();
 }
 
-
 void Debugger::RewindToOptimizedFrame(StackFrame* frame,
                                       const Code& optimized_code,
                                       intptr_t sub_index) {
   post_deopt_frame_index_ = sub_index;
 
   // We will be jumping out of the debugger rather than exiting this
   // function, so prepare the debugger state.
   ClearCachedStackTraces();
   resume_action_ = kContinue;
   resume_frame_index_ = -1;
   EnterSingleStepMode();
 
   if (FLAG_trace_rewind) {
     OS::PrintErr(
         "===============================\n"
         "Deoptimizing frame for rewind:\n"
         "    deopt_pc(0x%" Px ") sp(0x%" Px ") fp(0x%" Px
         ")\n"
         "===============================\n",
         frame->pc(), frame->sp(), frame->fp());
   }
   Thread* thread = Thread::Current();
   thread->set_resume_pc(frame->pc());
   uword deopt_stub_pc = StubCode::DeoptForRewind_entry()->EntryPoint();
   Exceptions::JumpToFrame(thread, deopt_stub_pc, frame->sp(), frame->fp(),
                           true /* clear lazy deopt at target */);
   UNREACHABLE();
 }
 
-
 void Debugger::RewindPostDeopt() {
   intptr_t rewind_frame = post_deopt_frame_index_;
   post_deopt_frame_index_ = -1;
   if (FLAG_trace_rewind) {
     OS::PrintErr("Post deopt, jumping to frame %" Pd "\n", rewind_frame);
     OS::PrintErr(
         "-------------------------\n"
         "All frames...\n\n");
     StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                                 Thread::Current(),
@@ skipping 22 matching lines @@
       ASSERT(!code.is_optimized());
       if (current_frame == rewind_frame) {
         RewindToUnoptimizedFrame(frame, code);
         UNREACHABLE();
       }
       current_frame++;
     }
   }
 }
 
-
 // static
 bool Debugger::IsDebuggable(const Function& func) {
   if (!func.is_debuggable()) {
     return false;
   }
   const Class& cls = Class::Handle(func.Owner());
   const Library& lib = Library::Handle(cls.library());
   return lib.IsDebuggable();
 }
 
-
 void Debugger::SignalPausedEvent(ActivationFrame* top_frame, Breakpoint* bpt) {
   resume_action_ = kContinue;
   ResetSteppingFramePointers();
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
   if ((bpt != NULL) && bpt->IsSingleShot()) {
     RemoveBreakpoint(bpt->id());
     bpt = NULL;
   }
 
   ServiceEvent event(isolate_, ServiceEvent::kPauseBreakpoint);
   event.set_top_frame(top_frame);
   event.set_breakpoint(bpt);
   event.set_at_async_jump(IsAtAsyncJump(top_frame));
   Pause(&event);
 }
 
-
 bool Debugger::IsAtAsyncJump(ActivationFrame* top_frame) {
   Zone* zone = Thread::Current()->zone();
   Object& closure_or_null =
       Object::Handle(zone, top_frame->GetAsyncOperation());
   if (!closure_or_null.IsNull()) {
     ASSERT(closure_or_null.IsInstance());
     ASSERT(Instance::Cast(closure_or_null).IsClosure());
     const Script& script = Script::Handle(zone, top_frame->SourceScript());
     if (script.kind() == RawScript::kKernelTag) {
       // Are we at a yield point (previous await)?
@@ skipping 84 matching lines @@
   ASSERT(!HasActiveBreakpoint(frame->pc()));
 
   if (FLAG_verbose_debug) {
     OS::Print(">>> single step break at %s:%" Pd " (func %s token %s)\n",
               String::Handle(frame->SourceUrl()).ToCString(),
               frame->LineNumber(),
               String::Handle(frame->QualifiedFunctionName()).ToCString(),
               frame->TokenPos().ToCString());
   }
 
-
   CacheStackTraces(CollectStackTrace(), CollectAsyncCausalStackTrace(),
                    CollectAwaiterReturnStackTrace());
   if (SteppedForSyntheticAsyncBreakpoint()) {
     CleanupSyntheticAsyncBreakpoint();
   }
   SignalPausedEvent(frame, NULL);
   HandleSteppingRequest(stack_trace_);
   ClearCachedStackTraces();
 
   // 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();
 }
 
-
 RawError* Debugger::PauseBreakpoint() {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
   if (ignore_breakpoints_ || IsPaused()) {
     return Error::null();
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ActivationFrame* top_frame = stack_trace->FrameAt(0);
@@ skipping 52 matching lines @@
   // point will be at the exact same pc.  Skip it.
   HandleSteppingRequest(stack_trace_, true /* skip next step */);
   ClearCachedStackTraces();
 
   // 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();
 }
 
-
 Breakpoint* Debugger::FindHitBreakpoint(BreakpointLocation* location,
                                         ActivationFrame* top_frame) {
   if (location == NULL) {
     return NULL;
   }
   // There may be more than one applicable breakpoint at this location, but we
   // will report only one as reached. If there is a single-shot breakpoint, we
   // favor it; then a closure-specific breakpoint ; then an general breakpoint.
 
   // First check for a single-shot breakpoint.
@@ skipping 24 matching lines @@
   while (bpt != NULL) {
     if (bpt->IsRepeated()) {
       return bpt;
     }
     bpt = bpt->next();
   }
 
   return NULL;
 }
 
-
 void Debugger::PauseDeveloper(const String& msg) {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
   if (ignore_breakpoints_ || IsPaused()) {
     return;
   }
 
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace(),
                    CollectAwaiterReturnStackTrace());
   // TODO(johnmccutchan): Send |msg| to Observatory.
 
   // We are in the native call to Developer_debugger.  the developer
   // gets a better experience by not seeing this call. To accomplish
   // this, we continue execution until the call exits (step out).
   SetResumeAction(kStepOut);
   HandleSteppingRequest(stack_trace_);
   ClearCachedStackTraces();
 }
 
-
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
   isolate_ = isolate;
 
   // Use the isolate's control port as the isolate_id for debugging.
   // This port will be used as a unique ID to represent the isolate in
   // the debugger embedder api.
   isolate_id_ = isolate_->main_port();
   initialized_ = true;
 }
 
-
 void Debugger::NotifyIsolateCreated() {
   if (NeedsIsolateEvents()) {
     ServiceEvent event(isolate_, ServiceEvent::kIsolateStart);
     InvokeEventHandler(&event);
   }
 }
 
-
 // Return innermost closure contained in 'function' that contains
 // the given token position.
 RawFunction* Debugger::FindInnermostClosure(const Function& function,
                                             TokenPosition token_pos) {
   Zone* zone = Thread::Current()->zone();
   const Script& outer_origin = Script::Handle(zone, function.script());
   const GrowableObjectArray& closures = GrowableObjectArray::Handle(
       zone, Isolate::Current()->object_store()->closure_functions());
   const intptr_t num_closures = closures.Length();
   Function& closure = Function::Handle(zone);
   Function& best_fit = Function::Handle(zone);
   for (intptr_t i = 0; i < num_closures; i++) {
     closure ^= closures.At(i);
     if ((function.token_pos() < closure.token_pos()) &&
         (closure.end_token_pos() < function.end_token_pos()) &&
         (closure.token_pos() <= token_pos) &&
         (token_pos <= closure.end_token_pos()) &&
         (closure.script() == outer_origin.raw())) {
       SelectBestFit(&best_fit, &closure);
     }
   }
   return best_fit.raw();
 }
 
-
 void Debugger::NotifyCompilation(const Function& func) {
   if (breakpoint_locations_ == NULL) {
     // Return with minimal overhead if there are no breakpoints.
     return;
   }
   if (!func.is_debuggable()) {
     // Nothing to do if the function is not debuggable. If there is
     // a pending breakpoint in an inner function (that is debuggable),
     // we'll resolve the breakpoint when the inner function is compiled.
     return;
@@ skipping 72 matching lines @@
                     func.IsClosureFunction() ? "closure" : "function",
                     String::Handle(func.name()).ToCString());
           bpt = bpt->next();
         }
       }
       MakeCodeBreakpointAt(func, loc);
     }
   }
 }
 
-
 void Debugger::NotifyDoneLoading() {
   if (latent_locations_ == NULL) {
     // Common, fast path.
     return;
   }
   Zone* zone = Thread::Current()->zone();
   Library& lib = Library::Handle(zone);
   Script& script = Script::Handle(zone);
   String& url = String::Handle(zone);
   BreakpointLocation* loc = latent_locations_;
@@ skipping 95 matching lines @@
               "%" Pd " with url '%s'\n",
               bpt->id(), url.ToCString());
           bpt = bpt->next();
         }
       }
       loc = loc->next();
     }
   }
 }
 
-
 // TODO(hausner): Could potentially make this faster by checking
 // whether the call target at pc is a debugger stub.
 bool Debugger::HasActiveBreakpoint(uword pc) {
   CodeBreakpoint* bpt = GetCodeBreakpoint(pc);
   return (bpt != NULL) && (bpt->IsEnabled());
 }
 
-
 CodeBreakpoint* Debugger::GetCodeBreakpoint(uword breakpoint_address) {
   CodeBreakpoint* bpt = code_breakpoints_;
   while (bpt != NULL) {
     if (bpt->pc() == breakpoint_address) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
-
 RawCode* Debugger::GetPatchedStubAddress(uword breakpoint_address) {
   CodeBreakpoint* bpt = GetCodeBreakpoint(breakpoint_address);
   if (bpt != NULL) {
     return bpt->OrigStubAddress();
   }
   UNREACHABLE();
   return Code::null();
 }
 
-
 // Remove and delete the source breakpoint bpt and its associated
 // code breakpoints.
 void Debugger::RemoveBreakpoint(intptr_t bp_id) {
   if (RemoveBreakpointFromTheList(bp_id, &breakpoint_locations_)) {
     return;
   }
   RemoveBreakpointFromTheList(bp_id, &latent_locations_);
 }
 
-
 // Remove and delete the source breakpoint bpt and its associated
 // code breakpoints. Returns true, if breakpoint was found and removed,
 // returns false, if breakpoint was not found.
 bool Debugger::RemoveBreakpointFromTheList(intptr_t bp_id,
                                            BreakpointLocation** list) {
   BreakpointLocation* prev_loc = NULL;
   BreakpointLocation* curr_loc = *list;
   while (curr_loc != NULL) {
     Breakpoint* prev_bpt = NULL;
     Breakpoint* curr_bpt = curr_loc->breakpoints();
@@ skipping 49 matching lines @@
       prev_bpt = curr_bpt;
       curr_bpt = curr_bpt->next();
     }
     prev_loc = curr_loc;
     curr_loc = curr_loc->next();
   }
   // breakpoint with bp_id does not exist, nothing to do.
   return false;
 }
 
-
 // Unlink code breakpoints from the given breakpoint location.
 // They will later be deleted when control returns from the pause event
 // callback. Also, disable the breakpoint so it no longer fires if it
 // should be hit before it gets deleted.
 void Debugger::UnlinkCodeBreakpoints(BreakpointLocation* bpt_location) {
   ASSERT(bpt_location != NULL);
   CodeBreakpoint* curr_bpt = code_breakpoints_;
   while (curr_bpt != NULL) {
     if (curr_bpt->bpt_location() == bpt_location) {
       curr_bpt->Disable();
       curr_bpt->set_bpt_location(NULL);
       needs_breakpoint_cleanup_ = true;
     }
     curr_bpt = curr_bpt->next();
   }
 }
 
-
 // Remove and delete unlinked code breakpoints, i.e. breakpoints that
 // are not associated with a breakpoint location.
 void Debugger::RemoveUnlinkedCodeBreakpoints() {
   CodeBreakpoint* prev_bpt = NULL;
   CodeBreakpoint* curr_bpt = code_breakpoints_;
   while (curr_bpt != NULL) {
     if (curr_bpt->bpt_location() == NULL) {
       if (prev_bpt == NULL) {
         code_breakpoints_ = code_breakpoints_->next();
       } else {
         prev_bpt->set_next(curr_bpt->next());
       }
       CodeBreakpoint* temp_bpt = curr_bpt;
       curr_bpt = curr_bpt->next();
       temp_bpt->Disable();
       delete temp_bpt;
     } else {
       prev_bpt = curr_bpt;
       curr_bpt = curr_bpt->next();
     }
   }
   needs_breakpoint_cleanup_ = false;
 }
 
-
 BreakpointLocation* Debugger::GetBreakpointLocation(const Script& script,
                                                     TokenPosition token_pos,
                                                     intptr_t requested_column) {
   BreakpointLocation* bpt = breakpoint_locations_;
   while (bpt != NULL) {
     if ((bpt->script_ == script.raw()) && (bpt->token_pos_ == token_pos) &&
         (bpt->requested_column_number_ == requested_column)) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
-
 Breakpoint* Debugger::GetBreakpointById(intptr_t id) {
   Breakpoint* bpt = GetBreakpointByIdInTheList(id, breakpoint_locations_);
   if (bpt != NULL) {
     return bpt;
   }
   return GetBreakpointByIdInTheList(id, latent_locations_);
 }
 
-
 Breakpoint* Debugger::GetBreakpointByIdInTheList(intptr_t id,
                                                  BreakpointLocation* list) {
   BreakpointLocation* loc = list;
   while (loc != NULL) {
     Breakpoint* bpt = loc->breakpoints();
     while (bpt != NULL) {
       if (bpt->id() == id) {
         return bpt;
       }
       bpt = bpt->next();
     }
     loc = loc->next();
   }
   return NULL;
 }
 
-
 void Debugger::MaybeAsyncStepInto(const Closure& async_op) {
   if (FLAG_async_debugger && IsSingleStepping()) {
     // We are single stepping, set a breakpoint on the closure activation
     // and resume execution so we can hit the breakpoint.
     AsyncStepInto(async_op);
   }
 }
 
-
 void Debugger::AsyncStepInto(const Closure& async_op) {
   SetBreakpointAtActivation(async_op, true);
   Continue();
 }
 
-
 void Debugger::Continue() {
   SetResumeAction(kContinue);
   stepping_fp_ = 0;
   async_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;
     }
     bpt = bpt->next();
   }
   // No breakpoint for this location requested. Allocate new one.
   bpt = new BreakpointLocation(url, line, column);
   bpt->set_next(latent_locations_);
   latent_locations_ = bpt;
   return bpt;
 }
 
-
 void Debugger::RegisterBreakpointLocation(BreakpointLocation* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(breakpoint_locations_);
   breakpoint_locations_ = bpt;
 }
 
-
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart