When parsing inner functions, try to allocate in a temporary Zone

src/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/parser.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 4188 matching lines @@
         is_lazily_parsed = false;
 
         // This is probably an initialization function. Inform the compiler it
         // should also eager-compile this function, and that we expect it to be
         // used once.
         eager_compile_hint = FunctionLiteral::kShouldEagerCompile;
         should_be_used_once_hint = true;
       }
     }
     if (!is_lazily_parsed) {
+      // Determine whether the function body can be discarded after parsing.
+      // The preconditions are:
+      // - Lazy compilation has to be enabled.
+      // - Neither V8 natives nor native function declarations can be allowed,
+      //   since parsing one would retroactively force the function to be
+      //   eagerly compiled.
+      // - The invoker of this parser can't depend on the AST being eagerly
+      //   built (either because the function is about to be compiled, or
+      //   because the AST is going to be inspected for some reason).
+      // - Because of the above, we can't be attempting to parse a
+      //   FunctionExpression; even without enclosing parentheses it might be
+      //   immediately invoked.
+      // - The function literal shouldn't be hinted to eagerly compile.
+      bool can_use_temp_zone =
+          FLAG_lazy && !allow_natives() && extension_ == NULL && allow_lazy() &&
+          function_type == FunctionLiteral::DECLARATION &&
+          eager_compile_hint != FunctionLiteral::kShouldEagerCompile;
+      Zone* outer_zone = factory()->zone();
+      Zone temp_zone;
+      if (can_use_temp_zone) {
+        // For the purpose of scope analysis, some HeapObjects 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).
+        factory()->set_zone(&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 (can_use_temp_zone) {
+        body = NULL;
+        factory()->set_zone(outer_zone);

[Michael Starzinger, 2015/09/10 12:16:54]

Suggestion as discsussed offline: This explicit resetting to the previous zone
could become brittle should the thing it is scoping become more complex. Also
exposing AstFactory::set_zone can be abused. One counter proposal would be to
slightly change the API. I was thinking about something along the lines of:

{
  Zone temp_zone;
  bool can_use_temp_zone = ...;
  AstNodeFactory::ZoneScope scope(factory(), &temp_zone, can_use_temp_zone);
  ...
}

This way we gain two things:
1) There is no need to expose set_zone() to the general public, the new scope is
the only one being able to change the zone.
2) Even if the thing being covered by the scope gets more complex and early
bailout return statements are added, the resetting to the original zone and the
destruction of the body still happens.

WDYT?

[conradw, 2015/09/10 13:12:40]

Sounds good! Done.

+      }
     }
 
     // Parsing the body may change the language mode in our scope.
     language_mode = scope->language_mode();
 
     if (is_strong(language_mode) && IsSubclassConstructor(kind)) {
       if (!function_state.super_location().IsValid()) {
         ReportMessageAt(function_name_location,
                         MessageTemplate::kStrongSuperCallMissing,
                         kReferenceError);
@@ skipping 1981 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args, pos);
 }
 }  // namespace internal
 }  // namespace v8