Shuffle fields around in Scope to save more zone memory

src/ast/scopes.h

 // 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.
 
 #ifndef V8_AST_SCOPES_H_
 #define V8_AST_SCOPES_H_
 
 #include "src/ast/ast.h"
 #include "src/base/hashmap.h"
 #include "src/globals.h"
@@ skipping 100 matching lines @@
 
   // Compute top scope and allocate variables. For lazy compilation the top
   // scope only contains the single lazily compiled function, so this
   // doesn't re-allocate variables repeatedly.
   static bool Analyze(ParseInfo* info);
 
   static Scope* DeserializeScopeChain(Isolate* isolate, Zone* zone,
                                       Context* context, Scope* script_scope,
                                       AstValueFactory* ast_value_factory);
 
+#ifdef DEBUG
   // The scope name is only used for printing/debugging.
   void SetScopeName(const AstRawString* scope_name) {
     scope_name_ = scope_name;
   }
+#endif
 
   void DeclareThis(AstValueFactory* ast_value_factory);
   void DeclareDefaultFunctionVariables(AstValueFactory* ast_value_factory);
 
   // Checks if the block scope is redundant, i.e. it does not contain any
   // block scoped declarations. In that case it is removed from the scope
   // tree and its children are reparented.
   Scope* FinalizeBlockScope();
 
   // Inserts outer_scope into this scope's scope chain (and removes this
@@ skipping 377 matching lines @@
   Scope* sibling() const { return sibling_; }
 
   // The scope immediately surrounding this scope, or NULL.
   Scope* outer_scope() const { return outer_scope_; }
 
   // The ModuleDescriptor for this scope; only for module scopes.
   ModuleDescriptor* module() const { return module_descriptor_; }
 
   const AstRawString* catch_variable_name() const {
     DCHECK(is_catch_scope());
-    DCHECK(num_var() == 1);
+    DCHECK_EQ(1, num_var());
     return static_cast<AstRawString*>(variables_.Start()->key);
   }
 
   // ---------------------------------------------------------------------------
   // Variable allocation.
 
   // Collect stack and context allocated local variables in this scope. Note
   // that the function variable - if present - is not collected and should be
   // handled separately.
   void CollectStackAndContextLocals(ZoneList<Variable*>* stack_locals,
                                     ZoneList<Variable*>* context_locals,
                                     ZoneList<Variable*>* context_globals);
 
-  // Current number of var locals.
-  int num_var() const { return num_var_; }
-
   // Result of variable allocation.
   int num_stack_slots() const { return num_stack_slots_; }
   int num_heap_slots() const { return num_heap_slots_; }
   int num_global_slots() const { return num_global_slots_; }
 
   int StackLocalCount() const;
   int ContextLocalCount() const;
   int ContextGlobalCount() const;
 
   // Make sure this scope and all outer scopes are eagerly compiled.
@@ skipping 48 matching lines @@
     return variables_.Lookup(name) != NULL;
   }
 
   bool IsDeclaredParameter(const AstRawString* name) {
     // If IsSimpleParameterList is false, duplicate parameters are not allowed,
     // however `arguments` may be allowed if function is not strict code. Thus,
     // the assumptions explained above do not hold.
     return params_.Contains(variables_.Lookup(name));
   }
 
+  int num_var() const { return variables_.occupancy(); }

[adamk, 2016/08/01 22:47:07]

You might have noticed that this slightly changes the behavior of num_var(), but
given that the only external caller is testing whether we have more than 2^22-1
local variables
(https://cs.chromium.org/chromium/src/v8/src/parsing/pattern-rewriter.cc?q=num...),
I'm guessing you don't care?

+
   SloppyBlockFunctionMap* sloppy_block_function_map() {
     return &sloppy_block_function_map_;
   }
 
   // ---------------------------------------------------------------------------
   // Debugging.
 
 #ifdef DEBUG
   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 
   // Check that the scope has positions assigned.
   void CheckScopePositions();
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  private:
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   Scope* inner_scope_;  // an inner scope of this scope
   Scope* sibling_;  // a sibling inner scope of the outer scope of this scope.
 
-  // The scope type.
-  const ScopeType scope_type_;
-  // If the scope is a function scope, this is the function kind.
-  const FunctionKind function_kind_;
-
   // Debugging support.
+#ifdef DEBUG
   const AstRawString* scope_name_;
+#endif
 
   // The variables declared in this scope:
   //
   // All user-declared variables (incl. parameters).  For script scopes
   // variables may be implicitly 'declared' by being used (possibly in
   // an inner scope) with no intervening with statements or eval calls.
   VariableMap variables_;
   // Compiler-allocated (user-invisible) temporaries. Due to the implementation
   // of RemoveTemporary(), may contain nulls, which must be skipped-over during
   // allocation and printing.
@@ skipping 16 matching lines @@
   // Convenience variable; function scopes only.
   Variable* arguments_;
   // Convenience variable; Subclass constructor only
   Variable* this_function_;
   // Module descriptor; module scopes only.
   ModuleDescriptor* module_descriptor_;
 
   // Map of function names to lists of functions defined in sloppy blocks
   SloppyBlockFunctionMap sloppy_block_function_map_;
 
+  // The scope type.
+  const ScopeType scope_type_;
+  // If the scope is a function scope, this is the function kind.
+  const FunctionKind function_kind_;
+
   // Scope-specific information computed during parsing.
   //
+  // The language mode of this scope.
+  STATIC_ASSERT(LANGUAGE_END == 3);
+  LanguageMode language_mode_ : 2;
   // This scope is inside a 'with' of some outer scope.
-  bool scope_inside_with_;
+  bool scope_inside_with_ : 1;
   // This scope or a nested catch scope or with scope contain an 'eval' call. At
   // the 'eval' call site this scope is the declaration scope.
-  bool scope_calls_eval_;
+  bool scope_calls_eval_ : 1;
   // This scope uses "super" property ('super.foo').
-  bool scope_uses_super_property_;
+  bool scope_uses_super_property_ : 1;
   // This scope has a parameter called "arguments".
-  bool has_arguments_parameter_;
+  bool has_arguments_parameter_ : 1;
   // This scope contains an "use asm" annotation.
-  bool asm_module_;
+  bool asm_module_ : 1;
   // This scope's outer context is an asm module.
-  bool asm_function_;
+  bool asm_function_ : 1;
   // This scope's declarations might not be executed in order (e.g., switch).
-  bool scope_nonlinear_;
-  // The language mode of this scope.
-  LanguageMode language_mode_;
+  bool scope_nonlinear_ : 1;
+  bool is_hidden_ : 1;
+  bool has_simple_parameters_ : 1;
+
+  // Computed via PropagateScopeInfo.
+  bool outer_scope_calls_sloppy_eval_ : 1;
+  bool inner_scope_calls_eval_ : 1;
+  bool force_eager_compilation_ : 1;
+  bool force_context_allocation_ : 1;
+
+  // True if it doesn't need scope resolution (e.g., if the scope was
+  // constructed based on a serialized scope info or a catch context).
+  bool already_resolved_ : 1;
+  bool already_resolved() { return already_resolved_; }
+
+  // True if it holds 'var' declarations.
+  bool is_declaration_scope_ : 1;
+
   // Source positions.
   int start_position_;
   int end_position_;
-  bool is_hidden_;
-
-  // Computed via PropagateScopeInfo.
-  bool outer_scope_calls_sloppy_eval_;
-  bool inner_scope_calls_eval_;
-  bool force_eager_compilation_;
-  bool force_context_allocation_;
-
-  // True if it doesn't need scope resolution (e.g., if the scope was
-  // constructed based on a serialized scope info or a catch context).
-  bool already_resolved_;
-
-  // True if it holds 'var' declarations.
-  bool is_declaration_scope_;
-
-  // Computed as variables are declared.
-  int num_var_;
 
   // Computed via AllocateVariables; function, block and catch scopes only.
   int num_stack_slots_;
   int num_heap_slots_;
   int num_global_slots_;
 
   // Info about the parameter list of a function.
   int arity_;
-  bool has_simple_parameters_;
+  int rest_index_;
   Variable* rest_parameter_;
-  int rest_index_;
 
   // Serialized scope info support.
   Handle<ScopeInfo> scope_info_;
-  bool already_resolved() { return already_resolved_; }
 
   // Create a non-local variable with a given name.
   // These variables are looked up dynamically at runtime.
   Variable* NonLocal(const AstRawString* name, VariableMode mode);
 
   // Variable resolution.
   // Possible results of a recursive variable lookup telling if and how a
   // variable is bound. These are returned in the output parameter *binding_kind
   // of the LookupRecursive function.
   enum BindingKind {
@@ skipping 115 matching lines @@
 
   void SetDefaults();
 
   PendingCompilationErrorHandler pending_error_handler_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_