Prevent accidental breakpoints in non-debuggable code

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 1292 matching lines @@
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   intptr_t best_fit_index = -1;
   intptr_t best_fit_pos = INT_MAX;
   uword lowest_pc = kUwordMax;
   intptr_t lowest_pc_index = -1;
   for (intptr_t i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenPos(i);
     ASSERT(desc_token_pos >= 0);
-    if (desc_token_pos < requested_token_pos) {
-      // This descriptor is before the first acceptable token position.
-      continue;
-    }
     if (IsSafePoint(desc, i)) {
+      if ((desc_token_pos < func.token_pos()) ||
+          (desc_token_pos > func.end_token_pos())) {
+        // The position is outside of the function token range. This can
+        // happen in constructors, for initializer expressions that are
+        // inlined in the field declaration.
+        ASSERT(func.IsConstructor());
+        continue;
+      }
+      if (desc_token_pos < requested_token_pos) {
+        // This descriptor is before the first acceptable token position.
+        continue;
+      }
       if (desc_token_pos < best_fit_pos) {
         // So far, this descriptor has the lowest token position after
         // the first acceptable token position.
         best_fit_pos = desc_token_pos;
         best_fit_index = i;
       }
       if (desc.PC(i) < lowest_pc) {
         // This descriptor so far has the lowest code address.
         lowest_pc = desc.PC(i);
         lowest_pc_index = i;
@@ skipping 105 matching lines @@
               }
             }
           }
         }
       }
     }
   }
 }
 
 
+static bool IsDebuggableFunctionKind(const Function& func) {
+  RawFunction::Kind kind = func.kind();
+  if ((kind == RawFunction::kImplicitGetter) ||
+      (kind == RawFunction::kImplicitSetter) ||
+      (kind == RawFunction::kImplicitStaticFinalGetter) ||
+      (kind == RawFunction::kStaticInitializer) ||
+      (kind == RawFunction::kMethodExtractor) ||
+      (kind == RawFunction::kNoSuchMethodDispatcher) ||
+      (kind == RawFunction::kInvokeFieldDispatcher) ||
+      func.IsImplicitConstructor()) {
+    return false;
+  }
+  return true;
+}
+
+
 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();
     }
   }
 }
@@ skipping 22 matching lines @@
         continue;
       }
       // Parse class definition if not done yet.
       cls.EnsureIsFinalized(isolate_);
       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());
-          if (FunctionContains(function, script, token_pos)) {
+          if (IsDebuggableFunctionKind(function) &&
+              FunctionContains(function, script, token_pos)) {
             SelectBestFit(&best_fit, &function);
           }
         }
       }
 
       closures = cls.closures();
       if (!closures.IsNull()) {
         const intptr_t num_closures = closures.Length();
         for (intptr_t pos = 0; pos < num_closures; pos++) {
           function ^= closures.At(pos);
           ASSERT(!function.IsNull());
-          if (FunctionContains(function, script, token_pos)) {
+          if (IsDebuggableFunctionKind(function) &&
+              FunctionContains(function, script, token_pos)) {
             SelectBestFit(&best_fit, &function);
           }
         }
       }
     }
   }
   return best_fit.raw();
 }
 
 
@@ skipping 376 matching lines @@
   obj_cache_ = new RemoteObjectCache(64);
 
   (*event_handler_)(event);
 
   pause_event_ = NULL;
   obj_cache_ = NULL;    // Zone allocated
 }
 
 
 bool Debugger::IsDebuggable(const Function& func) {
-  RawFunction::Kind fkind = func.kind();
-  if ((fkind == RawFunction::kImplicitGetter) ||
-      (fkind == RawFunction::kImplicitSetter) ||
-      (fkind == RawFunction::kImplicitStaticFinalGetter) ||
-      (fkind == RawFunction::kStaticInitializer) ||
-      (fkind == RawFunction::kMethodExtractor) ||
-      (fkind == RawFunction::kNoSuchMethodDispatcher) ||
-      (fkind == RawFunction::kInvokeFieldDispatcher)) {
+  if (!IsDebuggableFunctionKind(func)) {
     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,
                                  SourceBreakpoint* bpt) {
@@ skipping 374 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart