VM debugger: fix closures in mixed-in 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 "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 2008 matching lines @@
   // debugger wire protocol messages.
   isolate_id_ = isolate->main_port();
   initialized_ = true;
 
   // Signal isolate creation event.
   SignalIsolateEvent(Debugger::kIsolateCreated);
 }
 
 
 static RawFunction* GetOriginalFunction(const Function& func) {
+  if (func.IsClosureFunction()) {
+    // Local functions (closures) in mixin functions do not have
+    // an original function they were cloned from.
+    // Note: this is a problem when a breakpoint is set in a mixed-in
+    // closure. The breakpoint is linked to the closure attached to the
+    // mixin application class, not the mixin class. When the same
+    // closure is compiled for another mixin application class, we
+    // don't find the breakpoint since we'll be looking in the
+    // mixin class.
+    return func.raw();
+  }
   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++) {
@@ skipping 27 matching lines @@
   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());
+      // within the newly compiled function. Note that we must look
+      // in the owner class of the function that just got compiled
+      // (i.e. func), not the owner class of the function we use to
+      // record the breakpoint (lookup_function).
+      Class& owner = Class::Handle(func.Owner());
       Function& closure =
           Function::Handle(owner.LookupClosureFunction(bpt->token_pos()));
       if (!closure.IsNull() && (closure.raw() != lookup_function.raw())) {
         if (FLAG_verbose_debug) {
           OS::Print("Resetting pending breakpoint to function %s\n",
                     closure.ToFullyQualifiedCString());
         }
         bpt->set_function(closure);
       } else {
         if (FLAG_verbose_debug) {
@@ skipping 138 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart