Replace intptr_t with TokenDescriptor

runtime/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"
 #include "vm/scopes.h"
 #include "vm/object.h"
 #include "vm/native_entry.h"
 #include "vm/token.h"
+#include "vm/token_position.h"
 
 namespace dart {
 
 #define FOR_EACH_NODE(V)                                                       \
   V(Await)                                                                     \
   V(AwaitMarker)                                                               \
   V(Return)                                                                    \
   V(Literal)                                                                   \
   V(Type)                                                                      \
   V(Assignable)                                                                \
@@ skipping 65 matching lines @@
 
 
 #define DECLARE_COMMON_NODE_FUNCTIONS(type)                                    \
   virtual void Visit(AstNodeVisitor* visitor);                                 \
   virtual const char* PrettyName() const;                                      \
   virtual type* As##type() { return this; }
 
 
 class AstNode : public ZoneAllocated {
  public:
-  explicit AstNode(intptr_t token_pos)
+  explicit AstNode(TokenPosition token_pos)
       : token_pos_(token_pos) {
-    ASSERT(!Token::IsClassifying(token_pos_) ||
-           (token_pos_ == ClassifyingTokenPositions::kMethodExtractor));
+    ASSERT(!token_pos_.IsClassifying() ||
+           (token_pos_ == TokenPosition::kMethodExtractor));
   }
   virtual ~AstNode() { }
 
-  intptr_t token_pos() const { return token_pos_; }
+  TokenPosition token_pos() const { return token_pos_; }
 
 #define AST_TYPE_CHECK(BaseName)                                               \
   bool Is##BaseName##Node() { return As##BaseName##Node() != NULL; }           \
   virtual BaseName##Node* As##BaseName##Node() { return NULL; }
 
   FOR_EACH_NODE(AST_TYPE_CHECK)
 #undef AST_TYPE_CHECK
 
   virtual void Visit(AstNodeVisitor* visitor) = 0;
   virtual void VisitChildren(AstNodeVisitor* visitor) const = 0;
@@ skipping 28 matching lines @@
   // actual value of the const expression. The type of the returned value
   // corresponds to the type of the const expression and is either
   // Number, Integer, String, Bool, or anything else (not a subtype of
   // the former).
   virtual const Instance* EvalConstExpr() const { return NULL; }
 
  protected:
   friend class ParsedFunction;
 
  private:
-  const intptr_t token_pos_;
+  const TokenPosition token_pos_;
   DISALLOW_COPY_AND_ASSIGN(AstNode);
 };
 
 
 class AwaitNode : public AstNode {
  public:
-  AwaitNode(intptr_t token_pos,
+  AwaitNode(TokenPosition token_pos,
             AstNode* expr,
             LocalVariable* saved_try_ctx,
             LocalVariable* async_saved_try_ctx,
             LocalVariable* outer_saved_try_ctx,
             LocalVariable* outer_async_saved_try_ctx,
             LocalScope* scope)
     : AstNode(token_pos),
       expr_(expr),
       saved_try_ctx_(saved_try_ctx),
       async_saved_try_ctx_(async_saved_try_ctx),
@@ skipping 34 matching lines @@
 // current context.
 //
 // It is expected (ASSERT) that an AwaitMarker is followed by
 // a return node of kind kContinuationTarget. That is:
 //   <AwaitMarker> -> <other nodes> -> <kContinuationTarget> -> <other nodes> ->
 //   <AwaitMarker> -> ...
 class AwaitMarkerNode : public AstNode {
  public:
   AwaitMarkerNode(LocalScope* async_scope,
                   LocalScope* await_scope,
-                  intptr_t token_pos)
+                  TokenPosition token_pos)
     : AstNode(token_pos),
       async_scope_(async_scope),
       await_scope_(await_scope) {
     ASSERT(async_scope != NULL);
     ASSERT(await_scope != NULL);
     await_scope->CaptureLocalVariables(async_scope);
   }
 
   void VisitChildren(AstNodeVisitor* visitor) const { }
 
   LocalScope* async_scope() const { return async_scope_; }
   LocalScope* await_scope() const { return await_scope_; }
 
   DECLARE_COMMON_NODE_FUNCTIONS(AwaitMarkerNode);
 
  private:
   LocalScope* async_scope_;
   LocalScope* await_scope_;
 
   DISALLOW_COPY_AND_ASSIGN(AwaitMarkerNode);
 };
 
 
 class SequenceNode : public AstNode {
  public:
-  SequenceNode(intptr_t token_pos, LocalScope* scope)
+  SequenceNode(TokenPosition token_pos, LocalScope* scope)
     : AstNode(token_pos),
       scope_(scope),
       nodes_(4),
       label_(NULL) {
   }
 
   LocalScope* scope() const { return scope_; }
 
   SourceLabel* label() const { return label_; }
   void set_label(SourceLabel* value) { label_ = value; }
@@ skipping 14 matching lines @@
   LocalScope* scope_;
   GrowableArray<AstNode*> nodes_;
   SourceLabel* label_;
 
   DISALLOW_COPY_AND_ASSIGN(SequenceNode);
 };
 
 
 class CloneContextNode : public AstNode {
  public:
-  explicit CloneContextNode(intptr_t token_pos)
+  explicit CloneContextNode(TokenPosition 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_pos)
+  explicit ArgumentListNode(TokenPosition token_pos)
      : AstNode(token_pos),
        nodes_(4),
        names_(Array::ZoneHandle()) {
   }
 
   void VisitChildren(AstNodeVisitor* visitor) const;
 
   void Add(AstNode* node) {
     nodes_.Add(node);
   }
@@ skipping 11 matching lines @@
  private:
   GrowableArray<AstNode*> nodes_;
   Array& names_;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentListNode);
 };
 
 
 class LetNode : public AstNode {
  public:
-  explicit LetNode(intptr_t token_pos);
+  explicit LetNode(TokenPosition token_pos);
 
   LocalVariable* TempAt(intptr_t i) const { return vars_[i]; }
   AstNode* InitializerAt(intptr_t i) const { return initializers_[i]; }
 
   virtual bool IsPotentiallyConst() const;
   virtual const Instance* EvalConstExpr() const;
 
   LocalVariable* AddInitializer(AstNode* node);
 
   const GrowableArray<AstNode*>& nodes() const { return nodes_; }
@@ skipping 12 matching lines @@
   GrowableArray<LocalVariable*> vars_;
   GrowableArray<AstNode*> initializers_;
   GrowableArray<AstNode*> nodes_;
 
   DISALLOW_COPY_AND_ASSIGN(LetNode);
 };
 
 
 class ArrayNode : public AstNode {
  public:
-  ArrayNode(intptr_t token_pos, const AbstractType& type)
+  ArrayNode(TokenPosition token_pos, const AbstractType& type)
       : AstNode(token_pos),
         type_(type),
         elements_() {
     CheckFields();
   }
-  ArrayNode(intptr_t token_pos,
+  ArrayNode(TokenPosition token_pos,
             const AbstractType& type,
             const GrowableArray<AstNode*>& elements)
       : AstNode(token_pos),
         type_(type),
         elements_(elements.length()) {
     CheckFields();
     for (intptr_t i = 0; i < elements.length(); i++) {
       elements_.Add(elements[i]);
     }
   }
@@ skipping 24 matching lines @@
     ASSERT((type_.arguments() == TypeArguments::null()) ||
            ((TypeArguments::Handle(type_.arguments()).Length() == 1)));
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayNode);
 };
 
 
 class StringInterpolateNode : public AstNode {
  public:
-  StringInterpolateNode(intptr_t token_pos, ArrayNode* value)
+  StringInterpolateNode(TokenPosition token_pos, ArrayNode* value)
       : AstNode(token_pos), value_(value) { }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value_->Visit(visitor);
   }
 
   ArrayNode* value() const { return value_; }
 
   virtual bool IsPotentiallyConst() const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(StringInterpolateNode);
 
  private:
   ArrayNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringInterpolateNode);
 };
 
 
 class LiteralNode : public AstNode {
  public:
-  LiteralNode(intptr_t token_pos, const Instance& literal)
+  LiteralNode(TokenPosition token_pos, const Instance& literal)
       : AstNode(token_pos), literal_(literal) {
     ASSERT(literal_.IsNotTemporaryScopedHandle());
     ASSERT(literal_.IsSmi() || literal_.IsOld());
 #if defined(DEBUG)
     if (literal_.IsString()) {
       ASSERT(String::Cast(literal_).IsSymbol());
     }
 #endif  // defined(DEBUG)
     ASSERT(literal_.IsNull() ||
            Class::Handle(literal_.clazz()).is_finalized() ||
@@ skipping 15 matching lines @@
 
  private:
   const Instance& literal_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LiteralNode);
 };
 
 
 class TypeNode : public AstNode {
  public:
-  TypeNode(intptr_t token_pos, const AbstractType& type)
+  TypeNode(TokenPosition token_pos, const AbstractType& type)
       : AstNode(token_pos), type_(type) {
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
     // A wellformed literal Type must be canonical.
     ASSERT(!type_.IsType() ||
            type_.IsMalformedOrMalbounded() ||
            type_.IsCanonical());
   }
 
@@ skipping 14 matching lines @@
 
  private:
   const AbstractType& type_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeNode);
 };
 
 
 class AssignableNode : public AstNode {
  public:
-  AssignableNode(intptr_t token_pos,
+  AssignableNode(TokenPosition token_pos,
                  AstNode* expr,
                  const AbstractType& type,
                  const String& 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_.IsNotTemporaryScopedHandle());
   }
@@ skipping 12 matching lines @@
   AstNode* expr_;
   const AbstractType& type_;
   const String& dst_name_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AssignableNode);
 };
 
 
 class ClosureNode : public AstNode {
  public:
-  ClosureNode(intptr_t token_pos,
+  ClosureNode(TokenPosition token_pos,
               const Function& function,
               AstNode* receiver,  // Non-null for implicit instance closures.
               LocalScope* scope)  // Null for implicit closures.
       : AstNode(token_pos),
         function_(function),
         receiver_(receiver),
         scope_(scope),
         is_deferred_reference_(false) {
     ASSERT(function_.IsZoneHandle());
     ASSERT((function_.IsNonImplicitClosureFunction() &&
@@ skipping 31 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_pos, const Object& primary)
+  PrimaryNode(TokenPosition token_pos, const Object& primary)
       : AstNode(token_pos),
         primary_(primary),
         is_deferred_reference_(false) {
     ASSERT(primary_.IsNotTemporaryScopedHandle());
   }
 
   const Object& primary() const { return primary_; }
 
   void set_is_deferred(bool value) { is_deferred_reference_ = value; }
   bool is_deferred_reference() const { return is_deferred_reference_; }
@@ skipping 25 matching lines @@
 // In synchronous functions, return nodes are always of type'kRegular'
 class ReturnNode : public AstNode {
  public:
   enum ReturnType {
     kRegular,
     kContinuation,
     kContinuationTarget
   };
 
   // Return from a void function returns the null object.
-  explicit ReturnNode(intptr_t token_pos)
+  explicit ReturnNode(TokenPosition token_pos)
       : AstNode(token_pos),
         value_(new LiteralNode(token_pos, Instance::ZoneHandle())),
         inlined_finally_list_(),
         return_type_(kRegular) { }
   // Return from a non-void function.
-  ReturnNode(intptr_t token_pos,
+  ReturnNode(TokenPosition token_pos,
              AstNode* value)
       : AstNode(token_pos),
         value_(value),
         inlined_finally_list_(),
         return_type_(kRegular) {
     ASSERT(value_ != NULL);
   }
 
   AstNode* value() const { return value_; }
 
@@ skipping 26 matching lines @@
   GrowableArray<InlinedFinallyNode*> inlined_finally_list_;
   LocalScope* scope_;
   ReturnType return_type_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnNode);
 };
 
 
 class ComparisonNode : public AstNode {
  public:
-  ComparisonNode(intptr_t token_pos,
+  ComparisonNode(TokenPosition token_pos,
                  Token::Kind kind,
                  AstNode* left,
                  AstNode* right)
   : AstNode(token_pos), kind_(kind), left_(left), right_(right) {
     ASSERT(left_ != NULL);
     ASSERT(right_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
@@ skipping 17 matching lines @@
   AstNode* right_;
 
   bool IsKindValid() const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ComparisonNode);
 };
 
 
 class BinaryOpNode : public AstNode {
  public:
-  BinaryOpNode(intptr_t token_pos,
+  BinaryOpNode(TokenPosition token_pos,
                Token::Kind kind,
                AstNode* left,
                AstNode* right)
       : AstNode(token_pos), kind_(kind), left_(left), right_(right) {
     ASSERT(left_ != NULL);
     ASSERT(right_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
@@ skipping 23 matching lines @@
   AstNode* right_;
 
   bool IsKindValid() const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BinaryOpNode);
 };
 
 
 class BinaryOpWithMask32Node : public BinaryOpNode {
  public:
-  BinaryOpWithMask32Node(intptr_t token_pos,
+  BinaryOpWithMask32Node(TokenPosition token_pos,
                          Token::Kind kind_value,
                          AstNode* left,
                          AstNode* right,
                          int64_t mask32)
       : BinaryOpNode(token_pos, kind_value, left, right), mask32_(mask32) {
     ASSERT(mask32 >= 0 && Utils::IsUint(32, mask32));
     ASSERT((kind_value != Token::kAND) && (kind_value != Token::kOR));
   }
 
   // The optional 32-bit mask must be a an unsigned 32-bit value.
@@ skipping 10 matching lines @@
   // Optional unsigned 32 bit mask applied on result. No mask: -1.
   const int64_t mask32_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BinaryOpWithMask32Node);
 };
 
 
 class UnaryOpNode : public AstNode {
  public:
   // Returns optimized version, e.g., for ('-' '1') ('-1') literal is returned.
-  static AstNode* UnaryOpOrLiteral(intptr_t token_pos,
+  static AstNode* UnaryOpOrLiteral(TokenPosition token_pos,
                                    Token::Kind kind,
                                    AstNode* operand);
-  UnaryOpNode(intptr_t token_pos,
+  UnaryOpNode(TokenPosition token_pos,
               Token::Kind kind,
               AstNode* operand)
       : AstNode(token_pos), kind_(kind), operand_(operand) {
     ASSERT(operand_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
   AstNode* operand() const { return operand_; }
 
@@ skipping 12 matching lines @@
   AstNode* operand_;
 
   bool IsKindValid() const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(UnaryOpNode);
 };
 
 
 class ConditionalExprNode : public AstNode {
  public:
-  ConditionalExprNode(intptr_t token_pos,
+  ConditionalExprNode(TokenPosition token_pos,
                       AstNode* condition,
                       AstNode* true_expr,
                       AstNode* false_expr)
       : AstNode(token_pos),
         condition_(condition),
         true_expr_(true_expr),
         false_expr_(false_expr) {
       ASSERT(condition_ != NULL);
       ASSERT(true_expr_ != NULL);
       ASSERT(false_expr_ != NULL);
@@ skipping 27 matching lines @@
   AstNode* condition_;
   AstNode* true_expr_;
   AstNode* false_expr_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ConditionalExprNode);
 };
 
 
 class IfNode : public AstNode {
  public:
-  IfNode(intptr_t token_pos,
+  IfNode(TokenPosition token_pos,
          AstNode* condition,
          SequenceNode* true_branch,
          SequenceNode* false_branch)
       : AstNode(token_pos),
         condition_(condition),
         true_branch_(true_branch),
         false_branch_(false_branch) {
       ASSERT(condition_ != NULL);
   }
 
@@ skipping 15 matching lines @@
   AstNode* condition_;
   SequenceNode* true_branch_;
   SequenceNode* false_branch_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(IfNode);
 };
 
 
 class CaseNode : public AstNode {
  public:
-  CaseNode(intptr_t token_pos,
+  CaseNode(TokenPosition token_pos,
            SourceLabel* label,
            SequenceNode* case_expressions,
            bool contains_default,
            LocalVariable* switch_expr_value,
            SequenceNode* statements)
     : AstNode(token_pos),
       label_(label),
       case_expressions_(case_expressions),
       contains_default_(contains_default),
       switch_expr_value_(switch_expr_value),
@@ skipping 23 matching lines @@
   bool contains_default_;
   LocalVariable* switch_expr_value_;
   SequenceNode* statements_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaseNode);
 };
 
 
 class SwitchNode : public AstNode {
  public:
-  SwitchNode(intptr_t token_pos,
+  SwitchNode(TokenPosition token_pos,
              SourceLabel* label,
              SequenceNode* body)
     : AstNode(token_pos),
       label_(label),
       body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   SequenceNode* body() const { return body_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     body()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(SwitchNode);
 
  private:
   SourceLabel* label_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SwitchNode);
 };
 
 
 class WhileNode : public AstNode {
  public:
-  WhileNode(intptr_t token_pos,
+  WhileNode(TokenPosition token_pos,
             SourceLabel* label,
             AstNode* condition,
             SequenceNode* condition_preamble,
             SequenceNode* body)
     : AstNode(token_pos),
       label_(label),
       condition_(condition),
       condition_preamble_(condition_preamble),
       body_(body) {
     ASSERT(label_ != NULL);
@@ skipping 21 matching lines @@
   AstNode* condition_;
   SequenceNode* condition_preamble_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WhileNode);
 };
 
 
 class DoWhileNode : public AstNode {
  public:
-  DoWhileNode(intptr_t token_pos,
+  DoWhileNode(TokenPosition token_pos,
               SourceLabel* label,
               AstNode* condition,
               SequenceNode* body)
     : AstNode(token_pos),
       label_(label),
       condition_(condition),
       body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(condition_ != NULL);
     ASSERT(body_ != NULL);
@@ skipping 15 matching lines @@
   AstNode* condition_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DoWhileNode);
 };
 
 
 // The condition can be NULL.
 class ForNode : public AstNode {
  public:
-  ForNode(intptr_t token_pos,
+  ForNode(TokenPosition token_pos,
           SourceLabel* label,
           SequenceNode* initializer,
           AstNode* condition,
           SequenceNode* condition_preamble,
           SequenceNode* increment,
           SequenceNode* body)
     : AstNode(token_pos),
       label_(label),
       initializer_(initializer),
       condition_(condition),
@@ skipping 35 matching lines @@
   AstNode* condition_preamble_;
   SequenceNode* increment_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ForNode);
 };
 
 
 class JumpNode : public AstNode {
  public:
-  JumpNode(intptr_t token_pos,
+  JumpNode(TokenPosition token_pos,
            Token::Kind kind,
            SourceLabel* label)
     : AstNode(token_pos),
       kind_(kind),
       label_(label),
       inlined_finally_list_() {
     ASSERT(label_ != NULL);
     ASSERT(kind_ == Token::kBREAK || kind_ == Token::kCONTINUE);
   }
 
@@ skipping 20 matching lines @@
   Token::Kind kind_;
   SourceLabel* label_;
   GrowableArray<InlinedFinallyNode*> inlined_finally_list_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JumpNode);
 };
 
 
 class StopNode : public AstNode {
  public:
-  StopNode(intptr_t token_pos, const char* message)
+  StopNode(TokenPosition token_pos, const char* message)
       : AstNode(token_pos),
         message_(message) {
     ASSERT(message != NULL);
   }
 
   const char* message() const { return message_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StopNode);
 
  private:
   const char* message_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StopNode);
 };
 
 
 class LoadLocalNode : public AstNode {
  public:
-  LoadLocalNode(intptr_t token_pos, const LocalVariable* local)
+  LoadLocalNode(TokenPosition token_pos, const LocalVariable* local)
       : AstNode(token_pos), local_(*local) {
     ASSERT(local != NULL);
   }
 
   const LocalVariable& local() const { return local_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   virtual const Instance* EvalConstExpr() const;
   virtual bool IsPotentiallyConst() const;
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadLocalNode);
 
  private:
   const LocalVariable& local_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadLocalNode);
 };
 
 
 class StoreLocalNode : public AstNode {
  public:
-  StoreLocalNode(intptr_t token_pos, const LocalVariable* local, AstNode* value)
+  StoreLocalNode(TokenPosition token_pos,
+                 const LocalVariable* local,
+                 AstNode* value)
       : AstNode(token_pos),  local_(*local), value_(value) {
     ASSERT(local != NULL);
     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_pos,
+  LoadInstanceFieldNode(TokenPosition token_pos,
                         AstNode* instance,
                         const 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_pos,
+  StoreInstanceFieldNode(TokenPosition token_pos,
                          AstNode* instance,
                          const Field& field,
                          AstNode* value)
       : AstNode(token_pos),
         instance_(instance),
         field_(field),
         value_(value) {
     ASSERT(instance_ != NULL);
     ASSERT(field_.IsZoneHandle());
     ASSERT(value_ != NULL);
@@ skipping 14 matching lines @@
   AstNode* instance_;
   const Field& field_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreInstanceFieldNode);
 };
 
 
 class LoadStaticFieldNode : public AstNode {
  public:
-  LoadStaticFieldNode(intptr_t token_pos, const Field& field)
+  LoadStaticFieldNode(TokenPosition token_pos, const Field& field)
       : AstNode(token_pos), field_(field), is_deferred_reference_(false) {
     ASSERT(field_.IsZoneHandle());
   }
 
   const Field& field() const { return field_; }
   void set_is_deferred(bool value) { is_deferred_reference_ = value; }
   bool is_deferred_reference() const { return is_deferred_reference_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
@@ skipping 15 matching lines @@
  private:
   const Field& field_;
   bool is_deferred_reference_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadStaticFieldNode);
 };
 
 
 class StoreStaticFieldNode : public AstNode {
  public:
-  StoreStaticFieldNode(intptr_t token_pos, const Field& field, AstNode* value)
+  StoreStaticFieldNode(TokenPosition 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_pos,
+  LoadIndexedNode(TokenPosition token_pos,
                   AstNode* array,
                   AstNode* index,
                   const Class& super_class)
       : AstNode(token_pos),
         array_(array),
         index_expr_(index),
         super_class_(super_class) {
     ASSERT(array_ != NULL);
     ASSERT(index_expr_ != NULL);
     ASSERT(super_class_.IsZoneHandle());
@@ skipping 16 matching lines @@
  private:
   AstNode* array_;
   AstNode* index_expr_;
   const Class& super_class_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadIndexedNode);
 };
 
 
 class StoreIndexedNode : public AstNode {
  public:
-  StoreIndexedNode(intptr_t token_pos,
+  StoreIndexedNode(TokenPosition token_pos,
                    AstNode* array,
                    AstNode* index,
                    AstNode* value,
                    const Class& super_class)
     : AstNode(token_pos),
       array_(array),
       index_expr_(index),
       value_(value),
       super_class_(super_class) {
     ASSERT(array_ != NULL);
@@ skipping 20 matching lines @@
   AstNode* array_;
   AstNode* index_expr_;
   AstNode* value_;
   const Class& super_class_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreIndexedNode);
 };
 
 
 class InstanceCallNode : public AstNode {
  public:
-  InstanceCallNode(intptr_t token_pos,
+  InstanceCallNode(TokenPosition token_pos,
                    AstNode* receiver,
                    const String& function_name,
                    ArgumentListNode* arguments,
                    bool is_conditional = false)
       : AstNode(token_pos),
         receiver_(receiver),
         function_name_(function_name),
         arguments_(arguments),
         is_conditional_(is_conditional) {
     ASSERT(receiver_ != NULL);
@@ skipping 19 matching lines @@
   const String& function_name_;
   ArgumentListNode* arguments_;
   const bool is_conditional_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceCallNode);
 };
 
 
 class InstanceGetterNode : public AstNode {
  public:
-  InstanceGetterNode(intptr_t token_pos,
+  InstanceGetterNode(TokenPosition token_pos,
                      AstNode* receiver,
                      const String& field_name,
                      bool is_conditional = false)
       : AstNode(token_pos),
         receiver_(receiver),
         field_name_(field_name),
         is_conditional_(is_conditional) {
     ASSERT(receiver_ != NULL);
     ASSERT(field_name_.IsNotTemporaryScopedHandle());
     ASSERT(field_name_.IsSymbol());
@@ skipping 18 matching lines @@
   AstNode* receiver_;
   const String& field_name_;
   const bool is_conditional_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceGetterNode);
 };
 
 
 class InstanceSetterNode : public AstNode {
  public:
-  InstanceSetterNode(intptr_t token_pos,
+  InstanceSetterNode(TokenPosition token_pos,
                      AstNode* receiver,
                      const String& field_name,
                      AstNode* value,
                      bool is_conditional = false)
       : AstNode(token_pos),
         receiver_(receiver),
         field_name_(field_name),
         value_(value),
         is_conditional_(is_conditional) {
     ASSERT(receiver_ != NULL);
@@ skipping 19 matching lines @@
   const String& field_name_;
   AstNode* value_;
   const bool is_conditional_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceSetterNode);
 };
 
 
 class InitStaticFieldNode : public AstNode {
  public:
-  InitStaticFieldNode(intptr_t token_pos, const Field& field)
+  InitStaticFieldNode(TokenPosition 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 { }
 
   DECLARE_COMMON_NODE_FUNCTIONS(InitStaticFieldNode);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldNode);
 };
 
 
 class StaticGetterNode : public AstNode {
  public:
-  StaticGetterNode(intptr_t token_pos,
+  StaticGetterNode(TokenPosition token_pos,
                    AstNode* receiver,
                    const Class& cls,
                    const String& field_name)
       : AstNode(token_pos),
         receiver_(receiver),
         owner_(Object::ZoneHandle(cls.raw())),
         cls_(cls),
         field_name_(field_name),
         is_deferred_reference_(false) {
     ASSERT(cls_.IsZoneHandle());
@@ skipping 36 matching lines @@
   const String& field_name_;
   bool is_deferred_reference_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticGetterNode);
 };
 
 
 class StaticSetterNode : public AstNode {
  public:
   // Static setter with resolved setter function.
-  StaticSetterNode(intptr_t token_pos,
+  StaticSetterNode(TokenPosition token_pos,
                    AstNode* receiver,
                    const String& field_name,
                    const Function& function,
                    AstNode* value)
       : AstNode(token_pos),
         receiver_(receiver),
         cls_(Class::ZoneHandle(function.Owner())),
         field_name_(field_name),
         function_(function),
         value_(value) {
     ASSERT(function_.IsZoneHandle());
     ASSERT(function.is_static() || receiver != NULL);
     ASSERT(field_name_.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   // For unresolved setters.
-  StaticSetterNode(intptr_t token_pos,
+  StaticSetterNode(TokenPosition token_pos,
                    AstNode* receiver,
                    const Class& cls,
                    const String& field_name,
                    AstNode* value)
   : AstNode(token_pos),
   receiver_(receiver),
   cls_(cls),
   field_name_(field_name),
   function_(Function::ZoneHandle()),
   value_(value) {
@@ skipping 23 matching lines @@
   const String& field_name_;
   const Function& function_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticSetterNode);
 };
 
 
 class StaticCallNode : public AstNode {
  public:
-  StaticCallNode(intptr_t token_pos,
+  StaticCallNode(TokenPosition token_pos,
                  const Function& function,
                  ArgumentListNode* arguments)
       : AstNode(token_pos),
         function_(function),
         arguments_(arguments) {
     ASSERT(function_.IsZoneHandle());
     ASSERT(arguments_ != NULL);
   }
 
   const Function& function() const { return function_; }
@@ skipping 10 matching lines @@
  private:
   const Function& function_;
   ArgumentListNode* arguments_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticCallNode);
 };
 
 
 class ClosureCallNode : public AstNode {
  public:
-  ClosureCallNode(intptr_t token_pos,
+  ClosureCallNode(TokenPosition token_pos,
                   AstNode* closure,
                   ArgumentListNode* arguments)
       : AstNode(token_pos),
         closure_(closure),
         arguments_(arguments) {
     ASSERT(closure_ != NULL);
     ASSERT(arguments_ != NULL);
   }
 
   AstNode* closure() const { return closure_; }
@@ skipping 35 matching lines @@
 // the class of the caller), the code at run time extracts the type arguments of
 // the receiver at an offset in the receiver specified by the provided
 // instantiator_class.
 //
 // 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.
 class ConstructorCallNode : public AstNode {
  public:
-  ConstructorCallNode(intptr_t token_pos,
+  ConstructorCallNode(TokenPosition token_pos,
                       const TypeArguments& type_arguments,
                       const Function& constructor,
                       ArgumentListNode* arguments)
       : AstNode(token_pos),
         type_arguments_(type_arguments),
         constructor_(constructor),
         arguments_(arguments) {
     ASSERT(type_arguments_.IsZoneHandle());
     ASSERT(constructor_.IsZoneHandle());
     ASSERT(arguments_ != NULL);
@@ skipping 16 matching lines @@
   const Function& constructor_;
   ArgumentListNode* arguments_;
 
   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_pos,
+  NativeBodyNode(TokenPosition token_pos,
                  const Function& function,
                  const String& native_c_function_name,
                  LocalScope* scope,
                  bool link_lazily = false)
       : AstNode(token_pos),
         function_(function),
         native_c_function_name_(native_c_function_name),
         scope_(scope),
         link_lazily_(link_lazily) {
     ASSERT(function_.IsZoneHandle());
@@ skipping 20 matching lines @@
   const bool link_lazily_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(NativeBodyNode);
 };
 
 
 class CatchClauseNode : public AstNode {
  public:
   static const intptr_t kInvalidTryIndex = -1;
 
-  CatchClauseNode(intptr_t token_pos,
+  CatchClauseNode(TokenPosition token_pos,
                   SequenceNode* catch_block,
                   const Array& handler_types,
                   const LocalVariable* context_var,
                   const LocalVariable* exception_var,
                   const LocalVariable* stacktrace_var,
                   const LocalVariable* rethrow_exception_var,
                   const LocalVariable* rethrow_stacktrace_var,
                   intptr_t catch_handler_index,
                   bool needs_stacktrace)
       : AstNode(token_pos),
@@ skipping 42 matching lines @@
   const LocalVariable& rethrow_stacktrace_var_;
   const intptr_t catch_handler_index_;
   const bool needs_stacktrace_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchClauseNode);
 };
 
 
 class TryCatchNode : public AstNode {
  public:
-  TryCatchNode(intptr_t token_pos,
+  TryCatchNode(TokenPosition token_pos,
                SequenceNode* try_block,
                const LocalVariable* context_var,
                CatchClauseNode* catch_block,
                SequenceNode* finally_block,
                intptr_t try_index,
                SequenceNode* rethrow_clause)
       : AstNode(token_pos),
         try_block_(try_block),
         context_var_(*context_var),
         catch_block_(catch_block),
@@ skipping 32 matching lines @@
   SequenceNode* finally_block_;
   const intptr_t try_index_;
   SequenceNode* rethrow_clause_;
 
   DISALLOW_COPY_AND_ASSIGN(TryCatchNode);
 };
 
 
 class ThrowNode : public AstNode {
  public:
-  ThrowNode(intptr_t token_pos, AstNode* exception, AstNode* stacktrace)
+  ThrowNode(TokenPosition 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_pos,
+  InlinedFinallyNode(TokenPosition token_pos,
                      SequenceNode* finally_block,
                      const LocalVariable* context_var,
                      intptr_t try_index)
       : AstNode(token_pos),
         finally_block_(finally_block),
         context_var_(*context_var),
         try_index_(try_index) {
     ASSERT(finally_block_ != NULL);
     ASSERT(context_var != NULL);
   }
@@ skipping 14 matching lines @@
   const intptr_t try_index_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InlinedFinallyNode);
 };
 
 }  // namespace dart
 
 #undef DECLARE_COMMON_NODE_FUNCTIONS
 
 #endif  // VM_AST_H_