clang-format runtime/vm

runtime/vm/debugger.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 16 matching lines @@
 #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,
+DEFINE_FLAG(bool,
+            show_invisible_frames,
+            false,
             "Show invisible frames in debugger stack traces");
-DEFINE_FLAG(bool, trace_debugger_stacktrace, false,
+DEFINE_FLAG(bool,
+            trace_debugger_stacktrace,
+            false,
             "Trace debugger stacktrace collection");
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
-DEFINE_FLAG(bool, steal_breakpoints, false,
+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();
-  }
+  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,
@@ skipping 124 matching lines @@
 }
 
 
 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->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
 }
 
 
 void Breakpoint::PrintJSON(JSONStream* stream) {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Breakpoint");
 
   jsobj.AddFixedServiceId("breakpoints/%" Pd "", id());
@@ skipping 11 matching lines @@
 
 
 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)
-    : pc_(pc), fp_(fp), sp_(sp),
+ActivationFrame::ActivationFrame(uword pc,
+                                 uword fp,
+                                 uword sp,
+                                 const Code& code,
+                                 const Array& deopt_frame,
+                                 intptr_t deopt_frame_offset)
+    : pc_(pc),
+      fp_(fp),
+      sp_(sp),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle(code.raw())),
       function_(Function::ZoneHandle(code.function())),
       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.raw())),
       deopt_frame_offset_(deopt_frame_offset),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
-      pc_desc_(PcDescriptors::ZoneHandle()) {
-}
+      pc_desc_(PcDescriptors::ZoneHandle()) {}
 
 
 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) ||
+  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) {
@@ skipping 112 matching lines @@
   }
   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());
+  return OS::SCreate(Thread::Current()->zone(), "%s%s%s",
+                     func_class.IsTopLevel() ? "" : class_name.ToCString(),
+                     func_class.IsTopLevel() ? "" : ".", func_name.ToCString());
 }
 
 
 // Returns true if function contains the token position in the given script.
 static bool FunctionContains(const Function& func,
                              const Script& script,
                              TokenPosition token_pos) {
   if ((func.token_pos() <= token_pos) && (token_pos <= func.end_token_pos())) {
     // Check script equality second because it allocates
     // handles as a side effect.
@@ skipping 157 matching lines @@
   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()));
+      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());
   }
 }
@@ skipping 51 matching lines @@
   if (!ctx_.IsNull()) return ctx_;
   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);
     const int8_t kind = var_info.kind();
     if (kind == RawLocalVarDescriptors::kSavedCurrentContext) {
       if (FLAG_trace_debugger_stacktrace) {
         OS::PrintErr("\tFound saved current ctx at index %d\n",
-            var_info.index());
+                     var_info.index());
       }
       ctx_ ^= GetStackVar(var_info.index());
       return ctx_;
     }
   }
   return Context::ZoneHandle(Context::null());
 }
 
 
 RawObject* ActivationFrame::GetAsyncOperation() {
@@ skipping 15 matching lines @@
   return Object::null();
 }
 
 
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const TypeArguments& no_instantiator = TypeArguments::Handle();
-  for (intptr_t frame_index = 0;
-       frame_index < Length();
-       frame_index++) {
+  for (intptr_t frame_index = 0; frame_index < Length(); frame_index++) {
     ActivationFrame* frame = FrameAt(frame_index);
     intptr_t try_index = frame->TryIndex();
     if (try_index < 0) continue;
     handlers = frame->code().exception_handlers();
     ASSERT(!handlers.IsNull());
     intptr_t num_handlers_checked = 0;
     while (try_index >= 0) {
       // Detect circles in the exception handler data.
       num_handlers_checked++;
       ASSERT(num_handlers_checked <= handlers.num_entries());
@@ skipping 106 matching lines @@
 
 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)));
+    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));
   }
 }
 
 
-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"
-               "\tvar_ctx_level: %" Pd "\n\n",
-               ctx_slot,
-               frame_ctx_level,
-               var_ctx_level);
+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"
+      "\tvar_ctx_level: %" Pd "\n\n",
+      ctx_slot, frame_ctx_level, var_ctx_level);
 
-  OS::PrintErr("-------------------------\n"
-               "Current frame:\n%s\n",
-               this->ToCString());
+  OS::PrintErr(
+      "-------------------------\n"
+      "Current frame:\n%s\n",
+      this->ToCString());
 
-  OS::PrintErr("-------------------------\n"
-               "Context contents:\n");
+  OS::PrintErr(
+      "-------------------------\n"
+      "Context contents:\n");
   const Context& ctx = GetSavedCurrentContext();
   ctx.Dump(8);
 
-  OS::PrintErr("-------------------------\n"
-               "Debugger stack trace...\n\n");
-  DebuggerStackTrace* stack =
-      Isolate::Current()->debugger()->StackTrace();
+  OS::PrintErr(
+      "-------------------------\n"
+      "Debugger stack trace...\n\n");
+  DebuggerStackTrace* stack = Isolate::Current()->debugger()->StackTrace();
   intptr_t num_frames = stack->Length();
   for (intptr_t i = 0; i < num_frames; i++) {
     ActivationFrame* frame = stack->FrameAt(i);
     OS::PrintErr("#%04" Pd " %s", i, frame->ToCString());
   }
 
-  OS::PrintErr("-------------------------\n"
-               "All frames...\n\n");
+  OS::PrintErr(
+      "-------------------------\n"
+      "All frames...\n\n");
   StackFrameIterator iterator(false);
   StackFrame* frame = iterator.NextFrame();
   intptr_t num = 0;
   while ((frame != NULL)) {
     OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
     frame = iterator.NextFrame();
   }
 }
 
 
@@ skipping 32 matching lines @@
 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) {
-    if ((ctx_slot < 0) ||
-        (ctx_slot >= ctx.num_variables())) {
+    if ((ctx_slot < 0) || (ctx_slot >= ctx.num_variables())) {
       PrintContextMismatchError(ctx_slot, frame_ctx_level, var_ctx_level);
     }
     ASSERT((ctx_slot >= 0) && (ctx_slot < ctx.num_variables()));
     return ctx.At(ctx_slot);
   } else {
     ASSERT(level_diff > 0);
     Context& var_ctx = Context::Handle(ctx.raw());
     while (level_diff > 0 && !var_ctx.IsNull()) {
       level_diff--;
       var_ctx = var_ctx.parent();
     }
-    if (var_ctx.IsNull() ||
-        (ctx_slot < 0) ||
+    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);
   }
 }
 
 
@@ skipping 55 matching lines @@
       if (IsPrivateVariableName(name)) {
         name = String::ScrubName(name);
       }
       param_names.Add(name);
       param_values.Add(value);
     }
   }
 
   if (function().is_static()) {
     const Class& cls = Class::Handle(function().Owner());
-    return cls.Evaluate(expr,
-                        Array::Handle(Array::MakeArray(param_names)),
+    return cls.Evaluate(expr, Array::Handle(Array::MakeArray(param_names)),
                         Array::Handle(Array::MakeArray(param_values)));
   } else {
     const Object& receiver = Object::Handle(GetReceiver());
     const Class& method_cls = Class::Handle(function().origin());
     ASSERT(receiver.IsInstance() || receiver.IsNull());
     if (!(receiver.IsInstance() || receiver.IsNull())) {
       return Object::null();
     }
     const Instance& inst = Instance::Cast(receiver);
-    return inst.Evaluate(method_cls,
-                         expr,
+    return inst.Evaluate(method_cls, expr,
                          Array::Handle(Array::MakeArray(param_names)),
                          Array::Handle(Array::MakeArray(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());
+  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) {
+void ActivationFrame::PrintToJSONObject(JSONObject* jsobj, bool full) {
   const Script& script = Script::Handle(SourceScript());
   jsobj->AddProperty("type", "Frame");
   TokenPosition pos = TokenPos();
   if (pos.IsSynthetic()) {
     pos = pos.FromSynthetic();
   }
   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);
   }
   {
     JSONArray jsvars(jsobj, "vars");
     const int num_vars = NumLocalVariables();
     for (intptr_t v = 0; v < num_vars; v++) {
       String& var_name = String::Handle();
       Instance& var_value = Instance::Handle();
       TokenPosition declaration_token_pos;
       TokenPosition visible_start_token_pos;
       TokenPosition visible_end_token_pos;
-      VariableAt(v,
-                 &var_name,
-                 &declaration_token_pos,
-                 &visible_start_token_pos,
-                 &visible_end_token_pos,
-                 &var_value);
+      VariableAt(v, &var_name, &declaration_token_pos, &visible_start_token_pos,
+                 &visible_end_token_pos, &var_value);
       if (var_name.raw() != Symbols::AsyncOperation().raw()) {
         JSONObject jsvar(&jsvars);
         jsvar.AddProperty("type", "BoundVariable");
         var_name = String::ScrubName(var_name);
         jsvar.AddProperty("name", var_name.ToCString());
         jsvar.AddProperty("value", var_value, !full);
         // Where was the variable declared?
         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 DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   if (FLAG_show_invisible_frames || frame->function().is_visible()) {
     trace_.Add(frame);
   }
 }
 
 
-const uint8_t kSafepointKind = RawPcDescriptors::kIcCall
-                             | RawPcDescriptors::kUnoptStaticCall
-                             | RawPcDescriptors::kRuntimeCall;
+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.
+// 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
 }
 
 
@@ skipping 34 matching lines @@
 
 void CodeBreakpoint::Disable() {
   if (is_enabled_) {
     RestoreCode();
   }
   ASSERT(!is_enabled_);
 }
 
 
 RemoteObjectCache::RemoteObjectCache(intptr_t initial_size) {
-  objs_ = &GrowableObjectArray::ZoneHandle(
-              GrowableObjectArray::New(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;
     }
   }
@@ skipping 17 matching lines @@
       breakpoint_locations_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       ignore_breakpoints_(false),
       pause_event_(NULL),
       obj_cache_(NULL),
       stack_trace_(NULL),
       stepping_fp_(0),
       skip_next_step_(false),
       synthetic_async_breakpoint_(NULL),
-      exc_pause_info_(kNoPauseOnExceptions) {
-}
+      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(obj_cache_ == NULL);
@@ skipping 24 matching lines @@
     bpt->Disable();
     delete bpt;
   }
   if (NeedsIsolateEvents()) {
     ServiceEvent event(isolate_, ServiceEvent::kIsolateExit);
     InvokeEventHandler(&event);
   }
 }
 
 
-static RawFunction* ResolveLibraryFunction(
-                        const Library& library,
-                        const String& fname) {
+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() {
@@ skipping 105 matching lines @@
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code,
                                             const Array& deopt_frame,
                                             intptr_t deopt_frame_offset) {
   ASSERT(code.ContainsInstructionAt(pc));
-  ActivationFrame* activation =
-      new ActivationFrame(pc, frame->fp(), frame->sp(), code,
-                          deopt_frame, deopt_frame_offset);
+  ActivationFrame* activation = new ActivationFrame(
+      pc, frame->fp(), frame->sp(), code, deopt_frame, deopt_frame_offset);
   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 */);
+      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());
+  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(false);
   Code& code = Code::Handle(zone);
   Code& inlined_code = Code::Handle(zone);
   Array& deopt_frame = Array::Handle(zone);
 
-  for (StackFrame* frame = iterator.NextFrame();
-       frame != NULL;
+  for (StackFrame* frame = iterator.NextFrame(); frame != NULL;
        frame = iterator.NextFrame()) {
     ASSERT(frame->IsValid());
     if (FLAG_trace_debugger_stacktrace) {
       OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n",
                    frame->ToCString());
     }
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       if (code.is_optimized() && !FLAG_precompiled_runtime) {
         deopt_frame = DeoptimizeToArray(thread, frame, code);
-        for (InlinedFunctionsIterator it(code, frame->pc());
-             !it.Done();
+        for (InlinedFunctionsIterator it(code, frame->pc()); !it.Done();
              it.Advance()) {
           inlined_code = it.code();
           if (FLAG_trace_debugger_stacktrace) {
             const Function& function =
                 Function::Handle(zone, inlined_code.function());
             ASSERT(!function.IsNull());
             OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
                          function.ToFullyQualifiedCString());
           }
           intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
-          stack_trace->AddActivation(CollectDartFrame(isolate,
-                                                      it.pc(),
-                                                      frame,
-                                                      inlined_code,
-                                                      deopt_frame,
+          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));
+        stack_trace->AddActivation(CollectDartFrame(
+            isolate, frame->pc(), frame, code, Object::null_array(), 0));
       }
     }
   }
   return stack_trace;
 }
 
 
 ActivationFrame* Debugger::TopDartFrame() const {
   StackFrameIterator iterator(false);
   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);
+  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();
@@ skipping 25 matching lines @@
         for (InlinedFunctionsIterator it(code, pc); !it.Done(); it.Advance()) {
           function = it.function();
           code = it.code();
           ASSERT(function.raw() == code.function());
           uword pc = it.pc();
           ASSERT(pc != 0);
           ASSERT(code.PayloadStart() <= pc);
           ASSERT(pc < (code.PayloadStart() + code.Size()));
 
           ActivationFrame* activation = new ActivationFrame(
-            pc, fp, sp, code, deopt_frame, deopt_frame_offset);
+              pc, fp, sp, code, deopt_frame, deopt_frame_offset);
           stack_trace->AddActivation(activation);
         }
       } else {
         ActivationFrame* activation = new ActivationFrame(
-          pc, fp, sp, code, deopt_frame, deopt_frame_offset);
+            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) ||
@@ skipping 28 matching lines @@
   }
   return false;
 }
 
 
 void Debugger::PauseException(const Instance& exc) {
   // 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() ||
+  if (ignore_breakpoints_ || IsPaused() ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
   ServiceEvent event(isolate_, ServiceEvent::kPauseException);
   event.set_exception(&exc);
   if (stack_trace->Length() > 0) {
     event.set_top_frame(stack_trace->FrameAt(0));
   }
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   Pause(&event);
   stack_trace_ = NULL;
 }
 
 
 static TokenPosition LastTokenOnLine(Zone* zone,
                                      const TokenStream& tokens,
                                      TokenPosition pos) {
-  TokenStream::Iterator iter(zone,
-                             tokens,
-                             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;
 }
@@ skipping 48 matching lines @@
 //
 // If no best fit token can be found, the search is expanded,
 // searching through the rest of the current function by calling this
 // function recursively.
 //
 // TODO(turnidge): Given that we usually call this function with a
 // token range restricted to a single line, this could be a one-pass
 // algorithm, which would be simpler.  I believe that it only needs
 // two passes to support the recursive try-the-whole-function case.
 // Rewrite this later, once there are more tests in place.
-TokenPosition Debugger::ResolveBreakpointPos(
-    const Function& func,
-    TokenPosition requested_token_pos,
-    TokenPosition last_token_pos,
-    intptr_t requested_column) {
+TokenPosition Debugger::ResolveBreakpointPos(const Function& func,
+                                             TokenPosition requested_token_pos,
+                                             TokenPosition last_token_pos,
+                                             intptr_t requested_column) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
 
   if (requested_token_pos < func.token_pos()) {
     requested_token_pos = func.token_pos();
   }
   if (last_token_pos > func.end_token_pos()) {
     last_token_pos = func.end_token_pos();
   }
 
   Zone* zone = Thread::Current()->zone();
   Script& script = Script::Handle(zone, func.script());
   Code& code = Code::Handle(zone, func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(zone, code.pc_descriptors());
 
   // First pass: find the safe point which is closest to the beginning
   // of the given token range.
   TokenPosition best_fit_pos = TokenPosition::kMaxSource;
   intptr_t best_column = INT_MAX;
   PcDescriptors::Iterator iter(desc, kSafepointKind);
   while (iter.MoveNext()) {
     const TokenPosition pos = iter.TokenPos();
-    if ((!pos.IsReal()) ||
-        (pos < requested_token_pos) ||
+    if ((!pos.IsReal()) || (pos < requested_token_pos) ||
         (pos > last_token_pos)) {
       // Token is not in the target range.
       continue;
     }
 
     intptr_t token_start_column = -1;
     if (requested_column >= 0) {
       intptr_t ignored = -1;
       intptr_t token_len = -1;
       // TODO(turnidge): GetTokenLocation is a very expensive
@@ skipping 25 matching lines @@
   if (best_fit_pos != TokenPosition::kMaxSource) {
     const Script& script = Script::Handle(zone, func.script());
     const TokenStream& tokens = TokenStream::Handle(zone, script.tokens());
     const TokenPosition begin_pos = best_fit_pos;
     const TokenPosition end_of_line_pos =
         LastTokenOnLine(zone, tokens, begin_pos);
     uword lowest_pc_offset = kUwordMax;
     PcDescriptors::Iterator iter(desc, kSafepointKind);
     while (iter.MoveNext()) {
       const TokenPosition pos = iter.TokenPos();
-      if (!pos.IsReal() ||
-          (pos < begin_pos) ||
-          (pos > end_of_line_pos)) {
+      if (!pos.IsReal() || (pos < begin_pos) || (pos > end_of_line_pos)) {
         // Token is not on same line as best fit.
         continue;
       }
 
       if (requested_column >= 0) {
         intptr_t ignored = -1;
         intptr_t token_start_column = -1;
         // We look for other tokens at the best column in case there
         // is more than one token at the same column offset.
         script.GetTokenLocation(pos, &ignored, &token_start_column);
@@ skipping 44 matching lines @@
       }
     }
   }
   if (lowest_pc_offset == kUwordMax) {
     return;
   }
   uword lowest_pc = code.PayloadStart() + lowest_pc_offset;
   CodeBreakpoint* code_bpt = GetCodeBreakpoint(lowest_pc);
   if (code_bpt == NULL) {
     // No code breakpoint for this code exists; create one.
-    code_bpt = new CodeBreakpoint(code, loc->token_pos_,
-                                  lowest_pc, lowest_kind);
+    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);
 
   closures = isolate_->object_store()->closure_functions();
   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.token_pos() == start_pos)
-        && (function.end_token_pos() == end_pos)
-        && (function.script() == script.raw())) {
+    if ((function.token_pos() == start_pos) &&
+        (function.end_token_pos() == end_pos) &&
+        (function.script() == script.raw())) {
       if (function.HasCode() && function.is_debuggable()) {
         function_list->Add(function);
       }
       if (function.HasImplicitClosureFunction()) {
         function = function.ImplicitClosureFunction();
         if (function.HasCode() && function.is_debuggable()) {
           function_list->Add(function);
         }
       }
     }
@@ skipping 15 matching lines @@
       // the class is defined in a differenct 'script'. There could
       // be mixin functions from the given script in this class.
       functions = cls.functions();
       if (!functions.IsNull()) {
         const intptr_t num_functions = functions.Length();
         for (intptr_t pos = 0; pos < num_functions; pos++) {
           function ^= functions.At(pos);
           ASSERT(!function.IsNull());
           // Check token position first to avoid unnecessary calls
           // to script() which allocates handles.
-          if ((function.token_pos() == start_pos)
-              && (function.end_token_pos() == end_pos)
-              && (function.script() == script.raw())) {
+          if ((function.token_pos() == start_pos) &&
+              (function.end_token_pos() == end_pos) &&
+              (function.script() == script.raw())) {
             if (function.HasCode() && function.is_debuggable()) {
               function_list->Add(function);
             }
             if (function.HasImplicitClosureFunction()) {
               function = function.ImplicitClosureFunction();
               if (function.HasCode() && function.is_debuggable()) {
                 function_list->Add(function);
               }
             }
           }
@@ skipping 85 matching lines @@
   if (func.IsNull()) {
     return NULL;
   }
   // There may be more than one function object for a given function
   // in source code. There may be implicit closure functions, and
   // there may be copies of mixin functions. Collect all compiled
   // functions whose source code range matches exactly the best fit
   // function we found.
   GrowableObjectArray& functions =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
-  FindCompiledFunctions(script,
-                        func.token_pos(),
-                        func.end_token_pos(),
+  FindCompiledFunctions(script, func.token_pos(), func.end_token_pos(),
                         &functions);
 
   if (functions.Length() > 0) {
     // One or more function object containing this breakpoint location
     // have already been compiled. We can resolve the breakpoint now.
     DeoptimizeWorld();
     func ^= functions.At(0);
     TokenPosition breakpoint_pos =
         ResolveBreakpointPos(func, token_pos, last_token_pos, requested_column);
     if (breakpoint_pos.IsReal()) {
@@ skipping 12 matching lines @@
       const intptr_t num_functions = functions.Length();
       for (intptr_t i = 0; i < num_functions; i++) {
         func ^= functions.At(i);
         ASSERT(func.HasCode());
         MakeCodeBreakpointAt(func, bpt);
       }
       if (FLAG_verbose_debug) {
         intptr_t line_number;
         intptr_t column_number;
         script.GetTokenLocation(breakpoint_pos, &line_number, &column_number);
-        OS::Print("Resolved BP for "
-                  "function '%s' at line %" Pd " col %" Pd "\n",
-                  func.ToFullyQualifiedCString(),
-                  line_number, column_number);
+        OS::Print(
+            "Resolved BP for "
+            "function '%s' at line %" Pd " col %" Pd "\n",
+            func.ToFullyQualifiedCString(), line_number, column_number);
       }
       return bpt;
     }
   }
   // There is no compiled function at this token position.
   // Register an unresolved breakpoint.
   if (FLAG_verbose_debug && !func.IsNull()) {
     intptr_t line_number;
     intptr_t column_number;
     script.GetTokenLocation(token_pos, &line_number, &column_number);
-    OS::Print("Registering pending breakpoint for "
-              "uncompiled function '%s' at line %" Pd " col %" Pd "\n",
-              func.ToFullyQualifiedCString(),
-              line_number, column_number);
+    OS::Print(
+        "Registering pending breakpoint for "
+        "uncompiled function '%s' at line %" Pd " col %" Pd "\n",
+        func.ToFullyQualifiedCString(), line_number, column_number);
   }
   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;
 }
@@ skipping 29 matching lines @@
 }
 
 
 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 */);
+  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) {
+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 */);
+  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_;
@@ skipping 31 matching lines @@
 
 
 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);
+  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 =
-    GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       scripts.Add(script);
     }
   }
   if (scripts.Length() == 0) {
     // No script found with given url. Create a latent breakpoint which
     // will be set if the url is loaded later.
-    BreakpointLocation* latent_bpt = GetLatentBreakpoint(script_url,
-                                                         line_number,
-                                                         column_number);
+    BreakpointLocation* latent_bpt =
+        GetLatentBreakpoint(script_url, line_number, column_number);
     if (FLAG_verbose_debug) {
-      OS::Print("Set latent breakpoint in url '%s' at "
-                "line %" Pd " col %" Pd "\n",
-                script_url.ToCString(),
-                line_number, column_number);
+      OS::Print(
+          "Set latent breakpoint in url '%s' at "
+          "line %" Pd " col %" Pd "\n",
+          script_url.ToCString(), line_number, column_number);
     }
     return latent_bpt;
   }
   if (scripts.Length() > 1) {
     if (FLAG_verbose_debug) {
       OS::Print("Multiple scripts match url '%s'\n", script_url.ToCString());
     }
     return NULL;
   }
   script ^= scripts.At(0);
   TokenPosition first_token_idx, last_token_idx;
   script.TokenRangeAtLine(line_number, &first_token_idx, &last_token_idx);
   if (!first_token_idx.IsReal()) {
     // Script does not contain the given line number.
     if (FLAG_verbose_debug) {
       OS::Print("Script '%s' does not contain line number %" Pd "\n",
                 script_url.ToCString(), line_number);
     }
     return NULL;
   } else if (!last_token_idx.IsReal()) {
     // Line does not contain any tokens.
     if (FLAG_verbose_debug) {
-      OS::Print("No executable code at line %" Pd " in '%s'\n",
-                line_number, script_url.ToCString());
+      OS::Print("No executable code at line %" Pd " in '%s'\n", line_number,
+                script_url.ToCString());
     }
     return NULL;
   }
 
   BreakpointLocation* bpt = NULL;
   ASSERT(first_token_idx <= last_token_idx);
   while ((bpt == NULL) && (first_token_idx <= last_token_idx)) {
-    bpt = SetBreakpoint(script, first_token_idx, last_token_idx,
-                        line_number, column_number);
+    bpt = SetBreakpoint(script, first_token_idx, last_token_idx, line_number,
+                        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());
+    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);
 }
 
@@ skipping 229 matching lines @@
   pause_event_ = event;
   pause_event_->UpdateTimestamp();
   obj_cache_ = new RemoteObjectCache(64);
 
   // We are about to invoke the debugger's event handler. Disable
   // interrupts for this thread while waiting for debug commands over
   // the service protocol.
   {
     Thread* thread = Thread::Current();
     DisableThreadInterruptsScope dtis(thread);
-    TimelineDurationScope tds(thread,
-                              Timeline::GetDebuggerStream(),
+    TimelineDurationScope tds(thread, Timeline::GetDebuggerStream(),
                               "Debugger Pause");
 
     // Send the pause event.
     Service::HandleEvent(event);
 
     {
       TransitionVMToNative transition(Thread::Current());
       if (FLAG_steal_breakpoints || (event_handler_ == NULL)) {
         // We allow the embedder's default breakpoint handler to be overridden.
         isolate_->PauseEventHandler();
       } else if (event_handler_ != NULL) {
         (*event_handler_)(event);
       }
     }
 
     // Notify the service that we have resumed.
-    const Error& error =
-        Error::Handle(Thread::Current()->sticky_error());
-    ASSERT(error.IsNull() ||
-           error.IsUnwindError() ||
+    const Error& error = Error::Handle(Thread::Current()->sticky_error());
+    ASSERT(error.IsNull() || error.IsUnwindError() ||
            error.IsUnhandledException());
 
     // Only send a resume event when the isolate is not unwinding.
     if (!error.IsUnwindError()) {
       ServiceEvent resume_event(event->isolate(), ServiceEvent::kResume);
       resume_event.set_top_frame(event->top_frame());
       Service::HandleEvent(&resume_event);
     }
   }
 
   pause_event_ = NULL;
-  obj_cache_ = NULL;    // Zone allocated
+  obj_cache_ = NULL;  // Zone allocated
 }
 
 
 void Debugger::EnterSingleStepMode() {
   stepping_fp_ = 0;
   DeoptimizeWorld();
   isolate_->set_single_step(true);
 }
 
 
@@ skipping 43 matching lines @@
 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) {
+void Debugger::SignalPausedEvent(ActivationFrame* top_frame, Breakpoint* bpt) {
   resume_action_ = kContinue;
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
-  if ((bpt != NULL) && bpt->IsSingleShot())  {
+  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);
 }
@@ skipping 155 matching lines @@
   }
 
   if (bpt_hit->is_synthetic_async()) {
     DebuggerStackTrace* stack_trace = CollectStackTrace();
     ASSERT(stack_trace->Length() > 0);
     ASSERT(stack_trace_ == NULL);
     stack_trace_ = stack_trace;
 
     // Hit a synthetic async breakpoint.
     if (FLAG_verbose_debug) {
-      OS::Print(">>> hit synthetic breakpoint at %s:%" Pd " "
+      OS::Print(">>> hit synthetic breakpoint at %s:%" Pd
+                " "
                 "(token %s) (address %#" Px ")\n",
                 String::Handle(cbpt->SourceUrl()).ToCString(),
-                cbpt->LineNumber(),
-                cbpt->token_pos().ToCString(),
+                cbpt->LineNumber(), cbpt->token_pos().ToCString(),
                 top_frame->pc());
     }
 
     ASSERT(synthetic_async_breakpoint_ == NULL);
     synthetic_async_breakpoint_ = bpt_hit;
     bpt_hit = NULL;
 
     // We are at the entry of an async function.
     // We issue a step over to resume at the point after the await statement.
     SetStepOver();
     // When we single step from a user breakpoint, our next stepping
     // point will be at the exact same pc.  Skip it.
     HandleSteppingRequest(stack_trace_, true /* skip next step */);
     stack_trace_ = NULL;
     return Error::null();
   }
 
   if (FLAG_verbose_debug) {
-    OS::Print(">>> hit %s breakpoint at %s:%" Pd " "
+    OS::Print(">>> hit %s breakpoint at %s:%" Pd
+              " "
               "(token %s) (address %#" Px ")\n",
               cbpt->IsInternal() ? "internal" : "user",
-              String::Handle(cbpt->SourceUrl()).ToCString(),
-              cbpt->LineNumber(),
-              cbpt->token_pos().ToCString(),
-              top_frame->pc());
+              String::Handle(cbpt->SourceUrl()).ToCString(), cbpt->LineNumber(),
+              cbpt->token_pos().ToCString(), top_frame->pc());
   }
 
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   SignalPausedEvent(top_frame, bpt_hit);
   // When we single step from a user breakpoint, our next stepping
   // point will be at the exact same pc.  Skip it.
   HandleSteppingRequest(stack_trace_, true /* skip next step */);
   stack_trace_ = NULL;
   if (cbpt->IsInternal()) {
@@ skipping 53 matching lines @@
   }
 }
 
 
 // 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 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())) {
@@ skipping 12 matching lines @@
   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;
   }
   // Iterate over all source breakpoints to check whether breakpoints
   // need to be set in the newly compiled function.
   Zone* zone = Thread::Current()->zone();
   Script& script = Script::Handle(zone);
-  for (BreakpointLocation* loc = breakpoint_locations_;
-      loc != NULL;
-      loc = loc->next()) {
+  for (BreakpointLocation* loc = breakpoint_locations_; loc != NULL;
+       loc = loc->next()) {
     script = loc->script();
     if (FunctionContains(func, script, loc->token_pos())) {
       Function& inner_function = Function::Handle(zone);
       inner_function = FindInnermostClosure(func, loc->token_pos());
       if (!inner_function.IsNull()) {
         // The local function of a function we just compiled cannot
         // be compiled already.
         ASSERT(!inner_function.HasCode());
         if (FLAG_verbose_debug) {
           OS::Print("Pending BP remains unresolved in inner function '%s'\n",
@@ skipping 20 matching lines @@
                       String::Handle(func.name()).ToCString());
           }
           continue;
         }
         TokenPosition requested_pos = loc->token_pos();
         TokenPosition requested_end_pos = loc->end_token_pos();
         loc->SetResolved(func, bp_pos);
         Breakpoint* bpt = loc->breakpoints();
         while (bpt != NULL) {
           if (FLAG_verbose_debug) {
-            OS::Print("Resolved BP %" Pd " to pos %s, "
-                      "line %" Pd " col %" Pd ", "
+            OS::Print("Resolved BP %" Pd
+                      " to pos %s, "
+                      "line %" Pd " col %" Pd
+                      ", "
                       "function '%s' (requested range %s-%s, "
                       "requested col %" Pd ")\n",
-                      bpt->id(),
-                      loc->token_pos().ToCString(),
-                      loc->LineNumber(),
-                      loc->ColumnNumber(),
-                      func.ToFullyQualifiedCString(),
-                      requested_pos.ToCString(),
+                      bpt->id(), loc->token_pos().ToCString(),
+                      loc->LineNumber(), loc->ColumnNumber(),
+                      func.ToFullyQualifiedCString(), requested_pos.ToCString(),
                       requested_end_pos.ToCString(),
                       loc->requested_column_number());
           }
           SendBreakpointEvent(ServiceEvent::kBreakpointResolved, bpt);
           bpt = bpt->next();
         }
       }
       ASSERT(loc->IsResolved());
       if (FLAG_verbose_debug) {
         Breakpoint* bpt = loc->breakpoints();
         while (bpt != NULL) {
-          OS::Print("Setting breakpoint %" Pd " at line %" Pd " col %" Pd ""
+          OS::Print("Setting breakpoint %" Pd " at line %" Pd " col %" Pd
+                    ""
                     " for %s '%s'\n",
-                    bpt->id(),
-                    loc->LineNumber(),
-                    loc->ColumnNumber(),
+                    bpt->id(), loc->LineNumber(), loc->ColumnNumber(),
                     func.IsClosureFunction() ? "closure" : "function",
                     String::Handle(func.name()).ToCString());
           bpt = bpt->next();
         }
       }
       MakeCodeBreakpointAt(func, loc);
     }
   }
 }
 
@@ skipping 34 matching lines @@
         intptr_t column_number = matched_loc->requested_column_number();
         ASSERT(line_number >= 0);
         TokenPosition first_token_pos, last_token_pos;
         script.TokenRangeAtLine(line_number, &first_token_pos, &last_token_pos);
         if (!first_token_pos.IsDebugPause() || !last_token_pos.IsDebugPause()) {
           // Script does not contain the given line number or there are no
           // tokens on the line. Drop the breakpoint silently.
           Breakpoint* bpt = matched_loc->breakpoints();
           while (bpt != NULL) {
             if (FLAG_verbose_debug) {
-              OS::Print("No code found at line %" Pd ": "
+              OS::Print("No code found at line %" Pd
+                        ": "
                         "dropping latent breakpoint %" Pd " in '%s'\n",
-                        line_number,
-                        bpt->id(),
-                        url.ToCString());
+                        line_number, bpt->id(), url.ToCString());
             }
             Breakpoint* prev = bpt;
             bpt = bpt->next();
             delete prev;
           }
           delete matched_loc;
         } else {
           // We don't expect to already have a breakpoint for this location.
           // If there is one, assert in debug build but silently drop
           // the latent breakpoint in release build.
           BreakpointLocation* existing_loc =
               GetBreakpointLocation(script, first_token_pos, column_number);
           ASSERT(existing_loc == NULL);
           if (existing_loc == NULL) {
             // Create and register a new source breakpoint for the
             // latent breakpoint.
             BreakpointLocation* unresolved_loc =
-                new BreakpointLocation(script,
-                                       first_token_pos, last_token_pos,
+                new BreakpointLocation(script, first_token_pos, last_token_pos,
                                        line_number, column_number);
             RegisterBreakpointLocation(unresolved_loc);
 
             // Move breakpoints over.
             Breakpoint* bpt = matched_loc->breakpoints();
             unresolved_loc->set_breakpoints(bpt);
             matched_loc->set_breakpoints(NULL);
             while (bpt != NULL) {
               bpt->set_bpt_location(unresolved_loc);
               if (FLAG_verbose_debug) {
-                OS::Print("Converted latent breakpoint "
-                          "%" Pd " in '%s' at line %" Pd " col %" Pd "\n",
-                          bpt->id(),
-                          url.ToCString(),
-                          line_number, column_number);
+                OS::Print(
+                    "Converted latent breakpoint "
+                    "%" Pd " in '%s' at line %" Pd " col %" Pd "\n",
+                    bpt->id(), url.ToCString(), line_number, column_number);
               }
               bpt = bpt->next();
             }
             SyncBreakpointLocation(unresolved_loc);
           }
           delete matched_loc;
           // Break out of the iteration over loaded libraries. If the
           // same url has been loaded into more than one library, we
           // only set a breakpoint in the first one.
           // TODO(hausner): There is one possible pitfall here.
           // If the user sets a latent breakpoint using a partial url that
           // ends up matching more than one script, the breakpoint might
           // get set in the wrong script.
           // It would be better if we could warn the user if multiple
           // scripts are matching.
           break;
         }
       }
     }
     if (!found_match) {
       // No matching url found in any of the libraries.
       if (FLAG_verbose_debug) {
         Breakpoint* bpt = loc->breakpoints();
         while (bpt != NULL) {
-          OS::Print("No match found for latent breakpoint id "
-                    "%" Pd " with url '%s'\n",
-                    bpt->id(),
-                    url.ToCString());
+          OS::Print(
+              "No match found for latent breakpoint id "
+              "%" Pd " with url '%s'\n",
+              bpt->id(), url.ToCString());
           bpt = bpt->next();
         }
       }
       loc = loc->next();
     }
   }
 }
 
 
 // TODO(hausner): Could potentially make this faster by checking
@@ skipping 117 matching lines @@
     }
   }
 }
 
 
 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) &&
+    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) {
@@ skipping 12 matching lines @@
 }
 
 
 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) &&
+    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