Initialize num_heap_slots_ to MIN_CONTEXT_SLOTS in SetDefaults, make already_resolved_ debug-only

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 148 matching lines @@
 
   // Create a new unresolved variable.
   VariableProxy* NewUnresolved(AstNodeFactory* factory,
                                const AstRawString* name,
                                int start_position = kNoSourcePosition,
                                int end_position = kNoSourcePosition,
                                Variable::Kind kind = Variable::NORMAL) {
     // Note that we must not share the unresolved variables with
     // the same name because they may be removed selectively via
     // RemoveUnresolved().
-    DCHECK(!already_resolved());
+    DCHECK(!already_resolved_);
     DCHECK_EQ(factory->zone(), zone());
     VariableProxy* proxy =
         factory->NewVariableProxy(name, kind, start_position, end_position);
     proxy->set_next_unresolved(unresolved_);
     unresolved_ = proxy;
     return proxy;
   }
 
   void AddUnresolved(VariableProxy* proxy) {
-    DCHECK(!already_resolved());
+    DCHECK(!already_resolved_);
     DCHECK(!proxy->is_resolved());
     proxy->set_next_unresolved(unresolved_);
     unresolved_ = proxy;
   }
 
   // Remove a unresolved variable. During parsing, an unresolved variable
   // may have been added optimistically, but then only the variable name
   // was used (typically for labels). If the variable was not declared, the
   // addition introduced a new unresolved variable which may end up being
   // allocated globally as a "ghost" variable. RemoveUnresolved removes
@@ skipping 92 matching lines @@
   void set_end_position(int statement_pos) {
     end_position_ = statement_pos;
   }
 
   // Scopes created for desugaring are hidden. I.e. not visible to the debugger.
   bool is_hidden() const { return is_hidden_; }
   void set_is_hidden() { is_hidden_ = true; }
 
   // In some cases we want to force context allocation for a whole scope.
   void ForceContextAllocation() {
-    DCHECK(!already_resolved());
+    DCHECK(!already_resolved_);
     force_context_allocation_ = true;
   }
   bool has_forced_context_allocation() const {
     return force_context_allocation_;
   }
 
   // ---------------------------------------------------------------------------
   // Predicates.
 
   // Specific scope types.
@@ skipping 161 matching lines @@
   // form a linked list of all unresolved proxies.
   VariableProxy* unresolved_;
   // Declarations.
   ZoneList<Declaration*> decls_;
 
   // Serialized scope info support.
   Handle<ScopeInfo> scope_info_;
 // Debugging support.
 #ifdef DEBUG
   const AstRawString* scope_name_;
+
+  // 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;
 #endif
 
   // Source positions.
   int start_position_;
   int end_position_;
 
   // Computed via AllocateVariables.
   int num_stack_slots_;
   int num_heap_slots_;
   int num_global_slots_;
@@ skipping 24 matching lines @@
   bool is_hidden_ : 1;
   // Temporary workaround that allows masking of 'this' in debug-evalute scopes.
   bool is_debug_evaluate_scope_ : 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;
 
   // 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
@@ skipping 263 matching lines @@
            (is_function_scope() && (IsClassConstructor(function_kind()) ||
                                     IsConciseMethod(function_kind()) ||
                                     IsAccessorFunction(function_kind()))));
     return this_function_;
   }
 
   // Adds a temporary variable in this scope's TemporaryScope. This is for
   // adjusting the scope of temporaries used when desugaring parameter
   // initializers.
   void AddTemporary(Variable* var) {
-    DCHECK(!already_resolved());
+    DCHECK(!already_resolved_);
     // Temporaries are only placed in ClosureScopes.
     DCHECK_EQ(GetClosureScope(), this);
     temps_.Add(var, zone());
   }
 
   ZoneList<Variable*>* temps() { return &temps_; }
 
   void DeclareSloppyBlockFunction(const AstRawString* name,
                                   SloppyBlockFunctionStatement* statement) {
     sloppy_block_function_map_.Declare(zone(), name, statement);
@@ skipping 66 matching lines @@
   // Convenience variable; Subclass constructor only
   Variable* this_function_;
   // Module descriptor; module scopes only.
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_