includes: Make ast.h not need isolate.h any more.

src/ast/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_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
 #include "src/bailout-reason.h"
 #include "src/base/flags.h"
-#include "src/factory.h"
 #include "src/globals.h"
-#include "src/isolate.h"
 #include "src/list.h"
 #include "src/parsing/token.h"
 #include "src/runtime/runtime.h"
 #include "src/small-pointer-list.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 // The abstract syntax tree is an intermediate, light-weight
@@ skipping 83 matching lines @@
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstNodeFactory;
 class Declaration;
 class Module;
 class BreakableStatement;
 class Expression;
 class IterationStatement;
+class Isolate;
 class MaterializedLiteral;
 class Statement;
 class TypeFeedbackOracle;
 
 #define DEF_FORWARD_DECLARATION(type) class type;
 AST_NODE_LIST(DEF_FORWARD_DECLARATION)
 #undef DEF_FORWARD_DECLARATION
 
 
 // Typedef only introduced to avoid unreadable code.
@@ skipping 2767 matching lines @@
   bool CheckStackOverflow() {                               \
     if (stack_overflow_) return true;                       \
     if (GetCurrentStackPosition() < stack_limit_) {         \
       stack_overflow_ = true;                               \
       return true;                                          \
     }                                                       \
     return false;                                           \
   }                                                         \
                                                             \
  private:                                                   \
-  void InitializeAstVisitor(Isolate* isolate) {             \
-    stack_limit_ = isolate->stack_guard()->real_climit();   \
-    stack_overflow_ = false;                                \
-  }                                                         \
-                                                            \
   void InitializeAstVisitor(uintptr_t stack_limit) {        \
     stack_limit_ = stack_limit;                             \
     stack_overflow_ = false;                                \
   }                                                         \
                                                             \
   uintptr_t stack_limit_;                                   \
   bool stack_overflow_
 
 #define DEFINE_AST_VISITOR_MEMBERS_WITHOUT_STACKOVERFLOW()    \
  public:                                                      \
   void Visit(AstNode* node) { GENERATE_AST_VISITOR_SWITCH() } \
                                                               \
  private:
 
 #define DEFINE_AST_REWRITER_SUBCLASS_MEMBERS()        \
  public:                                              \
   AstNode* Rewrite(AstNode* node) {                   \
     DCHECK_NULL(replacement_);                        \
     DCHECK_NOT_NULL(node);                            \
     Visit(node);                                      \
     if (HasStackOverflow()) return node;              \
     if (replacement_ == nullptr) return node;         \
     AstNode* result = replacement_;                   \
     replacement_ = nullptr;                           \
     return result;                                    \
   }                                                   \
                                                       \
  private:                                             \
-  void InitializeAstRewriter(Isolate* isolate) {      \
-    InitializeAstVisitor(isolate);                    \
-    replacement_ = nullptr;                           \
-  }                                                   \
-                                                      \
   void InitializeAstRewriter(uintptr_t stack_limit) { \
     InitializeAstVisitor(stack_limit);                \
     replacement_ = nullptr;                           \
   }                                                   \
                                                       \
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();              \
                                                       \
  protected:                                           \
   AstNode* replacement_
 // Generic macro for rewriting things; `GET` is the expression to be
@@ skipping 509 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_