Separate scope info allocation for the debugger from regular allocation

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 1074 matching lines @@
 void DeclarationScope::AllocateVariables(ParseInfo* info, AnalyzeMode mode) {
   ResolveVariablesRecursively(info);
   AllocateVariablesRecursively();
 
   MaybeHandle<ScopeInfo> outer_scope;
   for (const Scope* s = outer_scope_; s != nullptr; s = s->outer_scope_) {
     if (s->scope_info_.is_null()) continue;
     outer_scope = s->scope_info_;
     break;
   }
-  AllocateScopeInfosRecursively(info->isolate(), mode, outer_scope);
+  AllocateScopeInfosRecursively(info->isolate(), outer_scope);
+  if (mode == AnalyzeMode::kDebugger) {
+    AllocateDebuggerScopeInfos(info->isolate(), outer_scope);
+  }
   // The debugger expects all shared function infos to contain a scope info.
   // Since the top-most scope will end up in a shared function info, make sure
   // it has one, even if it doesn't need a scope info.
   // TODO(jochen|yangguo): Remove this requirement.
   if (scope_info_.is_null()) {
     scope_info_ = ScopeInfo::Create(info->isolate(), zone(), this, outer_scope);
   }
 }
 
 bool Scope::AllowsLazyParsingWithoutUnresolvedVariables(
@@ skipping 81 matching lines @@
 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;
+  DCHECK(GetClosureScope()->ShouldEagerCompile());
   // 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()) {
@@ skipping 712 matching lines @@
   // If we didn't allocate any locals in the local context, then we only
   // need the minimal number of slots if we must have a context.
   if (num_heap_slots_ == Context::MIN_CONTEXT_SLOTS && !must_have_context) {
     num_heap_slots_ = 0;
   }
 
   // Allocation done.
   DCHECK(num_heap_slots_ == 0 || num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);
 }
 
-void Scope::AllocateScopeInfosRecursively(Isolate* isolate, AnalyzeMode mode,
+void Scope::AllocateScopeInfosRecursively(Isolate* isolate,
                                           MaybeHandle<ScopeInfo> outer_scope) {
   DCHECK(scope_info_.is_null());
-  if (mode == AnalyzeMode::kDebugger || NeedsScopeInfo()) {
+  MaybeHandle<ScopeInfo> next_outer_scope = outer_scope;
+
+  if (NeedsScopeInfo()) {
     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.
+    if (NeedsContext()) next_outer_scope = scope_info_;
   }
 
-  // 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_) {
-    // 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);
+    if (!scope->is_function_scope() ||
+        scope->AsDeclarationScope()->ShouldEagerCompile()) {
+      scope->AllocateScopeInfosRecursively(isolate, next_outer_scope);
+    }
   }
 }
 
+void Scope::AllocateDebuggerScopeInfos(Isolate* isolate,
+                                       MaybeHandle<ScopeInfo> outer_scope) {
+  if (scope_info_.is_null()) {
+    scope_info_ = ScopeInfo::Create(isolate, zone(), this, outer_scope);
+  }
+  MaybeHandle<ScopeInfo> outer = NeedsContext() ? scope_info_ : outer_scope;
+  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
+    if (scope->is_function_scope()) continue;
+    scope->AllocateDebuggerScopeInfos(isolate, outer);
+  }
+}
+
 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