Fix setting breakpoints in parts of a library.

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 2692 matching lines @@
 // 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);
+  Library& lib = Library::Handle(zone, script.FindLibrary());
+  ASSERT(!lib.IsNull());
   const GrowableObjectArray& closures = GrowableObjectArray::Handle(
       zone, isolate_->object_store()->closure_functions());
   Array& functions = Array::Handle(zone);
   Function& function = Function::Handle(zone);
   Array& fields = Array::Handle(zone);
   Field& field = Field::Handle(zone);
   Error& error = Error::Handle(zone);
 
   const intptr_t num_closures = closures.Length();
   for (intptr_t i = 0; i < num_closures; i++) {
@@ skipping 10 matching lines @@
     return true;
   }
 
   const ClassTable& class_table = *isolate_->class_table();
   const intptr_t num_classes = class_table.NumCids();
   for (intptr_t i = 1; i < num_classes; i++) {
     if (!class_table.HasValidClassAt(i)) {
       continue;
     }
     cls = class_table.At(i);
-    if (cls.script() != script.raw()) {
+    // This class is relevant to us only if it belongs to the
+    // library to which |script| belongs.
+    if (cls.library() != lib.raw()) {
       continue;
     }
     // Parse class definition if not done yet.
     error = cls.EnsureIsFinalized(Thread::Current());
     if (!error.IsNull()) {
       // Ignore functions in this class.
       // TODO(hausner): Should we propagate this error? How?
       // EnsureIsFinalized only returns an error object if there
       // is no longjump base on the stack.
       continue;
@@ skipping 25 matching lines @@
     // function literal initializer) has already been initialized, then
     // it would have been found above in the object store as a closure.
     fields = cls.fields();
     if (!fields.IsNull()) {
       const intptr_t num_fields = fields.Length();
       for (intptr_t pos = 0; pos < num_fields; pos++) {
         TokenPosition start;
         TokenPosition end;
         field ^= fields.At(pos);
         ASSERT(!field.IsNull());
+        if (field.Script() != script.raw()) {
+          // The field should be defined in the script we want to set
+          // the breakpoint in.
+          continue;
+        }
         if (Parser::FieldHasFunctionLiteralInitializer(field, &start, &end)) {
           if ((start <= token_pos && token_pos <= end) ||
               (token_pos <= start && start <= last_token_pos)) {
             return true;
           }
         }
       }
     }
   }
   return false;
@@ skipping 1730 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart