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_compile_lazily_ = false;
 }
 
 bool Scope::HasSimpleParameters() {
   DeclarationScope* scope = GetClosureScope();
   return !scope->is_function_scope() || scope->has_simple_parameters();
 }
 
+void Scope::SetShouldCompileLazily(bool compile_lazily) {
+  should_compile_lazily_ = compile_lazily;
+  for (Scope* inner = inner_scope_; inner != nullptr; inner = inner->sibling_) {
+    if (inner->is_function_scope()) continue;
+    inner->SetShouldCompileLazily(compile_lazily);
+  }
+}
+
 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->SetShouldCompileLazily(false);
+
   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 854 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_compile_lazily_) Indent(n1, "// should compile lazily\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 460 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);
+    if (should_compile_lazily_) scope->should_compile_lazily_ = true;
+    scope->AllocateScopeInfosRecursively(
+        isolate, scope->is_function_scope() ? AnalyzeMode::kRegular : mode,

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

Why is dropping to kRegular correct here?

[jochen (gone - plz use gerrit), 2016/10/06 15:05:04]

because the scope iterator that uses the AnalyzeMode::kDebugger only looks at
the current function and all its inner non-function scopes:
https://cs.chromium.org/chromium/src/v8/src/debug/debug-scopes.cc?rcl=0&l=816

+        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