Fix breakpoints in mixin methods

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 1943 matching lines @@
   // This port will be used as a unique ID to represet the isolate in the
   // debugger wire protocol messages.
   isolate_id_ = isolate->main_port();
   initialized_ = true;
 
   // Signal isolate creation event.
   SignalIsolateEvent(Debugger::kIsolateCreated);
 }
 
 
+static RawFunction* GetOriginalFunction(const Function& func) {
+  const Class& origin_class = Class::Handle(func.origin());
+  if (origin_class.is_patch()) {
+    // Patched functions from patch classes are removed from the
+    // function array of the patch class, so we will not find an
+    // original function object.
+    return func.raw();
+  }
+  const Array& functions = Array::Handle(origin_class.functions());
+  Object& orig_func = Object::Handle();
+  for (intptr_t i = 0; i < functions.Length(); i++) {
+    orig_func = functions.At(i);
+    // Function names are symbols, so we can compare the raw pointers.
+    if (func.name() == Function::Cast(orig_func).name()) {
+      return Function::Cast(orig_func).raw();
+    }
+  }
+  // Uncommon case: not a mixin function.
+  ASSERT(!Class::Handle(func.Owner()).IsMixinApplication());
+  return func.raw();
+}
+
+
 void Debugger::NotifyCompilation(const Function& func) {
   if (src_breakpoints_ == NULL) {
     // Return with minimal overhead if there are no breakpoints.
     return;
   }
   Function& lookup_function = Function::Handle(func.raw());
   if (func.IsImplicitClosureFunction()) {
     // If the newly compiled function is a an implicit closure (a closure that
     // was formed by assigning a static or instance method to a function
     // object), we need to use the closure's parent function to see whether
     // there are any breakpoints. The parent function is the actual method on
     // which the user sets breakpoints.
     lookup_function = func.parent_function();
     ASSERT(!lookup_function.IsNull());
   }
+  if (lookup_function.Owner() != lookup_function.origin()) {
+    // This is a cloned function from a mixin class. If a breakpoint
+    // was set in this function, it is registered using the function
+    // of the origin class.
+    lookup_function = GetOriginalFunction(lookup_function);
+  }
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
     if (lookup_function.raw() == bpt->function()) {
       // Check if the breakpoint is inside a closure or local function
       // within the newly compiled function.
       Class& owner = Class::Handle(lookup_function.Owner());
       Function& closure =
           Function::Handle(owner.LookupClosureFunction(bpt->token_pos()));
       if (!closure.IsNull() && (closure.raw() != lookup_function.raw())) {
         if (FLAG_verbose_debug) {
@@ skipping 144 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart