Remove the dependency of Zone on Isolate

src/ast.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_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 3125 matching lines @@
   void Visit(AstNode* node) FINAL {                         \
     if (!CheckStackOverflow()) node->Accept(this);          \
   }                                                         \
                                                             \
   void SetStackOverflow() { stack_overflow_ = true; }       \
   void ClearStackOverflow() { stack_overflow_ = false; }    \
   bool HasStackOverflow() const { return stack_overflow_; } \
                                                             \
   bool CheckStackOverflow() {                               \
     if (stack_overflow_) return true;                       \
-    StackLimitCheck check(zone_->isolate());                \
+    StackLimitCheck check(isolate_);                        \
     if (!check.HasOverflowed()) return false;               \
     stack_overflow_ = true;                                 \
     return true;                                            \
   }                                                         \
                                                             \
  private:                                                   \
-  void InitializeAstVisitor(Zone* zone) {                   \
+  void InitializeAstVisitor(Isolate* isolate, Zone* zone) { \
+    isolate_ = isolate;                                     \
     zone_ = zone;                                           \
     stack_overflow_ = false;                                \
   }                                                         \
   Zone* zone() { return zone_; }                            \
-  Isolate* isolate() { return zone_->isolate(); }           \
+  Isolate* isolate() { return isolate_; }                   \
                                                             \
+  Isolate* isolate_;                                        \
   Zone* zone_;                                              \
   bool stack_overflow_
 
 
 // ----------------------------------------------------------------------------
 // AstNode factory
 
 class AstNodeFactory FINAL BASE_EMBEDDED {
  public:
-  explicit AstNodeFactory(AstValueFactory* ast_value_factory)
+  explicit AstNodeFactory(Isolate* isolate, AstValueFactory* ast_value_factory)

[Michael Starzinger, 2015/01/23 14:21:10]

nit: The AstNodeFactory doesn't seem to use the Isolate, is there a particular
reason we need to pass it in?

[danno, 2015/01/23 14:45:19]

Done.

       : zone_(ast_value_factory->zone()),
         ast_value_factory_(ast_value_factory) {}
 
   VariableDeclaration* NewVariableDeclaration(VariableProxy* proxy,
                                               VariableMode mode,
                                               Scope* scope,
                                               int pos) {
     return new (zone_) VariableDeclaration(zone_, proxy, mode, scope, pos);
   }
 
@@ skipping 353 matching lines @@
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_