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

src/parser.cc

Index: src/parser.cc
diff --git a/src/parser.cc b/src/parser.cc
index 07f842a119b06e9c83fb3ad647e990a1d1cedb0c..188500d66a0b8b7ad3e0bb86bd3dfa423fc26f8d 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -4206,10 +4206,40 @@ FunctionLiteral* Parser::ParseFunctionLiteral(
       }
     }
     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.