Shuffle fields around in Scope to save more zone memory

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),
-      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),
+      scope_type_(scope_type),
+      function_kind_(function_kind),
       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_->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),
-      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),
+      scope_type_(scope_type),
+      function_kind_(scope_info.is_null() ? kNormalFunction
+                                          : scope_info->function_kind()),
       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),
-      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),
+      scope_type_(CATCH_SCOPE),
+      function_kind_(kNormalFunction),
       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;
+#ifdef DEBUG
   scope_name_ = nullptr;
+#endif
   dynamics_ = nullptr;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   this_function_ = nullptr;
   scope_inside_with_ = false;
   scope_calls_eval_ = false;
   has_arguments_parameter_ = false;
   scope_uses_super_property_ = false;
   asm_module_ = false;
   asm_function_ = false;
   language_mode_ = is_module_scope() ? STRICT : SLOPPY;
   outer_scope_calls_sloppy_eval_ = false;
   inner_scope_calls_eval_ = false;
   scope_nonlinear_ = false;
   force_eager_compilation_ = false;
   force_context_allocation_ = false;
-  num_var_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
   num_global_slots_ = 0;
   arity_ = 0;
   has_simple_parameters_ = true;
   rest_parameter_ = NULL;
   rest_index_ = -1;
   start_position_ = kNoSourcePosition;
   end_position_ = kNoSourcePosition;
   is_hidden_ = false;
@@ skipping 117 matching lines @@
                            CONST, Variable::NORMAL, kCreatedInitialized);
   }
 }
 
 
 Scope* Scope::FinalizeBlockScope() {
   DCHECK(is_block_scope());
   DCHECK(temps_.is_empty());
   DCHECK(params_.is_empty());
 
-  if (num_var() > 0 || (is_declaration_scope() && calls_sloppy_eval())) {
+  if (variables_.occupancy() > 0 ||
+      (is_declaration_scope() && calls_sloppy_eval())) {
     return this;
   }
 
   // Remove this scope from outer scope.
   outer_scope()->RemoveInnerScope(this);
 
   // Reparent inner scopes.
   if (inner_scope_ != nullptr) {
     Scope* scope = inner_scope_;
     scope->outer_scope_ = outer_scope();
@@ skipping 214 matching lines @@
 }
 
 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));
-  ++num_var_;
   return variables_.Declare(this, name, mode, kind, init_flag,
                             maybe_assigned_flag);
 }
 
 
 Variable* Scope::DeclareDynamicGlobal(const AstRawString* name) {
   DCHECK(is_script_scope());
   return variables_.Declare(this,
                             name,
                             DYNAMIC_GLOBAL,
@@ skipping 1000 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