Create ScopeInfos while analyzing the Scope chain

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/bootstrapper.h"
@@ skipping 834 matching lines @@
 }
 
 void DeclarationScope::AllocateVariables(ParseInfo* info) {
   // 1) Propagate scope information.
   PropagateScopeInfo();
 
   // 2) Resolve variables.
   ResolveVariablesRecursively(info);
 
   // 3) Allocate variables.
-  AllocateVariablesRecursively();
+  AllocateVariablesRecursively(info->isolate());
 }
 
 
 bool Scope::AllowsLazyParsing() const {
   // If we are inside a block scope, we must parse eagerly to find out how
   // to allocate variables on the block scope. At this point, declarations may
   // not have yet been parsed.
   for (const Scope* s = this; s != nullptr; s = s->outer_scope_) {
     if (s->is_block_scope()) return false;
   }
@@ skipping 68 matching lines @@
 DeclarationScope* Scope::GetReceiverScope() {
   Scope* scope = this;
   while (!scope->is_script_scope() &&
          (!scope->is_function_scope() ||
           scope->AsDeclarationScope()->is_arrow_scope())) {
     scope = scope->outer_scope();
   }
   return scope->AsDeclarationScope();
 }
 
-
-
-Handle<ScopeInfo> Scope::GetScopeInfo(Isolate* isolate) {
-  if (scope_info_.is_null()) {
-    scope_info_ = ScopeInfo::Create(isolate, zone(), this);
-  }
-  return scope_info_;
-}
-
 Handle<StringSet> DeclarationScope::CollectNonLocals(
     ParseInfo* info, Handle<StringSet> non_locals) {
   VariableProxy* free_variables = FetchFreeVariables(this, info);
   for (VariableProxy* proxy = free_variables; proxy != nullptr;
        proxy = proxy->next_unresolved()) {
     non_locals = StringSet::Add(non_locals, proxy->name());
   }
   return non_locals;
 }
 
@@ skipping 620 matching lines @@
     // TODO(neis): Use a meaningful index.
     var->AllocateTo(VariableLocation::MODULE, 42);
   }
 
   for (const auto& it : module()->regular_exports()) {
     Variable* var = LookupLocal(it.first);
     var->AllocateTo(VariableLocation::MODULE, 0);
   }
 }
 
-void Scope::AllocateVariablesRecursively() {
+void Scope::AllocateVariablesRecursively(Isolate* isolate) {
   DCHECK(!already_resolved_);
   DCHECK_EQ(0, num_stack_slots_);
-
-  // 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.
   // Parameters must be allocated first, if any.
   if (is_declaration_scope()) {
     if (is_module_scope()) {
       AsModuleScope()->AllocateModuleVariables();
     } else if (is_function_scope()) {
       AsDeclarationScope()->AllocateParameterLocals();
@@ skipping 12 matching lines @@
       (is_block_scope() && is_declaration_scope() && calls_sloppy_eval());
 
   // 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);
+
+  // Create ScopeInfo.
+  DCHECK(scope_info_.is_null());
+  scope_info_ = ScopeInfo::Create(isolate, zone(), this);
+
+  // Allocate variables for inner scopes.
+  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
+    scope->AllocateVariablesRecursively(isolate);

[adamk, 2016/08/26 18:41:08]

For stack-allocated block-scoped variables, this may allocate some variables in
this scope (or an outer scope), so running it after ScopeInfo::Create seems like
it'll just be wrong. But probably this only breaks the debugger, since lazy
compilation wouldn't depend on stack allocated variables from other scopes? We
really ought to have some tests that fail here...

+  }
 }
 
 
 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 - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8