Properly recognize closures when setting breakpoints

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 3889 matching lines @@
     }
     const String& anonymous_function_name =
         String::ZoneHandle(String::NewSymbol("function"));
     function_name = &anonymous_function_name;
   }
   ASSERT(ident_pos >= 0);
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
-  Function& function = Function::ZoneHandle(
-      Function::NewClosureFunction(*function_name,
-                                   current_function(),
-                                   token_index_));
-  function.set_result_type(result_type);
+  intptr_t function_pos = token_index_;
+
+  // Check whether we have parsed this closure before, in a previous
+  // compilation. If so, reuse the function object, else create a new one
+  // and register it in the current class.
+  Function& function = Function::ZoneHandle();
+  bool is_new_closure = false;
+  function = current_class().LookupClosureFunction(function_pos);
+  if (function.IsNull() || (function.token_index() != function_pos)) {
+    is_new_closure = true;
+    function = Function::NewClosureFunction(*function_name,
+                                          current_function(),
+                                          function_pos);
+    function.set_result_type(result_type);
+    current_class().AddClosureFunction(function);
+  }
 
   // The function type does not need to be determined at compile time, unless
   // the closure is assigned to a function variable and type checks are enabled.
   // At run time, the function type is derived from the signature class of the
   // closure function and from the type arguments of the instantiator.
 
   LocalVariable* function_variable = NULL;
   Type& function_type = Type::ZoneHandle();
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
@@ skipping 18 matching lines @@
     if (!current_block_->scope->AddVariable(function_variable)) {
       ErrorMsg(ident_pos, "identifier '%s' already defined",
                function_variable->name().ToCString());
     }
   }
 
   // Parse the local function.
   Array& default_parameter_values = Array::Handle();
   SequenceNode* statements = Parser::ParseFunc(function,
                                                default_parameter_values);
+  ASSERT(is_new_closure || (function.end_token_index() == token_index_));
+  function.set_end_token_index(token_index_);
 
   // Now that the local function has formal parameters, lookup the signature
   // class in the current library (but not in its imports) and only create a new
   // canonical signature class if it does not exist yet.
   const String& signature = String::Handle(function.Signature());
   Class& signature_class = Class::ZoneHandle(
       library_.LookupLocalClass(signature));
+
   if (signature_class.IsNull()) {
+    // If we don't have a signature class yet, this must be a closure we
+    // have not parsed before.
+    ASSERT(is_new_closure);
     signature_class = Class::NewSignatureClass(signature,
                                                function,
                                                script_);
     // Record the function signature class in the current library.
     library_.AddClass(signature_class);
-  } else {
+  } else if (is_new_closure) {
     function.set_signature_class(signature_class);
   }
   ASSERT(function.signature_class() == signature_class.raw());
-  // Local functions are not registered in the enclosing class, which is already
-  // finalized.
+
+  // Local functions are registered in the enclosing class, but
+  // ignored during class finalization. The enclosing class has
+  // already been finalized.
   ASSERT(current_class().is_finalized());
 
   // Make sure that the instantiator is captured.
   if ((signature_class.NumTypeParameters() > 0) &&
       (current_block_->scope->function_level() > 0)) {
     CaptureReceiver();
   }
 
   if (variable_name != NULL) {
     // Patch the function type now that the signature is known.
@@ skipping 4224 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart