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

src/ast/scopes.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/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/ast/ast.h"
@@ skipping 285 matching lines @@
   scope_nonlinear_ = false;
   is_hidden_ = false;
   is_debug_evaluate_scope_ = false;
 
   inner_scope_calls_eval_ = false;
   force_context_allocation_ = false;
 
   is_declaration_scope_ = false;
 
   is_lazily_parsed_ = false;
+  should_eager_compile_ = false;
 }
 
 bool Scope::HasSimpleParameters() {
   DeclarationScope* scope = GetClosureScope();
   return !scope->is_function_scope() || scope->has_simple_parameters();
 }
 
+bool Scope::ShouldEagerCompile() const {
+  if (is_declaration_scope() &&
+      !AsDeclarationScope()->AllowsLazyCompilation()) {
+    return true;
+  }
+  return !is_lazily_parsed_ && should_eager_compile_;
+}
+
+void Scope::SetShouldEagerCompile() {
+  should_eager_compile_ = true;
+  for (Scope* inner = inner_scope_; inner != nullptr; inner = inner->sibling_) {
+    if (inner->is_function_scope()) continue;
+    inner->SetShouldEagerCompile();
+  }
+}
+
 void DeclarationScope::set_asm_module() {
   asm_module_ = true;
   // Mark any existing inner function scopes as asm function scopes.
   for (Scope* inner = inner_scope_; inner != nullptr; inner = inner->sibling_) {
     if (inner->is_function_scope()) {
       inner->AsDeclarationScope()->set_asm_function();
     }
   }
 }
 
@@ skipping 222 matching lines @@
   }
 
   // We are compiling one of three cases:
   // 1) top-level code,
   // 2) a function/eval/module on the top-level
   // 3) a function/eval in a scope that was already resolved.
   DCHECK(scope->scope_type() == SCRIPT_SCOPE ||
          scope->outer_scope()->scope_type() == SCRIPT_SCOPE ||
          scope->outer_scope()->already_resolved_);
 
+  // The outer scope is never lazy.
+  scope->SetShouldEagerCompile();
+
   scope->AllocateVariables(info, mode);
 
   // Ensuring that the outer script scope has a scope info avoids having
   // special case for native contexts vs other contexts.
   if (info->script_scope()->scope_info_.is_null()) {
     info->script_scope()->scope_info_ =
         handle(ScopeInfo::Empty(info->isolate()));
   }
 
 #ifdef DEBUG
@@ skipping 843 matching lines @@
     Indent(n1, "// strict mode scope\n");
   }
   if (IsAsmModule()) Indent(n1, "// scope is an asm module\n");
   if (IsAsmFunction()) Indent(n1, "// scope is an asm function\n");
   if (scope_calls_eval_) Indent(n1, "// scope calls 'eval'\n");
   if (is_declaration_scope() && AsDeclarationScope()->uses_super_property()) {
     Indent(n1, "// scope uses 'super' property\n");
   }
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
   if (is_lazily_parsed_) Indent(n1, "// lazily parsed\n");
+  if (should_eager_compile_) Indent(n1, "// will be compiled\n");
   if (num_stack_slots_ > 0) {
     Indent(n1, "// ");
     PrintF("%d stack slots\n", num_stack_slots_);
   }
   if (num_heap_slots_ > 0) {
     Indent(n1, "// ");
     PrintF("%d heap slots\n", num_heap_slots_);
   }
 
   // Print locals.
@@ skipping 459 matching lines @@
     scope_info_ = ScopeInfo::Create(isolate, zone(), this, outer_scope);
   }
 
   // The ScopeInfo chain should mirror the context chain, so we only link to
   // the next outer scope that needs a context.
   MaybeHandle<ScopeInfo> next_outer_scope = outer_scope;
   if (NeedsContext()) next_outer_scope = scope_info_;
 
   // Allocate ScopeInfos for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
-    scope->AllocateScopeInfosRecursively(isolate, mode, next_outer_scope);
+    AnalyzeMode next_mode = mode;
+    bool next_eager = should_eager_compile_;
+    if (scope->is_function_scope()) {
+      // Make sure all inner scopes have are consistently marked: we can't
+      // eager compile inner functions of lazy functions, but if a function
+      // should be eagerly compiled, all its inner scopes are compiled as well.
+      next_eager = should_eager_compile_ ? scope->ShouldEagerCompile() : false;
+
+      // The ScopeIterator which uses the AnalyzeMode::kDebugger only expects
+      // to find ScopeInfos for the current function and all its inner
+      // non-function scopes (see ScopeIterator::GetNestedScopeChain).
+      next_mode = AnalyzeMode::kRegular;
+    }
+    scope->should_eager_compile_ = next_eager;
+    scope->AllocateScopeInfosRecursively(isolate, next_mode, next_outer_scope);
   }
 }
 
 int Scope::StackLocalCount() const {
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   return num_stack_slots() -
          (function != nullptr && function->IsStackLocal() ? 1 : 0);
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   bool is_function_var_in_context =
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
          (is_function_var_in_context ? 1 : 0);
 }
 
 }  // namespace internal
 }  // namespace v8