Fix parent function of deeply nested closures

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "vm/ast.h"
@@ skipping 121 matching lines @@
                                          const Script& script,
                                          intptr_t token_index,
                                          const char* message_header,
                                          const char* format,
                                          va_list args);
 
  private:
   struct Block;
   class TryBlocks;
 
-  // The function being parsed.
+  // The function for which we will generate code.
   const Function& current_function() const;
 
+  // The innermost function being parsed.
+  const Function& innermost_function() const;
+
   // Note that a local function may be parsed multiple times. It is first parsed
   // when its outermost enclosing function is being parsed. It is then parsed
   // again when an enclosing function calls this local function or calls
   // another local function enclosing it. Code for the local function will only
   // be generated the last time the local function is parsed, i.e. when it is
   // invoked. For example, a local function nested in another local function,
   // itself nested in a static function, is parsed 3 times (unless it does not
   // end up being invoked).
   // Now, current_function() always points to the outermost function being
-  // parsed (i.e. the function that is being invoked), and is not updated while
-  // parsing a nested function of that outermost function.
-  // Therefore, the statements being parsed may or may not belong to the body of
-  // the current_function(); they may belong to nested functions.
+  // compiled (i.e. the function that is being invoked), and is not updated
+  // while parsing a nested function of that outermost function.
+  // Therefore, the statements being parsed may or may not belong to the body
+  // of the current_function(); they may belong to nested functions.
+  // innermost_function() is the function that is currently being parsed.
+  // It is either the same as current_function(), or a lexically nested
+  // function.
   // The function level of the current parsing scope reflects the function
   // nesting. The function level is zero while parsing the body of the
   // current_function(), but is greater than zero while parsing the body of
   // local functions nested in current_function().
 
   // The class or interface being parsed.
   const Class& current_class() const;
   void set_current_class(const Class& value);
 
   // Parsing a library or a regular source script.
@@ skipping 344 matching lines @@
   bool is_top_level_;
 
   // The member currently being parsed during "top level" parsing.
   MemberDesc* current_member_;
 
   // Parser mode to allow/disallow function literals. This is used in
   // constructor initializer expressions to handle ambiguous grammar.
   bool SetAllowFunctionLiterals(bool value);
   bool allow_function_literals_;
 
+  // The function currently being compiled.
+  const Function& current_function_;
+
   // The function currently being parsed.
-  const Function& current_function_;
+  Function& innermost_function_;
 
   // The class or interface currently being parsed, or the owner class of the
   // function currently being parsed. It is used for primary identifier lookups.
   Class& current_class_;
 
   // The current library (and thus class dictionary) used to resolve names.
   const Library& library_;
 
   // List of try blocks seen so far, this is used to generate inlined finally
   // code at all points in the try block where an exit from the block is
   // done using 'return', 'break' or 'continue' statements.
   TryBlocks* try_blocks_list_;
 
   // Allocate temporary only once per function.
   LocalVariable* expression_temp_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_