Do not share local function between closurized and non-closurized enclosing

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 3907 matching lines @@
         String::ZoneHandle(String::NewSymbol("function"));
     function_name = &anonymous_function_name;
   }
   ASSERT(ident_pos >= 0);
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   intptr_t function_pos = token_index_;
 
-  // Check whether we have parsed this closure before, in a previous
+  // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
   // and register it in the current class.
+  // Note that we cannot share the same closure function between the closurized
+  // and non-closurized versions of the same parent function.
   Function& function = Function::ZoneHandle();
   bool is_new_closure = false;
+  // TODO(hausner): There could be two different closures at the given
+  // function_pos, one enclosed in a closurized function and one enclosed in the
+  // non-closurized version of this same function.
   function = current_class().LookupClosureFunction(function_pos);
-  if (function.IsNull() || (function.token_index() != function_pos)) {
+  if (function.IsNull() || (function.token_index() != function_pos) ||
+      (function.parent_function() != current_function().raw())) {
     is_new_closure = true;
     function = Function::NewClosureFunction(*function_name,
-                                          current_function(),
-                                          function_pos);
+                                            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;
@@ skipping 4292 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart