iv-phonic 0.0.1 → 0.0.2

data/ext/include/iv/ast.h

@@ -12,6 +12,7 @@
 #include "ast-fwd.h"
 #include "ast-visitor.h"
 #include "source.h"
+#include "location.h"
 #include "ustringpiece.h"
 
 namespace iv {
@@ -29,12 +30,25 @@ namespace ast {
 
 #define DECLARE_NODE_TYPE(type) \
   inline const type<Factory>* As##type() const { return this; }\
-  inline type<Factory>* As##type() { return this; }
+  inline type<Factory>* As##type() { return this; }\
+
+#define DECLARE_DERIVED_NODE_TYPE(type) \
+  DECLARE_NODE_TYPE(type)\
+  ACCEPT_VISITOR\
+  inline NodeType Type() const { return k##type; }
 
 #define DECLARE_NODE_TYPE_BASE(type) \
   inline virtual const type<Factory>* As##type() const { return NULL; }\
   inline virtual type<Factory>* As##type() { return NULL; }
 
+enum NodeType {
+#define V(type)\
+  k##type,
+AST_DERIVED_NODE_LIST(V)
+#undef V
+  kNodeCount
+};
+
 template<typename Factory>
 class Scope : public SpaceObject,
               private Noncopyable<Scope<Factory> >::type {
@@ -81,64 +95,14 @@ class AstNode : public SpaceObject,
  public:
   virtual ~AstNode() = 0;
 
-  DECLARE_NODE_TYPE_BASE(Statement)
-  DECLARE_NODE_TYPE_BASE(Block)
-  DECLARE_NODE_TYPE_BASE(ExpressionStatement)
-  DECLARE_NODE_TYPE_BASE(EmptyStatement)
-  DECLARE_NODE_TYPE_BASE(VariableStatement)
-  DECLARE_NODE_TYPE_BASE(DebuggerStatement)
-  DECLARE_NODE_TYPE_BASE(FunctionStatement)
-  DECLARE_NODE_TYPE_BASE(IfStatement)
-  DECLARE_NODE_TYPE_BASE(IterationStatement)
-  DECLARE_NODE_TYPE_BASE(DoWhileStatement)
-  DECLARE_NODE_TYPE_BASE(WhileStatement)
-  DECLARE_NODE_TYPE_BASE(ForStatement)
-  DECLARE_NODE_TYPE_BASE(ForInStatement)
-  DECLARE_NODE_TYPE_BASE(ContinueStatement)
-  DECLARE_NODE_TYPE_BASE(BreakStatement)
-  DECLARE_NODE_TYPE_BASE(ReturnStatement)
-  DECLARE_NODE_TYPE_BASE(WithStatement)
-  DECLARE_NODE_TYPE_BASE(LabelledStatement)
-  DECLARE_NODE_TYPE_BASE(SwitchStatement)
-  DECLARE_NODE_TYPE_BASE(ThrowStatement)
-  DECLARE_NODE_TYPE_BASE(TryStatement)
-  DECLARE_NODE_TYPE_BASE(BreakableStatement)
-  DECLARE_NODE_TYPE_BASE(NamedOnlyBreakableStatement)
-  DECLARE_NODE_TYPE_BASE(AnonymousBreakableStatement)
-
-  DECLARE_NODE_TYPE_BASE(Expression)
-
-  DECLARE_NODE_TYPE_BASE(Literal)
-  DECLARE_NODE_TYPE_BASE(ThisLiteral)
-  DECLARE_NODE_TYPE_BASE(NullLiteral)
-  DECLARE_NODE_TYPE_BASE(FalseLiteral)
-  DECLARE_NODE_TYPE_BASE(TrueLiteral)
-  DECLARE_NODE_TYPE_BASE(Undefined)
-  DECLARE_NODE_TYPE_BASE(NumberLiteral)
-  DECLARE_NODE_TYPE_BASE(StringLiteral)
-  DECLARE_NODE_TYPE_BASE(Directivable)
-  DECLARE_NODE_TYPE_BASE(Identifier)
-  DECLARE_NODE_TYPE_BASE(RegExpLiteral)
-  DECLARE_NODE_TYPE_BASE(ArrayLiteral)
-  DECLARE_NODE_TYPE_BASE(ObjectLiteral)
-  DECLARE_NODE_TYPE_BASE(FunctionLiteral)
-
-  DECLARE_NODE_TYPE_BASE(UnaryOperation)
-  DECLARE_NODE_TYPE_BASE(PostfixExpression)
-  DECLARE_NODE_TYPE_BASE(Assignment)
-  DECLARE_NODE_TYPE_BASE(BinaryOperation)
-  DECLARE_NODE_TYPE_BASE(ConditionalExpression)
-  DECLARE_NODE_TYPE_BASE(PropertyAccess)
-  DECLARE_NODE_TYPE_BASE(IdentifierAccess)
-  DECLARE_NODE_TYPE_BASE(IndexAccess)
-  DECLARE_NODE_TYPE_BASE(Call)
-  DECLARE_NODE_TYPE_BASE(FunctionCall)
-  DECLARE_NODE_TYPE_BASE(ConstructorCall)
+  STATEMENT_NODE_LIST(DECLARE_NODE_TYPE_BASE)
+  EXPRESSION_NODE_LIST(DECLARE_NODE_TYPE_BASE)
 
   virtual void Accept(
       typename AstVisitor<Factory>::type* visitor) = 0;
   virtual void Accept(
       typename AstVisitor<Factory>::const_type* visitor) const = 0;
+  virtual NodeType Type() const = 0;
 };
 
 template<typename Factory>
@@ -186,17 +150,7 @@ class Statement : public AstNode<Factory> {
 template<typename Factory>
 class BreakableStatement : public Statement<Factory> {
  public:
-  typedef typename SpaceVector<Factory, Identifier<Factory>*>::type Identifiers;
-  BreakableStatement() : labels_(NULL) { }
-  void set_labels(Identifiers* labels) {
-    labels_ = labels;
-  }
-  Identifiers* labels() const {
-    return labels_;
-  }
   DECLARE_NODE_TYPE(BreakableStatement)
- protected:
-  Identifiers* labels_;
 };
 
 template<typename Factory>
@@ -225,8 +179,7 @@ class Block : public NamedOnlyBreakableStatement<Factory> {
   inline const Statements& body() const {
     return body_;
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(Block)
+  DECLARE_DERIVED_NODE_TYPE(Block)
  private:
   Statements body_;
 };
@@ -240,8 +193,7 @@ class FunctionStatement : public Statement<Factory> {
   inline FunctionLiteral<Factory>* function() const {
     return function_;
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(FunctionStatement)
+  DECLARE_DERIVED_NODE_TYPE(FunctionStatement)
  private:
   FunctionLiteral<Factory>* function_;
 };
@@ -266,15 +218,15 @@ class VariableStatement : public Statement<Factory> {
   inline bool IsConst() const {
     return is_const_;
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(VariableStatement)
+  DECLARE_DERIVED_NODE_TYPE(VariableStatement)
  private:
   const bool is_const_;
   Declarations decls_;
 };
 
 template<typename Factory>
-class Declaration : public AstNode<Factory> {
+class Declaration : public SpaceObject,
+                    private Noncopyable<Declaration<Factory> >::type {
  public:
   Declaration(Identifier<Factory>* name, Expression<Factory>* expr)
     : name_(name),
@@ -286,7 +238,6 @@ class Declaration : public AstNode<Factory> {
   inline Expression<Factory>* expr() const {
     return expr_;
   }
-  ACCEPT_VISITOR
  private:
   Identifier<Factory>* name_;
   Expression<Factory>* expr_;
@@ -295,26 +246,24 @@ class Declaration : public AstNode<Factory> {
 template<typename Factory>
 class EmptyStatement : public Statement<Factory> {
  public:
-  DECLARE_NODE_TYPE(EmptyStatement)
-  ACCEPT_VISITOR
+  DECLARE_DERIVED_NODE_TYPE(EmptyStatement)
 };
 
 template<typename Factory>
 class IfStatement : public Statement<Factory> {
  public:
-  IfStatement(Expression<Factory>* cond, Statement<Factory>* then)
+  IfStatement(Expression<Factory>* cond,
+              Statement<Factory>* then,
+              Statement<Factory>* elses)
     : cond_(cond),
       then_(then),
-      else_(NULL) {
-  }
-  void SetElse(Statement<Factory>* stmt) {
-    else_ = stmt;
+      else_(elses) {
+    // else maybe NULL
   }
   inline Expression<Factory>* cond() const { return cond_; }
   inline Statement<Factory>* then_statement() const { return then_; }
   inline Statement<Factory>* else_statement() const { return else_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(IfStatement)
+  DECLARE_DERIVED_NODE_TYPE(IfStatement)
  private:
   Expression<Factory>* cond_;
   Statement<Factory>* then_;
@@ -324,13 +273,10 @@ class IfStatement : public Statement<Factory> {
 template<typename Factory>
 class IterationStatement : public AnonymousBreakableStatement<Factory> {
  public:
-  IterationStatement()
-    : body_(NULL) {
+  explicit IterationStatement(Statement<Factory>* stmt)
+    : body_(stmt) {
   }
   inline Statement<Factory>* body() const { return body_; }
-  inline void set_body(Statement<Factory>* stmt) {
-    body_ = stmt;
-  }
   DECLARE_NODE_TYPE(IterationStatement)
  private:
   Statement<Factory>* body_;
@@ -339,16 +285,12 @@ class IterationStatement : public AnonymousBreakableStatement<Factory> {
 template<typename Factory>
 class DoWhileStatement : public IterationStatement<Factory> {
  public:
-  DoWhileStatement()
-    : IterationStatement<Factory>(),
-      cond_(NULL) {
+  DoWhileStatement(Statement<Factory>* body, Expression<Factory>* cond)
+    : IterationStatement<Factory>(body),
+      cond_(cond) {
   }
   inline Expression<Factory>* cond() const { return cond_; }
-  inline void set_cond(Expression<Factory>* expr) {
-    cond_ = expr;
-  }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(DoWhileStatement)
+  DECLARE_DERIVED_NODE_TYPE(DoWhileStatement)
  private:
   Expression<Factory>* cond_;
 };
@@ -356,13 +298,12 @@ class DoWhileStatement : public IterationStatement<Factory> {
 template<typename Factory>
 class WhileStatement : public IterationStatement<Factory> {
  public:
-  explicit WhileStatement(Expression<Factory>* cond)
-    : IterationStatement<Factory>(),
+  WhileStatement(Statement<Factory>* body, Expression<Factory>* cond)
+    : IterationStatement<Factory>(body),
       cond_(cond) {
   }
   inline Expression<Factory>* cond() const { return cond_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(WhileStatement)
+  DECLARE_DERIVED_NODE_TYPE(WhileStatement)
  private:
   Expression<Factory>* cond_;
 };
@@ -370,20 +311,19 @@ class WhileStatement : public IterationStatement<Factory> {
 template<typename Factory>
 class ForStatement : public IterationStatement<Factory> {
  public:
-  ForStatement()
-    : IterationStatement<Factory>(),
-      init_(NULL),
-      cond_(NULL),
-      next_(NULL) {
-  }
-  inline void SetInit(Statement<Factory>* init) { init_ = init; }
-  inline void SetCondition(Expression<Factory>* cond) { cond_ = cond; }
-  inline void SetNext(Statement<Factory>* next) { next_ = next; }
+  ForStatement(Statement<Factory>* body,
+               Statement<Factory>* init,
+               Expression<Factory>* cond,
+               Statement<Factory>* next)
+    : IterationStatement<Factory>(body),
+      init_(init),
+      cond_(cond),
+      next_(next) {
+  }
   inline Statement<Factory>* init() const { return init_; }
   inline Expression<Factory>* cond() const { return cond_; }
   inline Statement<Factory>* next() const { return next_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ForStatement)
+  DECLARE_DERIVED_NODE_TYPE(ForStatement)
  private:
   Statement<Factory>* init_;
   Expression<Factory>* cond_;
@@ -393,16 +333,16 @@ class ForStatement : public IterationStatement<Factory> {
 template<typename Factory>
 class ForInStatement : public IterationStatement<Factory> {
  public:
-  ForInStatement(Statement<Factory>* each,
+  ForInStatement(Statement<Factory>* body,
+                 Statement<Factory>* each,
                  Expression<Factory>* enumerable)
-    : IterationStatement<Factory>(),
+    : IterationStatement<Factory>(body),
       each_(each),
       enumerable_(enumerable) {
   }
   inline Statement<Factory>* each() const { return each_; }
   inline Expression<Factory>* enumerable() const { return enumerable_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ForInStatement)
+  DECLARE_DERIVED_NODE_TYPE(ForInStatement)
  private:
   Statement<Factory>* each_;
   Expression<Factory>* enumerable_;
@@ -411,48 +351,41 @@ class ForInStatement : public IterationStatement<Factory> {
 template<typename Factory>
 class ContinueStatement : public Statement<Factory> {
  public:
-  ContinueStatement()
-    : label_(NULL) {
-  }
-
-  void SetLabel(Identifier<Factory>* label) {
-    label_ = label;
-  }
-
-  void SetTarget(IterationStatement<Factory>* target) {
-    target_ = target;
+  ContinueStatement(Identifier<Factory>* label,
+                    IterationStatement<Factory>** target)
+    : label_(label),
+      target_(target) {
+    assert(target_);
   }
   inline Identifier<Factory>* label() const { return label_; }
-  inline IterationStatement<Factory>* target() const { return target_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ContinueStatement)
+  inline IterationStatement<Factory>* target() const {
+    assert(target_ && *target_);
+    return *target_;
+  }
+  DECLARE_DERIVED_NODE_TYPE(ContinueStatement)
  private:
   Identifier<Factory>* label_;
-  IterationStatement<Factory>* target_;
+  IterationStatement<Factory>** target_;
 };
 
 template<typename Factory>
 class BreakStatement : public Statement<Factory> {
  public:
-  BreakStatement()
-    : label_(NULL),
-      target_(NULL) {
-  }
-
-  void SetLabel(Identifier<Factory>* label) {
-    label_ = label;
-  }
-
-  void SetTarget(BreakableStatement<Factory>* target) {
-    target_ = target;
+  BreakStatement(Identifier<Factory>* label,
+                 BreakableStatement<Factory>** target)
+    : label_(label),
+      target_(target) {
+    assert(target_);
   }
   inline Identifier<Factory>* label() const { return label_; }
-  inline BreakableStatement<Factory>* target() const { return target_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(BreakStatement)
+  inline BreakableStatement<Factory>* target() const {
+    assert(target_ && *target_);
+    return *target_;
+  }
+  DECLARE_DERIVED_NODE_TYPE(BreakStatement)
  private:
   Identifier<Factory>* label_;
-  BreakableStatement<Factory>* target_;
+  BreakableStatement<Factory>** target_;
 };
 
 template<typename Factory>
@@ -462,8 +395,7 @@ class ReturnStatement : public Statement<Factory> {
     : expr_(expr) {
   }
   inline Expression<Factory>* expr() const { return expr_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ReturnStatement)
+  DECLARE_DERIVED_NODE_TYPE(ReturnStatement)
  private:
   Expression<Factory>* expr_;
 };
@@ -478,8 +410,7 @@ class WithStatement : public Statement<Factory> {
   }
   inline Expression<Factory>* context() const { return context_; }
   inline Statement<Factory>* body() const { return body_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(WithStatement)
+  DECLARE_DERIVED_NODE_TYPE(WithStatement)
  private:
   Expression<Factory>* context_;
   Statement<Factory>* body_;
@@ -494,31 +425,23 @@ class LabelledStatement : public Statement<Factory> {
   }
   inline Identifier<Factory>* label() const { return label_; }
   inline Statement<Factory>* body() const { return body_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(LabelledStatement)
+  DECLARE_DERIVED_NODE_TYPE(LabelledStatement)
  private:
   Identifier<Factory>* label_;
   Statement<Factory>* body_;
 };
 
 template<typename Factory>
-class CaseClause : public AstNode<Factory> {
+class CaseClause : public SpaceObject,
+                   private Noncopyable<CaseClause<Factory> >::type {
  public:
   typedef typename SpaceVector<Factory, Statement<Factory>*>::type Statements;
-  explicit CaseClause(Factory* factory)
-    : expr_(NULL),
+  explicit CaseClause(bool is_default,
+                      Expression<Factory>* expr, Factory* factory)
+    : expr_(expr),
       body_(typename Statements::allocator_type(factory)),
-      default_(false) {
-  }
-
-  void SetExpression(Expression<Factory>* expr) {
-    expr_ = expr;
-  }
-
-  void SetDefault() {
-    default_ = true;
+      default_(is_default) {
   }
-
   void AddStatement(Statement<Factory>* stmt) {
     body_.push_back(stmt);
   }
@@ -531,7 +454,6 @@ class CaseClause : public AstNode<Factory> {
   inline const Statements& body() const {
     return body_;
   }
-  ACCEPT_VISITOR
  private:
   Expression<Factory>* expr_;
   Statements body_;
@@ -553,8 +475,7 @@ class SwitchStatement : public AnonymousBreakableStatement<Factory> {
   }
   inline Expression<Factory>* expr() const { return expr_; }
   inline const CaseClauses& clauses() const { return clauses_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(SwitchStatement)
+  DECLARE_DERIVED_NODE_TYPE(SwitchStatement)
  private:
   Expression<Factory>* expr_;
   CaseClauses clauses_;
@@ -567,8 +488,7 @@ class ThrowStatement : public Statement<Factory> {
     : expr_(expr) {
   }
   inline Expression<Factory>* expr() const { return expr_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ThrowStatement)
+  DECLARE_DERIVED_NODE_TYPE(ThrowStatement)
  private:
   Expression<Factory>* expr_;
 };
@@ -576,27 +496,20 @@ class ThrowStatement : public Statement<Factory> {
 template<typename Factory>
 class TryStatement : public Statement<Factory> {
  public:
-  explicit TryStatement(Block<Factory>* block)
-    : body_(block),
-      catch_name_(NULL),
-      catch_block_(NULL),
-      finally_block_(NULL) {
-  }
-
-  void SetCatch(Identifier<Factory>* name, Block<Factory>* block) {
-    catch_name_ = name;
-    catch_block_ = block;
-  }
-
-  void SetFinally(Block<Factory>* block) {
-    finally_block_ = block;
+  explicit TryStatement(Block<Factory>* try_block,
+                        Identifier<Factory>* catch_name,
+                        Block<Factory>* catch_block,
+                        Block<Factory>* finally_block)
+    : body_(try_block),
+      catch_name_(catch_name),
+      catch_block_(catch_block),
+      finally_block_(finally_block) {
   }
   inline Block<Factory>* body() const { return body_; }
   inline Identifier<Factory>* catch_name() const { return catch_name_; }
   inline Block<Factory>* catch_block() const { return catch_block_; }
   inline Block<Factory>* finally_block() const { return finally_block_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(TryStatement)
+  DECLARE_DERIVED_NODE_TYPE(TryStatement)
  private:
   Block<Factory>* body_;
   Identifier<Factory>* catch_name_;
@@ -606,8 +519,7 @@ class TryStatement : public Statement<Factory> {
 
 template<typename Factory>
 class DebuggerStatement : public Statement<Factory> {
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(DebuggerStatement)
+  DECLARE_DERIVED_NODE_TYPE(DebuggerStatement)
 };
 
 template<typename Factory>
@@ -615,8 +527,7 @@ class ExpressionStatement : public Statement<Factory> {
  public:
   explicit ExpressionStatement(Expression<Factory>* expr) : expr_(expr) { }
   inline Expression<Factory>* expr() const { return expr_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ExpressionStatement)
+  DECLARE_DERIVED_NODE_TYPE(ExpressionStatement)
  private:
   Expression<Factory>* expr_;
 };
@@ -633,8 +544,7 @@ class Assignment : public Expression<Factory> {
   inline Token::Type op() const { return op_; }
   inline Expression<Factory>* left() const { return left_; }
   inline Expression<Factory>* right() const { return right_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(Assignment)
+  DECLARE_DERIVED_NODE_TYPE(Assignment)
  private:
   Token::Type op_;
   Expression<Factory>* left_;
@@ -653,8 +563,7 @@ class BinaryOperation : public Expression<Factory> {
   inline Token::Type op() const { return op_; }
   inline Expression<Factory>* left() const { return left_; }
   inline Expression<Factory>* right() const { return right_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(BinaryOperation)
+  DECLARE_DERIVED_NODE_TYPE(BinaryOperation)
  private:
   Token::Type op_;
   Expression<Factory>* left_;
@@ -672,8 +581,7 @@ class ConditionalExpression : public Expression<Factory> {
   inline Expression<Factory>* cond() const { return cond_; }
   inline Expression<Factory>* left() const { return left_; }
   inline Expression<Factory>* right() const { return right_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ConditionalExpression)
+  DECLARE_DERIVED_NODE_TYPE(ConditionalExpression)
  private:
   Expression<Factory>* cond_;
   Expression<Factory>* left_;
@@ -689,8 +597,7 @@ class UnaryOperation : public Expression<Factory> {
   }
   inline Token::Type op() const { return op_; }
   inline Expression<Factory>* expr() const { return expr_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(UnaryOperation)
+  DECLARE_DERIVED_NODE_TYPE(UnaryOperation)
  private:
   Token::Type op_;
   Expression<Factory>* expr_;
@@ -705,8 +612,7 @@ class PostfixExpression : public Expression<Factory> {
   }
   inline Token::Type op() const { return op_; }
   inline Expression<Factory>* expr() const { return expr_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(PostfixExpression)
+  DECLARE_DERIVED_NODE_TYPE(PostfixExpression)
  private:
   Token::Type op_;
   Expression<Factory>* expr_;
@@ -726,8 +632,7 @@ class StringLiteral : public Literal<Factory> {
   inline const value_type& value() const {
     return value_;
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(StringLiteral)
+  DECLARE_DERIVED_NODE_TYPE(StringLiteral)
  private:
   const value_type value_;
 };
@@ -748,8 +653,7 @@ class NumberLiteral : public Literal<Factory> {
     : value_(val) {
   }
   inline double value() const { return value_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(NumberLiteral)
+  DECLARE_DERIVED_NODE_TYPE(NumberLiteral)
  private:
   double value_;
 };
@@ -758,27 +662,17 @@ template<typename Factory>
 class Identifier : public Literal<Factory> {
  public:
   typedef typename SpaceUString<Factory>::type value_type;
-  Identifier(const UStringPiece& buffer, Factory* factory)
-    : value_(buffer.data(),
-             buffer.size(),
-             typename value_type::allocator_type(factory)) {
-    }
-  Identifier(const std::vector<uc16>& buffer, Factory* factory)
-    : value_(buffer.data(),
-             buffer.size(),
-             typename value_type::allocator_type(factory)) {
-  }
-  Identifier(const std::vector<char>& buffer, Factory* factory)
-    : value_(buffer.begin(),
-             buffer.end(),
+  template<typename Range>
+  Identifier(const Range& range, Factory* factory)
+    : value_(range.begin(),
+             range.end(),
              typename value_type::allocator_type(factory)) {
   }
   inline const value_type& value() const {
     return value_;
   }
   inline bool IsValidLeftHandSide() const { return true; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(Identifier)
+  DECLARE_DERIVED_NODE_TYPE(Identifier)
  protected:
   value_type value_;
 };
@@ -821,36 +715,31 @@ class IdentifierKey {
 template<typename Factory>
 class ThisLiteral : public Literal<Factory> {
  public:
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ThisLiteral)
+  DECLARE_DERIVED_NODE_TYPE(ThisLiteral)
 };
 
 template<typename Factory>
 class NullLiteral : public Literal<Factory> {
  public:
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(NullLiteral)
+  DECLARE_DERIVED_NODE_TYPE(NullLiteral)
 };
 
 template<typename Factory>
 class TrueLiteral : public Literal<Factory> {
  public:
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(TrueLiteral)
+  DECLARE_DERIVED_NODE_TYPE(TrueLiteral)
 };
 
 template<typename Factory>
 class FalseLiteral : public Literal<Factory> {
  public:
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(FalseLiteral)
+  DECLARE_DERIVED_NODE_TYPE(FalseLiteral)
 };
 
 template<typename Factory>
 class Undefined : public Literal<Factory> {
  public:
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(Undefined)
+  DECLARE_DERIVED_NODE_TYPE(Undefined)
 };
 
 template<typename Factory>
@@ -868,8 +757,7 @@ class RegExpLiteral : public Literal<Factory> {
   }
   inline const value_type& value() const { return value_; }
   inline const value_type& flags() const { return flags_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(RegExpLiteral)
+  DECLARE_DERIVED_NODE_TYPE(RegExpLiteral)
  protected:
   value_type value_;
   value_type flags_;
@@ -889,8 +777,7 @@ class ArrayLiteral : public Literal<Factory> {
   inline const Expressions& items() const {
     return items_;
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ArrayLiteral)
+  DECLARE_DERIVED_NODE_TYPE(ArrayLiteral)
  private:
   Expressions items_;
 };
@@ -923,8 +810,7 @@ class ObjectLiteral : public Literal<Factory> {
   inline const Properties& properties() const {
     return properties_;
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ObjectLiteral)
+  DECLARE_DERIVED_NODE_TYPE(ObjectLiteral)
  private:
   inline void AddPropertyDescriptor(PropertyDescriptorType type,
                                     Identifier<Factory>* key,
@@ -1008,8 +894,7 @@ class FunctionLiteral : public Literal<Factory> {
   void AddStatement(Statement<Factory>* stmt) {
     body_.push_back(stmt);
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(FunctionLiteral)
+  DECLARE_DERIVED_NODE_TYPE(FunctionLiteral)
  private:
   Identifier<Factory>* name_;
   DeclType type_;
@@ -1044,8 +929,7 @@ class IdentifierAccess : public PropertyAccess<Factory> {
       key_(key) {
   }
   inline Identifier<Factory>* key() const { return key_; }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(IdentifierAccess)
+  DECLARE_DERIVED_NODE_TYPE(IdentifierAccess)
  private:
   Identifier<Factory>* key_;
 };
@@ -1059,8 +943,7 @@ class IndexAccess : public PropertyAccess<Factory> {
       key_(key) {
   }
   inline Expression<Factory>* key() const { return key_; }
-  DECLARE_NODE_TYPE(IndexAccess)
-  ACCEPT_VISITOR
+  DECLARE_DERIVED_NODE_TYPE(IndexAccess)
  private:
   Expression<Factory>* key_;
 };
@@ -1091,8 +974,7 @@ class FunctionCall : public Call<Factory> {
                Factory* factory)
     : Call<Factory>(target, factory) {
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(FunctionCall)
+  DECLARE_DERIVED_NODE_TYPE(FunctionCall)
 };
 
 template<typename Factory>
@@ -1102,8 +984,7 @@ class ConstructorCall : public Call<Factory> {
                   Factory* factory)
     : Call<Factory>(target, factory) {
   }
-  ACCEPT_VISITOR
-  DECLARE_NODE_TYPE(ConstructorCall)
+  DECLARE_DERIVED_NODE_TYPE(ConstructorCall)
 };
 
 } } }  // namespace iv::core::ast
@@ -1121,7 +1002,4 @@ struct hash<iv::core::ast::IdentifierKey<Factory> >
   }
 };
 } }  // namespace std::tr1
-#undef ACCEPT_VISITOR
-#undef DECLARE_NODE_TYPE
-#undef DECLARE_NODE_TYPE_BASE
 #endif  // _IV_AST_H_