Move zone_ to Scope

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"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 class ParseInfo;
 
 // A hash map to support fast variable declaration and lookup.
 class VariableMap: public ZoneHashMap {
  public:
   explicit VariableMap(Zone* zone);
 
-  virtual ~VariableMap();
-
-  Variable* Declare(Scope* scope, const AstRawString* name, VariableMode mode,
-                    Variable::Kind kind, InitializationFlag initialization_flag,
+  Variable* Declare(Zone* zone, Scope* scope, const AstRawString* name,
+                    VariableMode mode, Variable::Kind kind,
+                    InitializationFlag initialization_flag,
                     MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
 
   Variable* Lookup(const AstRawString* name);
-
-  Zone* zone() const { return zone_; }
-
- private:
-  Zone* zone_;
 };
 
 
 // The dynamic scope part holds hash maps for the variables that will
 // be looked up dynamically from within eval and with scopes. The objects
 // are allocated on-demand from Scope::NonLocal to avoid wasting memory
 // and setup time for scopes that don't need them.
 class DynamicScopePart : public ZoneObject {
  public:
   explicit DynamicScopePart(Zone* zone) {
     for (int i = 0; i < 3; i++)
       maps_[i] = new(zone->New(sizeof(VariableMap))) VariableMap(zone);
   }
 
   VariableMap* GetMap(VariableMode mode) {
     int index = mode - DYNAMIC;
     DCHECK(index >= 0 && index < 3);
     return maps_[index];
   }
 
  private:
   VariableMap *maps_[3];
 };
 
 
 // Sloppy block-scoped function declarations to var-bind
 class SloppyBlockFunctionMap : public ZoneHashMap {
  public:
   explicit SloppyBlockFunctionMap(Zone* zone);
-
-  virtual ~SloppyBlockFunctionMap();
-
-  void Declare(const AstRawString* name,
+  void Declare(Zone* zone, const AstRawString* name,
                SloppyBlockFunctionStatement* statement);
-
   typedef ZoneVector<SloppyBlockFunctionStatement*> Vector;
-
- private:
-  Zone* zone_;
 };
 
 
 // Global invariants after AST construction: Each reference (i.e. identifier)
 // to a JavaScript variable (including global properties) is represented by a
 // VariableProxy node. Immediately after AST construction and before variable
 // allocation, most VariableProxy nodes are "unresolved", i.e. not bound to a
 // corresponding variable (though some are bound during parse time). Variable
 // allocation binds each unresolved VariableProxy to one Variable and assigns
 // a location. Note that many VariableProxy nodes may refer to the same Java-
@@ skipping 59 matching lines @@
 
   // Inserts outer_scope into this scope's scope chain (and removes this
   // from the current outer_scope_'s inner scope list).
   // Assumes outer_scope_ is non-null.
   void ReplaceOuterScope(Scope* outer_scope);
 
   // Propagates any eagerly-gathered scope usage flags (such as calls_eval())
   // to the passed-in scope.
   void PropagateUsageFlagsToScope(Scope* other);
 
-  Zone* zone() const { return variables_.zone(); }
+  Zone* zone() const { return zone_; }
 
   // ---------------------------------------------------------------------------
   // Declarations
 
   // Lookup a variable in this scope. Returns the variable or NULL if not found.
   Variable* LookupLocal(const AstRawString* name);
 
   // Lookup a variable in this scope or outer scopes.
   // Returns the variable or NULL if not found.
   Variable* Lookup(const AstRawString* name);
@@ skipping 293 matching lines @@
   void CheckScopePositions();
 
   // Check that all Scopes in the scope tree use the same Zone.
   void CheckZones();
 #endif
 
   // Retrieve `IsSimpleParameterList` of current or outer function.
   bool HasSimpleParameters();
 
  private:
+  Zone* zone_;
+
   // 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 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.
@@ skipping 351 matching lines @@
   // adjusting the scope of temporaries used when desugaring parameter
   // initializers.
   void AddTemporary(Variable* var) {
     // 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);
+  }
+
   SloppyBlockFunctionMap* sloppy_block_function_map() {
     return &sloppy_block_function_map_;
   }
 
   // Resolve and fill in the allocation information for all variables
   // in this scopes. Must be called *after* all scopes have been
   // processed (parsed) to ensure that unresolved variables can be
   // resolved properly.
   //
   // In the case of code compiled and run using 'eval', the context
@@ skipping 50 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_