Teach Scopes whether they will end up being lazily compiled or not

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 <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 271 matching lines @@
 
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       name, function_scope, body, materialized_literal_count,
       expected_property_count, parameter_count,
       FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::kAnonymousExpression,
       FunctionLiteral::kShouldLazyCompile, pos);
 
   function_literal->set_requires_class_field_init(requires_class_field_init);
 
+  if (ShouldCompileLazily(function_literal)) {
+    function_literal->scope()->SetShouldCompileLazily(true);
+  }
+
   return function_literal;
 }
 
 
 // ----------------------------------------------------------------------------
 // Target is a support class to facilitate manipulation of the
 // Parser's target_stack_ (the stack of potential 'break' and
 // 'continue' statement targets). Upon construction, a new target is
 // added; it is removed upon destruction.
 
@@ skipping 337 matching lines @@
       compile_options_(info->compile_options()),
       cached_parse_data_(NULL),
       total_preparse_skipped_(0),
       pre_parse_timer_(NULL),
       parsing_on_main_thread_(true) {
   // Even though we were passed ParseInfo, we should not store it in
   // Parser - this makes sure that Isolate is not accidentally accessed via
   // ParseInfo during background parsing.
   DCHECK(!info->script().is_null() || info->source_stream() != nullptr ||
          info->character_stream() != nullptr);
+  set_will_serialize(info->will_serialize());
+  set_serializer_enabled(info->isolate()->serializer_enabled());
+  set_is_debug(info->is_debug());
   set_allow_lazy(FLAG_lazy && info->allow_lazy_parsing() &&
                  !info->is_native() && info->extension() == nullptr);
   set_allow_natives(FLAG_allow_natives_syntax || info->is_native());
   set_allow_tailcalls(FLAG_harmony_tailcalls && !info->is_native() &&
                       info->isolate()->is_tail_call_elimination_enabled());
   set_allow_harmony_do_expressions(FLAG_harmony_do_expressions);
   set_allow_harmony_for_in(FLAG_harmony_for_in);
   set_allow_harmony_function_sent(FLAG_harmony_function_sent);
   set_allow_harmony_restrictive_declarations(
       FLAG_harmony_restrictive_declarations);
@@ skipping 25 matching lines @@
   Handle<ScopeInfo> outer_scope_info;
   if (maybe_outer_scope_info.ToHandle(&outer_scope_info)) {
     scope = Scope::DeserializeScopeChain(
         info->isolate(), zone(), *outer_scope_info, script_scope,
         ast_value_factory(), Scope::DeserializationMode::kScopesOnly);
     DCHECK(!info->is_module() || scope->is_module_scope());
   }
   original_scope_ = scope;
 }
 
+bool Parser::ShouldCompileLazily(FunctionLiteral* fun) {
+  // Determine if the function should be lazily compiled. This is necessary to
+  // allow some of our builtin JS files to be lazily compiled. These
+  // builtins cannot be handled lazily by the parser, since we have to know
+  // if a function uses the special natives syntax, which is something the
+  // parser records.
+  // If the debugger requests compilation for break points, we cannot be
+  // aggressive about lazy compilation, because it might trigger compilation
+  // of functions without an outer context when setting a breakpoint through
+  // Debug::FindSharedFunctionInfoInScript.
+  bool allow_lazy = fun->AllowsLazyCompilation() && !is_debug();
+  bool lazy = FLAG_lazy && allow_lazy && !fun->should_eager_compile();
+
+  // Consider compiling eagerly when targeting the code cache.
+  lazy &= !(FLAG_serialize_eager && will_serialize());
+
+  // Consider compiling eagerly when compiling bytecode for Ignition.
+  lazy &= !(FLAG_ignition && FLAG_ignition_eager && !serializer_enabled());
+
+  return lazy;
+}
+
 FunctionLiteral* Parser::ParseProgram(Isolate* isolate, ParseInfo* info) {
   // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
   // see comment for HistogramTimerScope class.
 
   // It's OK to use the Isolate & counters here, since this function is only
   // called in the main thread.
   DCHECK(parsing_on_main_thread_);
 
   HistogramTimerScope timer_scope(isolate->counters()->parse(), true);
   RuntimeCallTimerScope runtime_timer(isolate, &RuntimeCallStats::Parse);
@@ skipping 2071 matching lines @@
       expected_property_count, arity, duplicate_parameters, function_type,
       eager_compile_hint, pos);
   function_literal->set_function_token_position(function_token_pos);
   if (should_be_used_once_hint)
     function_literal->set_should_be_used_once_hint();
 
   if (should_infer_name) {
     DCHECK_NOT_NULL(fni_);
     fni_->AddFunction(function_literal);
   }
+
+  if (ShouldCompileLazily(function_literal)) {
+    scope->SetShouldCompileLazily(true);

[marja, 2016/10/06 11:53:06]

Would it be feasible to pass this information in FunctionLiteral ctor (which
would then call scope->SetShouldCompileLazily) so that we don't need to
duplicate this in all places where FunctionLiterals are created?

+  }
+
   return function_literal;
 }
 
 Parser::LazyParsingResult Parser::SkipLazyFunctionBody(
     int* materialized_literal_count, int* expected_property_count,
     bool is_inner_function, bool may_abort, bool* ok) {
   if (produce_cached_parse_data()) CHECK(log_);
 
   int function_block_pos = position();
   DeclarationScope* scope = function_state_->scope();
@@ skipping 630 matching lines @@
             zone());
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       ast_value_factory()->empty_string(), initializer_scope, body,
       initializer_state.materialized_literal_count(),
       initializer_state.expected_property_count(), 0,
       FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::kAnonymousExpression,
       FunctionLiteral::kShouldLazyCompile, initializer_scope->start_position());
   function_literal->set_is_class_field_initializer(true);
   function_literal->scope()->set_arity(count);
+  if (ShouldCompileLazily(function_literal)) {
+    function_literal->scope()->SetShouldCompileLazily(true);
+  }
   return function_literal;
 }
 
 FunctionLiteral* Parser::InsertClassFieldInitializer(
     FunctionLiteral* constructor) {
   Statement* call_initializer = factory()->NewExpressionStatement(
       CallClassFieldInitializer(
           constructor->scope(),
           constructor->scope()->NewUnresolved(
               factory(), ast_value_factory()->this_string(), kNoSourcePosition,
@@ skipping 1997 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8