Move should_eager_compile and is_lazily_parsed to DeclarationScope

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 253 matching lines @@
   asm_function_ = false;
   force_eager_compilation_ = false;
   has_arguments_parameter_ = false;
   scope_uses_super_property_ = false;
   has_rest_ = false;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   this_function_ = nullptr;
+  should_eager_compile_ = false;
+  is_lazily_parsed_ = false;
 }
 
 void Scope::SetDefaults() {
 #ifdef DEBUG
   scope_name_ = nullptr;
   already_resolved_ = false;
   needs_migration_ = false;
 #endif
   inner_scope_ = nullptr;
   sibling_ = nullptr;
   unresolved_ = nullptr;
 
   start_position_ = kNoSourcePosition;
   end_position_ = kNoSourcePosition;
 
   num_stack_slots_ = 0;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
 
   set_language_mode(SLOPPY);
 
   scope_calls_eval_ = false;
   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;
-  }
+bool DeclarationScope::ShouldEagerCompile() const {
+  if (!AllowsLazyCompilation()) return true;
   return !is_lazily_parsed_ && should_eager_compile_;
 }
 
-void Scope::SetShouldEagerCompile() {
+void DeclarationScope::set_should_eager_compile() {
   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 225 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->set_should_eager_compile();
 
   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()));
   }
 
@@ skipping 594 matching lines @@
 }
 
 DeclarationScope* Scope::GetDeclarationScope() {
   Scope* scope = this;
   while (!scope->is_declaration_scope()) {
     scope = scope->outer_scope();
   }
   return scope->AsDeclarationScope();
 }
 
+const DeclarationScope* Scope::GetClosureScope() const {
+  const Scope* scope = this;
+  while (!scope->is_declaration_scope() || scope->is_block_scope()) {
+    scope = scope->outer_scope();
+  }
+  return scope->AsDeclarationScope();
+}
+
 DeclarationScope* Scope::GetClosureScope() {
   Scope* scope = this;
   while (!scope->is_declaration_scope() || scope->is_block_scope()) {
     scope = scope->outer_scope();
   }
   return scope->AsDeclarationScope();
 }
 
+bool Scope::NeedsScopeInfo() const {
+  DCHECK(!already_resolved_);
+  // A lazily parsed scope doesn't contain enough information to create a
+  // ScopeInfo from it.
+  if (!GetClosureScope()->ShouldEagerCompile()) return false;
+  // The debugger expects all functions to have scope infos.
+  // TODO(jochen|yangguo): Remove this requirement.
+  if (is_function_scope()) return true;
+  return NeedsContext();
+}
+
 ModuleScope* Scope::GetModuleScope() {
   Scope* scope = this;
   DCHECK(!scope->is_script_scope());
   while (!scope->is_module_scope()) {
     scope = scope->outer_scope();
     DCHECK_NOT_NULL(scope);
   }
   return scope->AsModuleScope();
 }
 
@@ skipping 234 matching lines @@
   if (is_strict(language_mode())) {
     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 (is_declaration_scope()) {
+    DeclarationScope* scope = AsDeclarationScope();
+    if (scope->is_lazily_parsed()) Indent(n1, "// lazily parsed\n");
+    if (scope->ShouldEagerCompile()) 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 404 matching lines @@
   for (const auto& it : module()->regular_exports()) {
     Variable* var = LookupLocal(it.first);
     var->AllocateTo(VariableLocation::MODULE, 0);
   }
 }
 
 void Scope::AllocateVariablesRecursively() {
   DCHECK(!already_resolved_);
   DCHECK_EQ(0, num_stack_slots_);
   // Don't allocate variables of preparsed scopes.
-  if (is_lazily_parsed_) return;
+  if (is_declaration_scope() && AsDeclarationScope()->is_lazily_parsed()) {
+    return;
+  }
 
   // Allocate variables for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     scope->AllocateVariablesRecursively();
   }
 
   DCHECK(!already_resolved_);
   DCHECK_EQ(Context::MIN_CONTEXT_SLOTS, num_heap_slots_);
 
   // Allocate variables for this scope.
@@ skipping 34 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_) {
-    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;
+    // 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).
+    AnalyzeMode next_mode =
+        scope->is_function_scope() ? AnalyzeMode::kRegular : mode;
     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