Put FunctionLiterals into temp_zone too.

src/parsing/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 148 matching lines @@
 
 unsigned ParseData::Version() {
   return Data()[PreparseDataConstants::kVersionOffset];
 }
 
 
 int ParseData::FunctionsSize() {
   return static_cast<int>(Data()[PreparseDataConstants::kFunctionsSizeOffset]);
 }
 
+// Helper for putting parts of the parse results into a temporary zone when
+// parsing inner function bodies.
+class DiscardableZoneScope {
+ public:
+  DiscardableZoneScope(Parser* parser, Zone* temp_zone, bool use_temp_zone)
+      : ast_node_factory_scope_(parser->factory(), temp_zone, use_temp_zone),
+        fni_(parser->ast_value_factory_, temp_zone),
+        parser_(parser),
+        prev_fni_(parser->fni_) {
+    if (use_temp_zone) {
+      parser_->fni_ = &fni_;
+    }
+  }
+  ~DiscardableZoneScope() { parser_->fni_ = prev_fni_; }
+
+ private:
+  AstNodeFactory::BodyScope ast_node_factory_scope_;
+  FuncNameInferrer fni_;
+  Parser* parser_;
+  FuncNameInferrer* prev_fni_;
+};
 
 void Parser::SetCachedData(ParseInfo* info) {
   if (compile_options_ == ScriptCompiler::kNoCompileOptions) {
     cached_parse_data_ = NULL;
   } else {
     DCHECK(info->cached_data() != NULL);
     if (compile_options_ == ScriptCompiler::kConsumeParserCache) {
       cached_parse_data_ = ParseData::FromCachedData(*info->cached_data());
     }
   }
@@ skipping 4234 matching lines @@
       //   FunctionExpression; even without enclosing parentheses it might be
       //   immediately invoked.
       // - The function literal shouldn't be hinted to eagerly compile.
       // - For asm.js functions the body needs to be available when module
       //   validation is active, because we examine the entire module at once.
       bool use_temp_zone =
           FLAG_lazy && !allow_natives() && extension_ == NULL && allow_lazy() &&
           function_type == FunctionLiteral::kDeclaration &&
           eager_compile_hint != FunctionLiteral::kShouldEagerCompile &&
           !(FLAG_validate_asm && scope->asm_function());
-      // Open a new BodyScope, which sets our AstNodeFactory to allocate in the
+      // Open a new zone scope, which sets our AstNodeFactory to allocate in the
       // new temporary zone if the preconditions are satisfied, and ensures that
       // the previous zone is always restored after parsing the body.
       // For the purpose of scope analysis, some ZoneObjects allocated by the
       // factory must persist after the function body is thrown away and
       // temp_zone is deallocated. These objects are instead allocated in a
       // parser-persistent zone (see parser_zone_ in AstNodeFactory).
       {
         Zone temp_zone(zone()->allocator());
-        AstNodeFactory::BodyScope inner(factory(), &temp_zone, use_temp_zone);
-
+        DiscardableZoneScope(this, &temp_zone, use_temp_zone);
         body = ParseEagerFunctionBody(function_name, pos, formals, kind,
                                       function_type, CHECK_OK);
       }
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       if (use_temp_zone) {
         // If the preconditions are correct the function body should never be
         // accessed, but do this anyway for better behaviour if they're wrong.
         body = NULL;
       }
@@ skipping 2618 matching lines @@
 
 #ifdef DEBUG
 void Parser::Print(AstNode* node) {
   ast_value_factory()->Internalize(Isolate::Current());
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8