Turn ZoneList inner_scopes into a linked list

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 "src/accessors.h"
 #include "src/ast/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
@@ skipping 67 matching lines @@
   delegates->push_back(stmt);
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
 Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type,
              FunctionKind function_kind)
     : outer_scope_(outer_scope),
-      inner_scopes_(4, zone),
       scope_type_(scope_type),
       function_kind_(function_kind),
       variables_(zone),
       temps_(4, zone),
       params_(4, zone),
       decls_(4, zone),
       module_descriptor_(scope_type == MODULE_SCOPE ? new (zone)
                                                           ModuleDescriptor(zone)
                                                     : NULL),
       sloppy_block_function_map_(zone),
       already_resolved_(false) {
   SetDefaults();
   if (outer_scope == nullptr) {
     // If the outer scope is null, this cannot be a with scope. The outermost
     // scope must be a script scope.
     DCHECK_EQ(SCRIPT_SCOPE, scope_type);
   } else {
     asm_function_ = outer_scope_->asm_module_;
     // Inherit the language mode from the parent scope unless we're a module
     // scope.
     if (!is_module_scope()) language_mode_ = outer_scope->language_mode_;
     force_context_allocation_ =
         !is_function_scope() && outer_scope->has_forced_context_allocation();
-    outer_scope_->inner_scopes_.Add(this, zone);
+    outer_scope_->AddInnerScope(this);
     scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
   }
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info)
     : outer_scope_(nullptr),
-      inner_scopes_(4, zone),
       scope_type_(scope_type),
       function_kind_(scope_info.is_null() ? kNormalFunction
                                           : scope_info->function_kind()),
       variables_(zone),
       temps_(4, zone),
       params_(4, zone),
       decls_(4, zone),
       module_descriptor_(nullptr),
       sloppy_block_function_map_(zone),
       already_resolved_(true),
       scope_info_(scope_info) {
   SetDefaults();
   if (!scope_info.is_null()) {
     scope_calls_eval_ = scope_info->CallsEval();
     language_mode_ = scope_info->language_mode();
     is_declaration_scope_ = scope_info->is_declaration_scope();
     num_heap_slots_ = scope_info_->ContextLength();
   }
   // Ensure at least MIN_CONTEXT_SLOTS to indicate a materialized context.
   num_heap_slots_ = Max(num_heap_slots_,
                         static_cast<int>(Context::MIN_CONTEXT_SLOTS));
   AddInnerScope(inner_scope);
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope,
              const AstRawString* catch_variable_name)
     : outer_scope_(nullptr),
-      inner_scopes_(1, zone),
       scope_type_(CATCH_SCOPE),
       function_kind_(kNormalFunction),
       variables_(zone),
       temps_(0, zone),
       params_(0, zone),
       decls_(0, zone),
       module_descriptor_(nullptr),
       sloppy_block_function_map_(zone),
       already_resolved_(true) {
   SetDefaults();
   AddInnerScope(inner_scope);
   ++num_var_;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   Variable* variable = variables_.Declare(this,
                                           catch_variable_name,
                                           VAR,
                                           Variable::NORMAL,
                                           kCreatedInitialized);
   AllocateHeapSlot(variable);
 }
 
 void Scope::SetDefaults() {
   is_declaration_scope_ =
       is_eval_scope() || is_function_scope() ||
       is_module_scope() || is_script_scope();
+  inner_scope_ = nullptr;
+  sibling_ = nullptr;
   unresolved_ = nullptr;
   scope_name_ = nullptr;
   dynamics_ = nullptr;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   this_function_ = nullptr;
   scope_inside_with_ = false;
   scope_calls_eval_ = false;
@@ skipping 147 matching lines @@
   DCHECK(params_.is_empty());
 
   if (num_var() > 0 || (is_declaration_scope() && calls_sloppy_eval())) {
     return this;
   }
 
   // Remove this scope from outer scope.
   outer_scope()->RemoveInnerScope(this);
 
   // Reparent inner scopes.
-  for (int i = 0; i < inner_scopes_.length(); i++) {
-    outer_scope()->AddInnerScope(inner_scopes_[i]);
+  if (inner_scope_ != nullptr) {
+    Scope* scope = inner_scope_;
+    scope->outer_scope_ = outer_scope();
+    while (scope->sibling_ != nullptr) {
+      scope = scope->sibling_;
+      scope->outer_scope_ = outer_scope();
+    }
+    scope->sibling_ = outer_scope()->inner_scope_;
+    outer_scope()->inner_scope_ = inner_scope_;
+    inner_scope_ = nullptr;
   }
 
   // Move unresolved variables
-  VariableProxy* unresolved = unresolved_;
-  if (outer_scope()->unresolved_ == nullptr) {
-    outer_scope()->unresolved_ = unresolved;
-  } else if (unresolved != nullptr) {
-    while (unresolved->next_unresolved() != nullptr) {
-      unresolved = unresolved->next_unresolved();
+  if (unresolved_ != nullptr) {
+    if (outer_scope()->unresolved_ != nullptr) {
+      VariableProxy* unresolved = unresolved_;
+      while (unresolved->next_unresolved() != nullptr) {
+        unresolved = unresolved->next_unresolved();
+      }
+      unresolved->set_next_unresolved(outer_scope()->unresolved_);
     }
-    unresolved->set_next_unresolved(outer_scope()->unresolved_);
     outer_scope()->unresolved_ = unresolved_;
+    unresolved_ = nullptr;
   }
 
   PropagateUsageFlagsToScope(outer_scope_);
 
   return NULL;
 }
 
 
 void Scope::ReplaceOuterScope(Scope* outer) {
   DCHECK_NOT_NULL(outer);
@@ skipping 404 matching lines @@
   for (Scope* s = this; s != scope; s = s->outer_scope_) {
     DCHECK(s != NULL);  // scope must be in the scope chain
     if (s->NeedsContext()) n++;
   }
   return n;
 }
 
 
 int Scope::MaxNestedContextChainLength() {
   int max_context_chain_length = 0;
-  for (int i = 0; i < inner_scopes_.length(); i++) {
-    Scope* scope = inner_scopes_[i];
+  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     max_context_chain_length = std::max(scope->MaxNestedContextChainLength(),
                                         max_context_chain_length);
   }
   if (NeedsContext()) {
     max_context_chain_length += 1;
   }
   return max_context_chain_length;
 }
 
 
@@ skipping 36 matching lines @@
 Handle<StringSet> Scope::CollectNonLocals(Handle<StringSet> non_locals) {
   // Collect non-local variables referenced in the scope.
   // TODO(yangguo): store non-local variables explicitly if we can no longer
   //                rely on unresolved_ to find them.
   for (VariableProxy* proxy = unresolved_; proxy != nullptr;
        proxy = proxy->next_unresolved()) {
     if (proxy->is_resolved() && proxy->var()->IsStackAllocated()) continue;
     Handle<String> name = proxy->name();
     non_locals = StringSet::Add(non_locals, name);
   }
-  for (int i = 0; i < inner_scopes_.length(); i++) {
-    non_locals = inner_scopes_[i]->CollectNonLocals(non_locals);
+  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
+    non_locals = scope->CollectNonLocals(non_locals);
   }
   return non_locals;
 }
 
 
 #ifdef DEBUG
 static const char* Header(ScopeType scope_type, FunctionKind function_kind,
                           bool is_declaration_scope) {
   switch (scope_type) {
     case EVAL_SCOPE: return "eval";
@@ skipping 172 matching lines @@
 
   if (dynamics_ != NULL) {
     Indent(n1, "// dynamic vars:\n");
     PrintMap(n1, dynamics_->GetMap(DYNAMIC));
     PrintMap(n1, dynamics_->GetMap(DYNAMIC_LOCAL));
     PrintMap(n1, dynamics_->GetMap(DYNAMIC_GLOBAL));
   }
 
   // Print inner scopes (disable by providing negative n).
   if (n >= 0) {
-    for (int i = 0; i < inner_scopes_.length(); i++) {
+    for (Scope* scope = inner_scope_; scope != nullptr;
+         scope = scope->sibling_) {
       PrintF("\n");
-      inner_scopes_[i]->Print(n1);
+      scope->Print(n1);
     }
   }
 
   Indent(n0, "}\n");
 }
 
 void Scope::CheckScopePositions() {
   // A scope is allowed to have invalid positions if it is hidden and has no
   // inner scopes
-  if (!is_hidden() && inner_scopes_.length() == 0) {
+  if (!is_hidden() && inner_scope_ == nullptr) {
     CHECK_NE(kNoSourcePosition, start_position());
     CHECK_NE(kNoSourcePosition, end_position());
   }
-  for (Scope* scope : inner_scopes_) scope->CheckScopePositions();
+  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
+    scope->CheckScopePositions();
+  }
 }
 #endif  // DEBUG
 
 
 Variable* Scope::NonLocal(const AstRawString* name, VariableMode mode) {
   if (dynamics_ == NULL) dynamics_ = new (zone()) DynamicScopePart(zone());
   VariableMap* map = dynamics_->GetMap(mode);
   Variable* var = map->Lookup(name);
   if (var == NULL) {
     // Declare a new non-local.
@@ skipping 165 matching lines @@
                                         AstNodeFactory* factory) {
   DCHECK(info->script_scope()->is_script_scope());
 
   // Resolve unresolved variables for this scope.
   for (VariableProxy* proxy = unresolved_; proxy != nullptr;
        proxy = proxy->next_unresolved()) {
     if (!ResolveVariable(info, proxy, factory)) return false;
   }
 
   // Resolve unresolved variables for inner scopes.
-  for (int i = 0; i < inner_scopes_.length(); i++) {
-    if (!inner_scopes_[i]->ResolveVariablesRecursively(info, factory))
-      return false;
+  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
+    if (!scope->ResolveVariablesRecursively(info, factory)) return false;
   }
 
   return true;
 }
 
 
 void Scope::PropagateScopeInfo(bool outer_scope_calls_sloppy_eval ) {
   if (outer_scope_calls_sloppy_eval) {
     outer_scope_calls_sloppy_eval_ = true;
   }
 
   bool calls_sloppy_eval =
       this->calls_sloppy_eval() || outer_scope_calls_sloppy_eval_;
-  for (int i = 0; i < inner_scopes_.length(); i++) {
-    Scope* inner = inner_scopes_[i];
+  for (Scope* inner = inner_scope_; inner != nullptr; inner = inner->sibling_) {
     inner->PropagateScopeInfo(calls_sloppy_eval);
     if (inner->scope_calls_eval_ || inner->inner_scope_calls_eval_) {
       inner_scope_calls_eval_ = true;
     }
     if (inner->force_eager_compilation_) {
       force_eager_compilation_ = true;
     }
     if (asm_module_ && inner->scope_type() == FUNCTION_SCOPE) {
       inner->asm_function_ = true;
     }
@@ skipping 211 matching lines @@
   if (this_function_ != nullptr && !MustAllocate(this_function_)) {
     this_function_ = nullptr;
   }
 }
 
 void Scope::AllocateVariablesRecursively(AstValueFactory* ast_value_factory) {
   if (!already_resolved()) {
     num_stack_slots_ = 0;
   }
   // Allocate variables for inner scopes.
-  for (int i = 0; i < inner_scopes_.length(); i++) {
-    inner_scopes_[i]->AllocateVariablesRecursively(ast_value_factory);
+  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
+    scope->AllocateVariablesRecursively(ast_value_factory);
   }
 
   // If scope is already resolved, we still need to allocate
   // variables in inner scopes which might not have been resolved yet.
   if (already_resolved()) return;
   // The number of slots required for variables.
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
 
   // Allocate variables for this scope.
   // Parameters must be allocated first, if any.
@@ skipping 33 matching lines @@
       function_ != NULL && function_->proxy()->var()->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