Move zone_ to Scope

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"
 #include "src/messages.h"
 #include "src/parsing/parser.h"  // for ParseInfo
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // Implementation of LocalsMap
 //
 // Note: We are storing the handle locations as key values in the hash map.
 //       When inserting a new variable via Declare(), we rely on the fact that
 //       the handle location remains alive for the duration of that variable
 //       use. Because a Variable holding a handle with the same location exists
 //       this is ensured.
 
 VariableMap::VariableMap(Zone* zone)
-    : ZoneHashMap(ZoneHashMap::PointersMatch, 8, ZoneAllocationPolicy(zone)),
-      zone_(zone) {}
-VariableMap::~VariableMap() {}
+    : ZoneHashMap(ZoneHashMap::PointersMatch, 8, ZoneAllocationPolicy(zone)) {}
 
-Variable* VariableMap::Declare(Scope* scope, const AstRawString* name,
-                               VariableMode mode, Variable::Kind kind,
+Variable* VariableMap::Declare(Zone* zone, Scope* scope,
+                               const AstRawString* name, VariableMode mode,
+                               Variable::Kind kind,
                                InitializationFlag initialization_flag,
                                MaybeAssignedFlag maybe_assigned_flag) {
   // AstRawStrings are unambiguous, i.e., the same string is always represented
   // by the same AstRawString*.
   // FIXME(marja): fix the type of Lookup.
   Entry* p =
       ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name), name->hash(),
-                                  ZoneAllocationPolicy(zone()));
+                                  ZoneAllocationPolicy(zone));
   if (p->value == NULL) {
     // The variable has not been declared yet -> insert it.
     DCHECK(p->key == name);
-    p->value = new (zone()) Variable(scope, name, mode, kind,
-                                     initialization_flag, maybe_assigned_flag);
+    p->value = new (zone) Variable(scope, name, mode, kind, initialization_flag,
+                                   maybe_assigned_flag);
   }
   return reinterpret_cast<Variable*>(p->value);
 }
 
 
 Variable* VariableMap::Lookup(const AstRawString* name) {
   Entry* p = ZoneHashMap::Lookup(const_cast<AstRawString*>(name), name->hash());
   if (p != NULL) {
     DCHECK(reinterpret_cast<const AstRawString*>(p->key) == name);
     DCHECK(p->value != NULL);
     return reinterpret_cast<Variable*>(p->value);
   }
   return NULL;
 }
 
+SloppyBlockFunctionMap::SloppyBlockFunctionMap(Zone* zone)
+    : ZoneHashMap(ZoneHashMap::PointersMatch, 8, ZoneAllocationPolicy(zone)) {}
 
-SloppyBlockFunctionMap::SloppyBlockFunctionMap(Zone* zone)
-    : ZoneHashMap(ZoneHashMap::PointersMatch, 8, ZoneAllocationPolicy(zone)),
-      zone_(zone) {}
-SloppyBlockFunctionMap::~SloppyBlockFunctionMap() {}
-
-
-void SloppyBlockFunctionMap::Declare(const AstRawString* name,
+void SloppyBlockFunctionMap::Declare(Zone* zone, const AstRawString* name,
                                      SloppyBlockFunctionStatement* stmt) {
   // AstRawStrings are unambiguous, i.e., the same string is always represented
   // by the same AstRawString*.
   Entry* p =
       ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name), name->hash(),
-                                  ZoneAllocationPolicy(zone_));
+                                  ZoneAllocationPolicy(zone));
   if (p->value == nullptr) {
-    p->value = new (zone_->New(sizeof(Vector))) Vector(zone_);
+    p->value = new (zone->New(sizeof(Vector))) Vector(zone);
   }
   Vector* delegates = static_cast<Vector*>(p->value);
   delegates->push_back(stmt);
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
 Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type)
-    : outer_scope_(outer_scope),
+    : zone_(zone),
+      outer_scope_(outer_scope),
       variables_(zone),
       decls_(4, zone),
       scope_type_(scope_type),
       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 {
@@ skipping 23 matching lines @@
       params_(4, zone),
       sloppy_block_function_map_(zone),
       module_descriptor_(scope_type == MODULE_SCOPE ? new (zone)
                                                           ModuleDescriptor(zone)
                                                     : NULL) {
   SetDefaults();
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info)
-    : outer_scope_(nullptr),
+    : zone_(zone),
+      outer_scope_(nullptr),
       variables_(zone),
       decls_(4, zone),
       scope_info_(scope_info),
       scope_type_(scope_type),
       already_resolved_(true) {
   SetDefaults();
   if (!scope_info.is_null()) {
     scope_calls_eval_ = scope_info->CallsEval();
     language_mode_ = scope_info->language_mode();
     num_heap_slots_ = scope_info_->ContextLength();
@@ skipping 12 matching lines @@
                                           : scope_info->function_kind()),
       temps_(4, zone),
       params_(4, zone),
       sloppy_block_function_map_(zone),
       module_descriptor_(nullptr) {
   SetDefaults();
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope,
              const AstRawString* catch_variable_name)
-    : outer_scope_(nullptr),
+    : zone_(zone),
+      outer_scope_(nullptr),
       variables_(zone),
       decls_(0, zone),
       scope_type_(CATCH_SCOPE),
       already_resolved_(true) {
   SetDefaults();
   AddInnerScope(inner_scope);
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
-  Variable* variable = variables_.Declare(this,
-                                          catch_variable_name,
-                                          VAR,
-                                          Variable::NORMAL,
-                                          kCreatedInitialized);
+  Variable* variable =
+      variables_.Declare(zone, this, catch_variable_name, VAR, Variable::NORMAL,
+                         kCreatedInitialized);
   AllocateHeapSlot(variable);
 }
 
 void DeclarationScope::SetDefaults() {
   is_declaration_scope_ = true;
   has_simple_parameters_ = true;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
@@ skipping 119 matching lines @@
     MaybeAssignedFlag maybe_assigned_flag =
         scope_info_->ContextLocalMaybeAssignedFlag(var);
     VariableLocation location = var < scope_info_->ContextLocalCount()
                                     ? VariableLocation::CONTEXT
                                     : VariableLocation::GLOBAL;
     Variable::Kind kind = Variable::NORMAL;
     if (index == scope_info_->ReceiverContextSlotIndex()) {
       kind = Variable::THIS;
     }
 
-    Variable* result = variables_.Declare(this, name, mode, kind, init_flag,
-                                          maybe_assigned_flag);
+    Variable* result = variables_.Declare(zone(), this, name, mode, kind,
+                                          init_flag, maybe_assigned_flag);
     result->AllocateTo(location, index);
   }
 
   // We must read parameters from the end since for multiply declared
   // parameters the value of the last declaration of that parameter is used
   // inside a function (and thus we need to look at the last index). Was bug#
   // 1110337.
   for (int index = scope_info_->ParameterCount() - 1; index >= 0; --index) {
     Handle<String> name_handle(scope_info_->ParameterName(index), isolate);
     const AstRawString* name = ast_value_factory->GetString(name_handle);
     if (!names_seen.insert(name).second) continue;
 
     VariableMode mode = DYNAMIC;
     InitializationFlag init_flag = kCreatedInitialized;
     MaybeAssignedFlag maybe_assigned_flag = kMaybeAssigned;
     VariableLocation location = VariableLocation::LOOKUP;
     Variable::Kind kind = Variable::NORMAL;
 
-    Variable* result = variables_.Declare(this, name, mode, kind, init_flag,
-                                          maybe_assigned_flag);
+    Variable* result = variables_.Declare(zone(), this, name, mode, kind,
+                                          init_flag, maybe_assigned_flag);
     result->AllocateTo(location, index);
   }
 
   // Internalize function proxy for this scope.
   if (scope_info_->HasFunctionName()) {
     AstNodeFactory factory(ast_value_factory);
     Handle<String> name_handle(scope_info_->FunctionName(), isolate);
     const AstRawString* name = ast_value_factory->GetString(name_handle);
     VariableMode mode;
     int index = scope_info_->FunctionContextSlotIndex(*name_handle, &mode);
@@ skipping 53 matching lines @@
 #endif
 }
 
 void DeclarationScope::DeclareThis(AstValueFactory* ast_value_factory) {
   DCHECK(!already_resolved());
   DCHECK(is_declaration_scope());
   DCHECK(has_this_declaration());
 
   bool subclass_constructor = IsSubclassConstructor(function_kind_);
   Variable* var = variables_.Declare(
-      this, ast_value_factory->this_string(),
+      zone(), this, ast_value_factory->this_string(),
       subclass_constructor ? CONST : VAR, Variable::THIS,
       subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
   receiver_ = var;
 }
 
 void DeclarationScope::DeclareDefaultFunctionVariables(
     AstValueFactory* ast_value_factory) {
   DCHECK(is_function_scope());
   DCHECK(!is_arrow_scope());
   // Declare 'arguments' variable which exists in all non arrow functions.
   // Note that it might never be accessed, in which case it won't be
   // allocated during variable allocation.
   arguments_ =
-      variables_.Declare(this, ast_value_factory->arguments_string(), VAR,
-                         Variable::ARGUMENTS, kCreatedInitialized);
+      variables_.Declare(zone(), this, ast_value_factory->arguments_string(),
+                         VAR, Variable::ARGUMENTS, kCreatedInitialized);
 
   new_target_ =
-      variables_.Declare(this, ast_value_factory->new_target_string(), CONST,
-                         Variable::NORMAL, kCreatedInitialized);
+      variables_.Declare(zone(), this, ast_value_factory->new_target_string(),
+                         CONST, Variable::NORMAL, kCreatedInitialized);
 
   if (IsConciseMethod(function_kind_) || IsClassConstructor(function_kind_) ||
       IsAccessorFunction(function_kind_)) {
-    this_function_ =
-        variables_.Declare(this, ast_value_factory->this_function_string(),
-                           CONST, Variable::NORMAL, kCreatedInitialized);
+    this_function_ = variables_.Declare(
+        zone(), this, ast_value_factory->this_function_string(), CONST,
+        Variable::NORMAL, kCreatedInitialized);
   }
 }
 
 
 Scope* Scope::FinalizeBlockScope() {
   DCHECK(is_block_scope());
 
   if (variables_.occupancy() > 0 ||
       (is_declaration_scope() && calls_sloppy_eval())) {
     return this;
@@ skipping 144 matching lines @@
   }
 
   Variable::Kind kind = Variable::NORMAL;
   if (location == VariableLocation::CONTEXT &&
       index == scope_info_->ReceiverContextSlotIndex()) {
     kind = Variable::THIS;
   }
   // TODO(marja, rossberg): Correctly declare FUNCTION, CLASS, NEW_TARGET, and
   // ARGUMENTS bindings as their corresponding Variable::Kind.
 
-  Variable* var = variables_.Declare(this, name, mode, kind, init_flag,
+  Variable* var = variables_.Declare(zone(), this, name, mode, kind, init_flag,
                                      maybe_assigned_flag);
   var->AllocateTo(location, index);
   return var;
 }
 
 Variable* DeclarationScope::LookupFunctionVar(const AstRawString* name,
                                               AstNodeFactory* factory) {
   if (function_ != NULL && function_->proxy()->raw_name() == name) {
     return function_->proxy()->var();
   } else if (!scope_info_.is_null()) {
@@ skipping 30 matching lines @@
 Variable* DeclarationScope::DeclareParameter(
     const AstRawString* name, VariableMode mode, bool is_optional, bool is_rest,
     bool* is_duplicate, AstValueFactory* ast_value_factory) {
   DCHECK(!already_resolved());
   DCHECK(is_function_scope());
   DCHECK(!is_optional || !is_rest);
   Variable* var;
   if (mode == TEMPORARY) {
     var = NewTemporary(name);
   } else {
-    var = variables_.Declare(this, name, mode, Variable::NORMAL,
+    var = variables_.Declare(zone(), this, name, mode, Variable::NORMAL,
                              kCreatedInitialized);
     // TODO(wingo): Avoid O(n^2) check.
     *is_duplicate = IsDeclaredParameter(name);
   }
   if (!is_optional && !is_rest && arity_ == params_.length()) {
     ++arity_;
   }
   if (is_rest) {
     DCHECK_NULL(rest_parameter_);
     rest_parameter_ = var;
     rest_index_ = num_parameters();
   }
   params_.Add(var, zone());
   if (name == ast_value_factory->arguments_string()) {
     has_arguments_parameter_ = true;
   }
   return var;
 }
 
 Variable* Scope::DeclareLocal(const AstRawString* name, VariableMode mode,
                               InitializationFlag init_flag, Variable::Kind kind,
                               MaybeAssignedFlag maybe_assigned_flag) {
   DCHECK(!already_resolved());
   // This function handles VAR, LET, and CONST modes.  DYNAMIC variables are
   // introduced during variable allocation, and TEMPORARY variables are
   // allocated via NewTemporary().
   DCHECK(IsDeclaredVariableMode(mode));
-  return variables_.Declare(this, name, mode, kind, init_flag,
+  return variables_.Declare(zone(), this, name, mode, kind, init_flag,
                             maybe_assigned_flag);
 }
 
 Variable* DeclarationScope::DeclareDynamicGlobal(const AstRawString* name) {
   DCHECK(is_script_scope());
-  return variables_.Declare(this,
-                            name,
-                            DYNAMIC_GLOBAL,
-                            Variable::NORMAL,
-                            kCreatedInitialized);
+  return variables_.Declare(zone(), this, name, DYNAMIC_GLOBAL,
+                            Variable::NORMAL, kCreatedInitialized);
 }
 
 
 bool Scope::RemoveUnresolved(VariableProxy* var) {
   if (unresolved_ == var) {
     unresolved_ = var->next_unresolved();
     var->set_next_unresolved(nullptr);
     return true;
   }
   VariableProxy* current = unresolved_;
@@ skipping 558 matching lines @@
 
 
 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.
     InitializationFlag init_flag = (mode == VAR)
         ? kCreatedInitialized : kNeedsInitialization;
-    var = map->Declare(NULL,
-                       name,
-                       mode,
-                       Variable::NORMAL,
-                       init_flag);
+    var = map->Declare(zone(), NULL, name, mode, Variable::NORMAL, init_flag);
     // Allocate it by giving it a dynamic lookup.
     var->AllocateTo(VariableLocation::LOOKUP, -1);
   }
   return var;
 }
 
 Variable* Scope::LookupRecursive(VariableProxy* proxy,
                                  BindingKind* binding_kind,
                                  AstNodeFactory* factory,
                                  Scope* max_outer_scope) {
@@ skipping 486 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