Make the parser agnostic to the TokenStream implementation. This is the first step towards compacti…

vm/ast.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_AST_H_
 #define VM_AST_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
@@ skipping 77 matching lines @@
   virtual void Visit(AstNodeVisitor* visitor);                                 \
   virtual const char* ShortName() const;                                       \
   virtual bool Is##type() const { return true; }                               \
   virtual type* As##type() { return this; }
 
 
 class AstNode : public ZoneAllocated {
  public:
   static const int kNoId = -1;
 
-  explicit AstNode(intptr_t token_index)
-      : token_index_(token_index),
+  explicit AstNode(intptr_t token_pos)
+      : token_pos_(token_pos),
         id_(GetNextId()),
         ic_data_(ICData::ZoneHandle()),
         info_(NULL) {
-    ASSERT(token_index >= 0);
+    ASSERT(token_pos >= 0);
   }
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
 
 
   const ICData& ic_data() const { return ic_data_; }
   void set_ic_data(const ICData& value) {
     ic_data_ = value.raw();
   }
 
   intptr_t id() const { return id_; }
 
   void set_info(CodeGenInfo* info) { info_ = info; }
@@ skipping 42 matching lines @@
   friend class ParsedFunction;
 
   static intptr_t GetNextId() {
     Isolate* isolate = Isolate::Current();
     intptr_t tmp = isolate->ast_node_id();
     isolate->set_ast_node_id(tmp + 1);
     return tmp;
   }
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   // Unique id per function compiled, used to match AST node to a PC.
   const intptr_t id_;
   // IC data collected for this node.
   ICData& ic_data_;
   // Used by optimizing compiler.
   CodeGenInfo* info_;
   DISALLOW_COPY_AND_ASSIGN(AstNode);
 };
 
 
 class SequenceNode : public AstNode {
  public:
-  SequenceNode(intptr_t token_index, LocalScope* scope)
-    : AstNode(token_index),
+  SequenceNode(intptr_t token_pos, LocalScope* scope)
+    : AstNode(token_pos),
       scope_(scope),
       nodes_(4),
       label_(NULL),
       first_parameter_id_(AstNode::kNoId),
       last_parameter_id_(AstNode::kNoId) {
   }
 
   LocalScope* scope() const { return scope_; }
 
   SourceLabel* label() const { return label_; }
@@ skipping 25 matching lines @@
   SourceLabel* label_;
   intptr_t first_parameter_id_;
   intptr_t last_parameter_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SequenceNode);
 };
 
 
 class CloneContextNode : public AstNode {
  public:
-  explicit CloneContextNode(intptr_t token_index)
-    : AstNode(token_index) {
+  explicit CloneContextNode(intptr_t token_pos)
+    : AstNode(token_pos) {
   }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   DECLARE_COMMON_NODE_FUNCTIONS(CloneContextNode);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloneContextNode);
 };
 
 
 class ArgumentListNode : public AstNode {
  public:
-  explicit ArgumentListNode(intptr_t token_index)
-     : AstNode(token_index),
+  explicit ArgumentListNode(intptr_t token_pos)
+     : AstNode(token_pos),
        nodes_(4),
        names_(Array::ZoneHandle()) {
   }
 
   void VisitChildren(AstNodeVisitor* visitor) const;
 
   void Add(AstNode* node) {
     nodes_.Add(node);
   }
   intptr_t length() const { return nodes_.length(); }
@@ skipping 11 matching lines @@
  private:
   GrowableArray<AstNode*> nodes_;
   Array& names_;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentListNode);
 };
 
 
 class ArrayNode : public AstNode {
  public:
-  ArrayNode(intptr_t token_index, const AbstractTypeArguments& type_arguments)
-      : AstNode(token_index),
+  ArrayNode(intptr_t token_pos, const AbstractTypeArguments& type_arguments)
+      : AstNode(token_pos),
         type_arguments_(type_arguments),
         elements_(4) {
     ASSERT(type_arguments_.IsZoneHandle());
   }
 
   void VisitChildren(AstNodeVisitor* visitor) const;
 
   intptr_t length() const { return elements_.length(); }
 
   AstNode* ElementAt(intptr_t index) const { return elements_[index]; }
@@ skipping 11 matching lines @@
  private:
   const AbstractTypeArguments& type_arguments_;
   GrowableArray<AstNode*> elements_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayNode);
 };
 
 
 class LiteralNode : public AstNode {
  public:
-  LiteralNode(intptr_t token_index, const Instance& literal)
-      : AstNode(token_index), literal_(literal) {
+  LiteralNode(intptr_t token_pos, const Instance& literal)
+      : AstNode(token_pos), literal_(literal) {
     ASSERT(literal.IsZoneHandle());
 #if defined(DEBUG)
     if (literal.IsString()) {
       String& str = String::Handle();
       str ^= literal.raw();
       ASSERT(str.IsSymbol());
     }
 #endif  // defined(DEBUG)
     ASSERT(literal.IsNull() ||
            Class::Handle(literal.clazz()).is_finalized() ||
@@ skipping 14 matching lines @@
 
  private:
   const Instance& literal_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LiteralNode);
 };
 
 
 class TypeNode : public AstNode {
  public:
-  TypeNode(intptr_t token_index, const AbstractType& type)
-      : AstNode(token_index), type_(type) {
+  TypeNode(intptr_t token_pos, const AbstractType& type)
+      : AstNode(token_pos), type_(type) {
     ASSERT(type.IsZoneHandle());
     ASSERT(!type.IsNull());
     ASSERT(type.IsFinalized());
   }
 
   const AbstractType& type() const { return type_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   DECLARE_COMMON_NODE_FUNCTIONS(TypeNode);
 
  private:
   const AbstractType& type_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeNode);
 };
 
 
 class AssignableNode : public AstNode {
  public:
-  AssignableNode(intptr_t token_index,
+  AssignableNode(intptr_t token_pos,
                  AstNode* expr,
                  const AbstractType& type,
                  const String& dst_name)
-      : AstNode(token_index), expr_(expr), type_(type), dst_name_(dst_name) {
+      : AstNode(token_pos), expr_(expr), type_(type), dst_name_(dst_name) {
     ASSERT(expr_ != NULL);
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
     ASSERT(dst_name_.IsZoneHandle());
   }
 
   AstNode* expr() const { return expr_; }
   const AbstractType& type() const { return type_; }
   const String& dst_name() const { return dst_name_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     expr()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(AssignableNode);
 
  private:
   AstNode* expr_;
   const AbstractType& type_;
   const String& dst_name_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AssignableNode);
 };
 
 
 class ClosureNode : public AstNode {
  public:
-  ClosureNode(intptr_t token_index,
+  ClosureNode(intptr_t token_pos,
               const Function& function,
               AstNode* receiver,  // Non-null for implicit instance closures.
               LocalScope* scope)  // Null for implicit closures.
-      : AstNode(token_index),
+      : AstNode(token_pos),
         function_(function),
         receiver_(receiver),
         scope_(scope) {
     ASSERT(function.IsZoneHandle());
     ASSERT((function.IsNonImplicitClosureFunction() &&
             (receiver_ == NULL) && (scope_ != NULL)) ||
            (function.IsImplicitInstanceClosureFunction() &&
             (receiver_ != NULL) && (scope_ == NULL)) ||
            (function.IsImplicitStaticClosureFunction() &&
             (receiver_ == NULL) && (scope_ == NULL)));
@@ skipping 19 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(ClosureNode);
 };
 
 
 // Primary nodes hold identifiers or values (library, class or function)
 // resolved from an identifier. Primary nodes should not ever make it to the
 // code generation phase as they will be transformed into the correct call or
 // field access nodes.
 class PrimaryNode : public AstNode {
  public:
-  PrimaryNode(intptr_t token_index, const Object& primary)
-      : AstNode(token_index), primary_(primary) {
+  PrimaryNode(intptr_t token_pos, const Object& primary)
+      : AstNode(token_pos), primary_(primary) {
     ASSERT(primary.IsZoneHandle());
   }
 
   const Object& primary() const { return primary_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(PrimaryNode);
 
  private:
   const Object& primary_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PrimaryNode);
 };
 
 
 class ReturnNode : public AstNode {
  public:
   // Return from a void function returns the null object.
-  explicit ReturnNode(intptr_t token_index)
-      : AstNode(token_index),
-        value_(new LiteralNode(token_index, Instance::ZoneHandle())),
+  explicit ReturnNode(intptr_t token_pos)
+      : AstNode(token_pos),
+        value_(new LiteralNode(token_pos, Instance::ZoneHandle())),
         inlined_finally_list_() { }
   // Return from a non-void function.
-  ReturnNode(intptr_t token_index,
+  ReturnNode(intptr_t token_pos,
              AstNode* value)
-      : AstNode(token_index), value_(value), inlined_finally_list_() {
+      : AstNode(token_pos), value_(value), inlined_finally_list_() {
     ASSERT(value != NULL);
   }
 
   AstNode* value() const { return value_; }
 
   intptr_t inlined_finally_list_length() const {
     return inlined_finally_list_.length();
   }
   InlinedFinallyNode* InlinedFinallyNodeAt(intptr_t index) const {
     return inlined_finally_list_[index];
@@ skipping 13 matching lines @@
  private:
   AstNode* value_;
   GrowableArray<InlinedFinallyNode*> inlined_finally_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnNode);
 };
 
 
 class ComparisonNode : public AstNode {
  public:
-  ComparisonNode(intptr_t token_index,
+  ComparisonNode(intptr_t token_pos,
                  Token::Kind kind,
                  AstNode* left,
                  AstNode* right)
-  : AstNode(token_index), kind_(kind), left_(left), right_(right) {
+  : AstNode(token_pos), kind_(kind), left_(left), right_(right) {
     ASSERT(left_ != NULL);
     ASSERT(right_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
   AstNode* left() const { return left_; }
   AstNode* right() const { return right_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
@@ skipping 12 matching lines @@
   AstNode* right_;
 
   bool IsKindValid() const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ComparisonNode);
 };
 
 
 class BinaryOpNode : public AstNode {
  public:
-  BinaryOpNode(intptr_t token_index,
+  BinaryOpNode(intptr_t token_pos,
                Token::Kind kind,
                AstNode* left,
                AstNode* right)
-      : AstNode(token_index), kind_(kind), left_(left), right_(right) {
+      : AstNode(token_pos), kind_(kind), left_(left), right_(right) {
     ASSERT(left_ != NULL);
     ASSERT(right_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
   AstNode* left() const { return left_; }
   AstNode* right() const { return right_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
@@ skipping 12 matching lines @@
   AstNode* right_;
 
   bool IsKindValid() const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BinaryOpNode);
 };
 
 
 class StringConcatNode : public AstNode {
  public:
-  explicit StringConcatNode(intptr_t token_index)
-      : AstNode(token_index),
-        values_(new ArrayNode(token_index, TypeArguments::ZoneHandle())) {
+  explicit StringConcatNode(intptr_t token_pos)
+      : AstNode(token_pos),
+        values_(new ArrayNode(token_pos, TypeArguments::ZoneHandle())) {
   }
 
   ArrayNode* values() const { return values_; }
 
   virtual const Instance* EvalConstExpr() const;
 
   void AddExpr(AstNode* expr) const {
     values_->AddElement(expr);
   }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     values_->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StringConcatNode);
 
  private:
   ArrayNode* values_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringConcatNode);
 };
 
 
 class UnaryOpNode : public AstNode {
  public:
   // Returns optimized version, e.g., for ('-' '1') ('-1') literal is returned.
-  static AstNode* UnaryOpOrLiteral(intptr_t token_index,
+  static AstNode* UnaryOpOrLiteral(intptr_t token_pos,
                                    Token::Kind kind,
                                    AstNode* operand);
-  UnaryOpNode(intptr_t token_index,
+  UnaryOpNode(intptr_t token_pos,
               Token::Kind kind,
               AstNode* operand)
-      : AstNode(token_index), kind_(kind), operand_(operand) {
+      : AstNode(token_pos), kind_(kind), operand_(operand) {
     ASSERT(operand_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
   AstNode* operand() const { return operand_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     operand()->Visit(visitor);
   }
 
   virtual const char* Name() const;
   virtual const Instance* EvalConstExpr() const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(UnaryOpNode);
 
  private:
   const Token::Kind kind_;
   AstNode* operand_;
 
   bool IsKindValid() const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(UnaryOpNode);
 };
 
 
 class ConditionalExprNode : public AstNode {
  public:
-  ConditionalExprNode(intptr_t token_index,
+  ConditionalExprNode(intptr_t token_pos,
                       AstNode* condition,
                       AstNode* true_expr,
                       AstNode* false_expr)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         condition_(condition),
         true_expr_(true_expr),
         false_expr_(false_expr) {
       ASSERT(condition_ != NULL);
       ASSERT(true_expr_ != NULL);
       ASSERT(false_expr_ != NULL);
   }
 
   AstNode* condition() const { return condition_; }
   AstNode* true_expr() const { return true_expr_; }
@@ skipping 20 matching lines @@
   AstNode* condition_;
   AstNode* true_expr_;
   AstNode* false_expr_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ConditionalExprNode);
 };
 
 
 class IfNode : public AstNode {
  public:
-  IfNode(intptr_t token_index,
+  IfNode(intptr_t token_pos,
          AstNode* condition,
          SequenceNode* true_branch,
          SequenceNode* false_branch)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         condition_(condition),
         true_branch_(true_branch),
         false_branch_(false_branch) {
       ASSERT(condition_ != NULL);
   }
 
   AstNode* condition() const { return condition_; }
   SequenceNode* true_branch() const { return true_branch_; }
   SequenceNode* false_branch() const { return false_branch_; }
 
@@ skipping 11 matching lines @@
   AstNode* condition_;
   SequenceNode* true_branch_;
   SequenceNode* false_branch_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(IfNode);
 };
 
 
 class CaseNode : public AstNode {
  public:
-  CaseNode(intptr_t token_index,
+  CaseNode(intptr_t token_pos,
            SourceLabel* label,
            SequenceNode* case_expressions,
            bool contains_default,
            LocalVariable* switch_expr_value,
            SequenceNode* statements)
-    : AstNode(token_index),
+    : AstNode(token_pos),
       label_(label),
       case_expressions_(case_expressions),
       contains_default_(contains_default),
       switch_expr_value_(switch_expr_value),
       statements_(statements) {
     // label may be NULL.
     ASSERT(case_expressions_ != NULL);
     ASSERT(switch_expr_value_ != NULL);
     ASSERT(statements_ != NULL);
   }
@@ skipping 17 matching lines @@
   bool contains_default_;
   LocalVariable* switch_expr_value_;
   SequenceNode* statements_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaseNode);
 };
 
 
 class SwitchNode : public AstNode {
  public:
-  SwitchNode(intptr_t token_index,
+  SwitchNode(intptr_t token_pos,
              SourceLabel* label,
              SequenceNode* body)
-    : AstNode(token_index),
+    : AstNode(token_pos),
       label_(label),
       body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   AstNode* body() const { return body_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     body()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(SwitchNode);
 
  private:
   SourceLabel* label_;
   AstNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SwitchNode);
 };
 
 
 class WhileNode : public AstNode {
  public:
-  WhileNode(intptr_t token_index,
+  WhileNode(intptr_t token_pos,
             SourceLabel* label,
             AstNode* condition,
             SequenceNode* body)
-    : AstNode(token_index),
+    : AstNode(token_pos),
       label_(label),
       condition_(condition),
       body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(condition_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   AstNode* condition() const { return condition_; }
@@ skipping 10 matching lines @@
   SourceLabel* label_;
   AstNode* condition_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WhileNode);
 };
 
 
 class DoWhileNode : public AstNode {
  public:
-  DoWhileNode(intptr_t token_index,
+  DoWhileNode(intptr_t token_pos,
               SourceLabel* label,
               AstNode* condition,
               SequenceNode* body)
-    : AstNode(token_index),
+    : AstNode(token_pos),
       label_(label),
       condition_(condition),
       body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(condition_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   AstNode* condition() const { return condition_; }
@@ skipping 11 matching lines @@
   AstNode* condition_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DoWhileNode);
 };
 
 
 // initializer, condition, increment expressions can be NULL.
 class ForNode : public AstNode {
  public:
-  ForNode(intptr_t token_index,
+  ForNode(intptr_t token_pos,
           SourceLabel* label,
           SequenceNode* initializer,
           AstNode* condition,
           SequenceNode* increment,
           SequenceNode* body)
-    : AstNode(token_index),
+    : AstNode(token_pos),
       label_(label),
       initializer_(initializer),
       condition_(condition),
       increment_(increment),
       body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(initializer_ != NULL);
     ASSERT(increment_ != NULL);
     ASSERT(body_ != NULL);
   }
@@ skipping 21 matching lines @@
   AstNode* condition_;
   SequenceNode* increment_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ForNode);
 };
 
 
 class JumpNode : public AstNode {
  public:
-  JumpNode(intptr_t token_index,
+  JumpNode(intptr_t token_pos,
            Token::Kind kind,
            SourceLabel* label)
-    : AstNode(token_index),
+    : AstNode(token_pos),
       kind_(kind),
       label_(label),
       inlined_finally_list_(NULL) {
     ASSERT(label_ != NULL);
     ASSERT(kind_ == Token::kBREAK || kind_ == Token::kCONTINUE);
     if (kind_ == Token::kCONTINUE) {
       label_->set_is_continue_target(true);
     }
   }
 
@@ skipping 19 matching lines @@
  private:
   Token::Kind kind_;
   SourceLabel* label_;
   GrowableArray<InlinedFinallyNode*> inlined_finally_list_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(JumpNode);
 };
 
 
 class LoadLocalNode : public AstNode {
  public:
-  LoadLocalNode(intptr_t token_index, const LocalVariable& local)
-      : AstNode(token_index), local_(local), pseudo_(NULL) { }
+  LoadLocalNode(intptr_t token_pos, const LocalVariable& local)
+      : AstNode(token_pos), local_(local), pseudo_(NULL) { }
   // The pseudo node does not produce input but must be visited before
   // completing local load.
-  LoadLocalNode(intptr_t token_index,
+  LoadLocalNode(intptr_t token_pos,
                 const LocalVariable& local,
                 AstNode* pseudo)
-      : AstNode(token_index), local_(local), pseudo_(pseudo) {}
+      : AstNode(token_pos), local_(local), pseudo_(pseudo) {}
 
   const LocalVariable& local() const { return local_; }
   AstNode* pseudo() const { return pseudo_; }  // Can be NULL.
   bool HasPseudo() const { return pseudo_ != NULL; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     if (HasPseudo()) {
       pseudo()->Visit(visitor);
     }
   }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadLocalNode);
 
  private:
   const LocalVariable& local_;
   AstNode* pseudo_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadLocalNode);
 };
 
 
 class StoreLocalNode : public AstNode {
  public:
-  StoreLocalNode(intptr_t token_index,
+  StoreLocalNode(intptr_t token_pos,
                  const LocalVariable& local,
                  AstNode* value)
-      : AstNode(token_index), local_(local), value_(value) {
+      : AstNode(token_pos), local_(local), value_(value) {
     ASSERT(value_ != NULL);
   }
 
   const LocalVariable& local() const { return local_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StoreLocalNode);
 
  private:
   const LocalVariable& local_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreLocalNode);
 };
 
 
 
 class LoadInstanceFieldNode : public AstNode {
  public:
-  LoadInstanceFieldNode(intptr_t token_index,
+  LoadInstanceFieldNode(intptr_t token_pos,
                         AstNode* instance,
                         const Field& field)
-      : AstNode(token_index), instance_(instance), field_(field) {
+      : AstNode(token_pos), instance_(instance), field_(field) {
     ASSERT(instance_ != NULL);
     ASSERT(field.IsZoneHandle());
   }
 
   AstNode* instance() const { return instance_; }
   const Field& field() const { return field_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     instance()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadInstanceFieldNode);
 
  private:
   AstNode* instance_;
   const Field& field_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadInstanceFieldNode);
 };
 
 
 class StoreInstanceFieldNode : public AstNode {
  public:
-  StoreInstanceFieldNode(intptr_t token_index,
+  StoreInstanceFieldNode(intptr_t token_pos,
                          AstNode* instance,
                          const Field& field,
                          AstNode* value)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         instance_(instance),
         field_(field),
         value_(value) {
     ASSERT(instance_ != NULL);
     ASSERT(field.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   AstNode* instance() const { return instance_; }
   const Field& field() const { return field_; }
@@ skipping 10 matching lines @@
   AstNode* instance_;
   const Field& field_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreInstanceFieldNode);
 };
 
 
 class LoadStaticFieldNode : public AstNode {
  public:
-  LoadStaticFieldNode(intptr_t token_index, const Field& field)
-      : AstNode(token_index), field_(field) {
+  LoadStaticFieldNode(intptr_t token_pos, const Field& field)
+      : AstNode(token_pos), field_(field) {
     ASSERT(field.IsZoneHandle());
   }
 
   const Field& field() const { return field_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   virtual const Instance* EvalConstExpr() const {
     ASSERT(field_.is_static());
     return field_.is_final() ? &Instance::ZoneHandle(field_.value()) : NULL;
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadStaticFieldNode);
 
  private:
   const Field& field_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadStaticFieldNode);
 };
 
 
 class StoreStaticFieldNode : public AstNode {
  public:
-  StoreStaticFieldNode(intptr_t token_index, const Field& field, AstNode* value)
-      : AstNode(token_index), field_(field), value_(value) {
+  StoreStaticFieldNode(intptr_t token_pos, const Field& field, AstNode* value)
+      : AstNode(token_pos), field_(field), value_(value) {
     ASSERT(field.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   const Field& field() const { return field_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StoreStaticFieldNode);
 
  private:
   const Field& field_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreStaticFieldNode);
 };
 
 
 class LoadIndexedNode : public AstNode {
  public:
-  LoadIndexedNode(intptr_t token_index, AstNode* array, AstNode* index)
-      : AstNode(token_index), array_(array), index_expr_(index) {
+  LoadIndexedNode(intptr_t token_pos, AstNode* array, AstNode* index)
+      : AstNode(token_pos), array_(array), index_expr_(index) {
     ASSERT(array != NULL);
     ASSERT(index != NULL);
   }
 
   AstNode* array() const { return array_; }
   AstNode* index_expr() const { return index_expr_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     array()->Visit(visitor);
     index_expr()->Visit(visitor);
   }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadIndexedNode);
 
  private:
   AstNode* array_;
   AstNode* index_expr_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadIndexedNode);
 };
 
 
 class StoreIndexedNode : public AstNode {
  public:
-  StoreIndexedNode(intptr_t token_index,
+  StoreIndexedNode(intptr_t token_pos,
                    AstNode* array, AstNode* index, AstNode* value)
-    : AstNode(token_index), array_(array), index_expr_(index), value_(value) {
+    : AstNode(token_pos), array_(array), index_expr_(index), value_(value) {
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     ASSERT(value != NULL);
   }
 
   AstNode* array() const { return array_; }
   AstNode* index_expr() const { return index_expr_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     array()->Visit(visitor);
     index_expr()->Visit(visitor);
     value()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StoreIndexedNode);
 
  private:
   AstNode* array_;
   AstNode* index_expr_;
   AstNode* value_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreIndexedNode);
 };
 
 
 class InstanceCallNode : public AstNode {
  public:
-  InstanceCallNode(intptr_t token_index,
+  InstanceCallNode(intptr_t token_pos,
                    AstNode* receiver,
                    const String& function_name,
                    ArgumentListNode* arguments)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         receiver_(receiver),
         function_name_(function_name),
         arguments_(arguments) {
     ASSERT(receiver_ != NULL);
     ASSERT(function_name_.IsZoneHandle());
     ASSERT(function_name_.IsSymbol());
     ASSERT(arguments_ != NULL);
   }
 
   AstNode* receiver() const { return receiver_; }
@@ skipping 11 matching lines @@
   AstNode* receiver_;
   const String& function_name_;
   ArgumentListNode* arguments_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceCallNode);
 };
 
 
 class InstanceGetterNode : public AstNode {
  public:
-  InstanceGetterNode(intptr_t token_index,
+  InstanceGetterNode(intptr_t token_pos,
                      AstNode* receiver,
                      const String& field_name)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         receiver_(receiver),
         field_name_(field_name) {
     ASSERT(receiver_ != NULL);
     ASSERT(field_name_.IsZoneHandle());
     ASSERT(field_name_.IsSymbol());
   }
 
   AstNode* receiver() const { return receiver_; }
   const String& field_name() const { return field_name_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     receiver()->Visit(visitor);
   }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   DECLARE_COMMON_NODE_FUNCTIONS(InstanceGetterNode);
 
  private:
   AstNode* receiver_;
   const String& field_name_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceGetterNode);
 };
 
 
 class InstanceSetterNode : public AstNode {
  public:
-  InstanceSetterNode(intptr_t token_index,
+  InstanceSetterNode(intptr_t token_pos,
                      AstNode* receiver,
                      const String& field_name,
                      AstNode* value)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         receiver_(receiver),
         field_name_(field_name),
         value_(value) {
     ASSERT(receiver_ != NULL);
     ASSERT(value_ != NULL);
     ASSERT(field_name_.IsZoneHandle());
     ASSERT(field_name_.IsSymbol());
   }
 
   AstNode* receiver() const { return receiver_; }
@@ skipping 11 matching lines @@
   AstNode* receiver_;
   const String& field_name_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceSetterNode);
 };
 
 
 class StaticGetterNode : public AstNode {
  public:
-  StaticGetterNode(intptr_t token_index,
+  StaticGetterNode(intptr_t token_pos,
                    const Class& cls,
                    const String& field_name)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         cls_(cls),
         field_name_(field_name) {
     ASSERT(cls_.IsZoneHandle());
     ASSERT(field_name_.IsZoneHandle());
     ASSERT(field_name_.IsSymbol());
   }
 
   const Class& cls() const { return cls_; }
   const String& field_name() const { return field_name_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   virtual const Instance* EvalConstExpr() const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(StaticGetterNode);
 
  private:
   const Class& cls_;
   const String& field_name_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticGetterNode);
 };
 
 
 class StaticSetterNode : public AstNode {
  public:
-  StaticSetterNode(intptr_t token_index,
+  StaticSetterNode(intptr_t token_pos,
                    const Class& cls,
                    const String& field_name,
                    AstNode* value)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         cls_(cls),
         field_name_(field_name),
         value_(value) {
     ASSERT(cls_.IsZoneHandle());
     ASSERT(field_name_.IsZoneHandle());
     ASSERT(value != NULL);
   }
 
   const Class& cls() const { return cls_; }
   const String& field_name() const { return field_name_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StaticSetterNode);
 
  private:
   const Class& cls_;
   const String& field_name_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticSetterNode);
 };
 
 
 class StaticCallNode : public AstNode {
  public:
-  StaticCallNode(intptr_t token_index,
+  StaticCallNode(intptr_t token_pos,
                  const Function& function,
                  ArgumentListNode* arguments)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         function_(function),
         arguments_(arguments) {
     ASSERT(function.IsZoneHandle());
     ASSERT(arguments_ != NULL);
   }
 
   const Function& function() const { return function_; }
   ArgumentListNode* arguments() const { return arguments_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     arguments()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StaticCallNode);
 
  private:
   const Function& function_;
   ArgumentListNode* arguments_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticCallNode);
 };
 
 
 class ClosureCallNode : public AstNode {
  public:
-  ClosureCallNode(intptr_t token_index,
+  ClosureCallNode(intptr_t token_pos,
                   AstNode* closure,
                   ArgumentListNode* arguments)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         closure_(closure),
         arguments_(arguments) {
     ASSERT(closure_ != NULL);
     ASSERT(arguments_ != NULL);
   }
 
   AstNode* closure() const { return closure_; }
   ArgumentListNode* arguments() const { return arguments_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
@@ skipping 35 matching lines @@
 //
 // If the caller to the constructor or to the factory is a factory, then the
 // instantiator is the first parameter of this factory, which is already a
 // type argument vector. This case is identified by a null and unneeded
 // instantiator_class.
 //
 // A temporary local is needed to hold the allocated value while the
 // constructor is being called.
 class ConstructorCallNode : public AstNode {
  public:
-  ConstructorCallNode(intptr_t token_index,
+  ConstructorCallNode(intptr_t token_pos,
                       const AbstractTypeArguments& type_arguments,
                       const Function& constructor,
                       ArgumentListNode* arguments,
                       const LocalVariable& allocated_object_var)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         type_arguments_(type_arguments),
         constructor_(constructor),
         arguments_(arguments),
         allocated_object_var_(allocated_object_var) {
     ASSERT(type_arguments_.IsZoneHandle());
     ASSERT(constructor_.IsZoneHandle());
     ASSERT(arguments_ != NULL);
   }
 
   const AbstractTypeArguments& type_arguments() const {
@@ skipping 17 matching lines @@
   ArgumentListNode* arguments_;
   const LocalVariable& allocated_object_var_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ConstructorCallNode);
 };
 
 
 // The body of a Dart function marked as 'native' consists of this node.
 class NativeBodyNode : public AstNode {
  public:
-  NativeBodyNode(intptr_t token_index,
+  NativeBodyNode(intptr_t token_pos,
                  const String& native_c_function_name,
                  NativeFunction native_c_function,
                  int argument_count,
                  bool has_optional_parameters,
                  bool is_native_instance_closure)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         native_c_function_name_(native_c_function_name),
         native_c_function_(native_c_function),
         argument_count_(argument_count),
         has_optional_parameters_(has_optional_parameters),
         is_native_instance_closure_(is_native_instance_closure) {
     ASSERT(native_c_function_ != NULL);
     ASSERT(native_c_function_name_.IsZoneHandle());
     ASSERT(native_c_function_name_.IsSymbol());
   }
 
@@ skipping 21 matching lines @@
   const bool is_native_instance_closure_;  // An implicit native closure.
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(NativeBodyNode);
 };
 
 
 class CatchClauseNode : public AstNode {
  public:
   static const int kInvalidTryIndex = -1;
 
-  CatchClauseNode(intptr_t token_index,
+  CatchClauseNode(intptr_t token_pos,
                   SequenceNode* catch_block,
                   const LocalVariable& context_var,
                   const LocalVariable& exception_var,
                   const LocalVariable& stacktrace_var)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         try_index_(kInvalidTryIndex),
         catch_block_(catch_block),
         context_var_(context_var),
         exception_var_(exception_var),
         stacktrace_var_(stacktrace_var) {
     ASSERT(catch_block != NULL);
   }
 
   int try_index() const {
     ASSERT(try_index_ >= 0);
@@ skipping 17 matching lines @@
   const LocalVariable& context_var_;
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchClauseNode);
 };
 
 
 class TryCatchNode : public AstNode {
  public:
-  TryCatchNode(intptr_t token_index,
+  TryCatchNode(intptr_t token_pos,
                SequenceNode* try_block,
                SourceLabel* end_catch_label,
                const LocalVariable& context_var,
                CatchClauseNode* catch_block,
                SequenceNode* finally_block)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         try_block_(try_block),
         end_catch_label_(end_catch_label),
         context_var_(context_var),
         catch_block_(catch_block),
         finally_block_(finally_block) {
     ASSERT(try_block != NULL);
     ASSERT(catch_block != NULL || finally_block != NULL);
     ASSERT(end_catch_label != NULL);
   }
 
@@ skipping 21 matching lines @@
   const LocalVariable& context_var_;
   CatchClauseNode* catch_block_;
   SequenceNode* finally_block_;
 
   DISALLOW_COPY_AND_ASSIGN(TryCatchNode);
 };
 
 
 class ThrowNode : public AstNode {
  public:
-  ThrowNode(intptr_t token_index, AstNode* exception, AstNode* stacktrace)
-      : AstNode(token_index), exception_(exception), stacktrace_(stacktrace) {
+  ThrowNode(intptr_t token_pos, AstNode* exception, AstNode* stacktrace)
+      : AstNode(token_pos), exception_(exception), stacktrace_(stacktrace) {
     ASSERT(exception != NULL);
   }
 
   AstNode* exception() const { return exception_; }
   AstNode* stacktrace() const { return stacktrace_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     exception()->Visit(visitor);
     if (stacktrace() != NULL) {
       stacktrace()->Visit(visitor);
     }
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(ThrowNode);
  private:
   AstNode* exception_;
   AstNode* stacktrace_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ThrowNode);
 };
 
 
 class InlinedFinallyNode : public AstNode {
  public:
-  InlinedFinallyNode(intptr_t token_index,
+  InlinedFinallyNode(intptr_t token_pos,
                      AstNode* finally_block,
                      const LocalVariable& context_var)
-      : AstNode(token_index),
+      : AstNode(token_pos),
         finally_block_(finally_block),
         context_var_(context_var) {
     ASSERT(finally_block != NULL);
   }
 
   AstNode* finally_block() const { return finally_block_; }
   const LocalVariable& context_var() const { return context_var_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     finally_block()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(InlinedFinallyNode);
  private:
   AstNode* finally_block_;
   const LocalVariable& context_var_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InlinedFinallyNode);
 };
 
 }  // namespace dart
 
 #undef DECLARE_COMMON_NODE_FUNCTIONS
 
 #endif  // VM_AST_H_