Fix parent function of deeply nested closures

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 236 matching lines @@
 Parser::Parser(const Script& script,
                const Library& library)
     : script_(script),
       tokens_(TokenStream::Handle(script.tokens())),
       token_index_(0),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(Function::Handle()),
+      innermost_function_(Function::Handle()),
       current_class_(Class::Handle()),
       library_(library),
       try_blocks_list_(NULL),
       expression_temp_(NULL) {
   ASSERT(!tokens_.IsNull());
   ASSERT(!library.IsNull());
   SetPosition(0);
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                const Function& function,
                intptr_t token_index)
     : script_(script),
       tokens_(TokenStream::Handle(script.tokens())),
       token_index_(0),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(function),
+      innermost_function_(Function::Handle(function.raw())),
       current_class_(Class::Handle(current_function_.owner())),
       library_(Library::Handle(current_class_.library())),
       try_blocks_list_(NULL),
       expression_temp_(NULL)  {
   ASSERT(!tokens_.IsNull());
   ASSERT(!function.IsNull());
   SetPosition(token_index);
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
   return current_value;
 }
 
 
 const Function& Parser::current_function() const {
   return current_function_;
 }
 
 
+const Function& Parser::innermost_function() const {
+  return innermost_function_;
+}
+
+
 const Class& Parser::current_class() const {
   return current_class_;
 }
 
 
 void Parser::set_current_class(const Class& value) {
   current_class_ = value.raw();
 }
 
 
@@ skipping 1754 matching lines @@
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func,
                                 Array& default_parameter_values) {
   TRACE_PARSER("ParseFunc");
+  Function& saved_innermost_function =
+      Function::Handle(innermost_function().raw());
+  innermost_function_ = func.raw();
+
   if (func.IsConstructor()) {
-    return ParseConstructor(func, default_parameter_values);
+    SequenceNode* statements = ParseConstructor(func, default_parameter_values);
+    innermost_function_ = saved_innermost_function.raw();
+    return statements;
   }
 
   ASSERT(!func.IsConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
   ParamList params;
   // Static functions do not have a receiver.
   // An instance closure may capture and access the receiver, but via the
   // context and not via the first formal parameter.
   // The first parameter of a factory is the AbstractTypeArguments vector of the
@@ skipping 54 matching lines @@
     AstNode* expr = ParseExpr(kAllowConst);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
   } else {
     UnexpectedToken();
   }
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
+  innermost_function_ = saved_innermost_function.raw();
   return CloseBlock();
 }
 
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
   }
 }
 
@@ skipping 2026 matching lines @@
   // 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) ||
-      (function.parent_function() != current_function().raw())) {
+      (function.parent_function() != innermost_function().raw())) {
     is_new_closure = true;
     function = Function::NewClosureFunction(*function_name,
-                                            current_function(),
+                                            innermost_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.
 
@@ skipping 1165 matching lines @@
 
     // Add this individual catch handler to the catch handlers list.
     current_block_->statements->Add(catch_clause);
   }
   catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
 
   // Finally parse the 'finally' block.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
-    current_function_.set_is_optimizable(false);
+    current_function().set_is_optimizable(false);
     ConsumeToken();  // Consume the 'finally'.
     const intptr_t finally_pos = token_index_;
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline =
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
       InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
                                                         finally_block,
@@ skipping 3187 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart