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

vm/intermediate_language.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_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 344 matching lines @@
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantVal);
 };
 
 #undef DECLARE_VALUE
 
 
 class AssertAssignableComp : public TemplateComputation<3> {
  public:
-  AssertAssignableComp(intptr_t token_index,
+  AssertAssignableComp(intptr_t token_pos,
                        intptr_t try_index,
                        Value* value,
                        Value* instantiator,
                        Value* instantiator_type_arguments,
                        const AbstractType& dst_type,
                        const String& dst_name)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         dst_type_(dst_type),
         dst_name_(dst_name) {
     ASSERT(value != NULL);
     ASSERT(instantiator != NULL);
     ASSERT(instantiator_type_arguments != NULL);
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_name.IsNull());
     inputs_[0] = value;
     inputs_[1] = instantiator;
     inputs_[2] = instantiator_type_arguments;
   }
 
   DECLARE_COMPUTATION(AssertAssignable)
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const AbstractType& dst_type() const { return dst_type_; }
   const String& dst_name() const { return dst_name_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableComp);
 };
 
 
 class AssertBooleanComp : public TemplateComputation<1> {
  public:
-  AssertBooleanComp(intptr_t token_index,
+  AssertBooleanComp(intptr_t token_pos,
                     intptr_t try_index,
                     Value* value)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(AssertBoolean)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* value() const { return inputs_[0]; }
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanComp);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextComp : public TemplateComputation<0> {
  public:
@@ skipping 27 matching lines @@
   ClosureCallComp(ClosureCallNode* node,
                   intptr_t try_index,
                   ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
         arguments_(arguments) { }
 
   DECLARE_COMPUTATION(ClosureCall)
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
-  intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
   virtual void SetInputAt(intptr_t i, Value* value) {
     (*arguments_)[i] = value;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const ClosureCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
 
 class InstanceCallComp : public Computation {
  public:
-  InstanceCallComp(intptr_t token_index,
+  InstanceCallComp(intptr_t token_pos,
                    intptr_t try_index,
                    const String& function_name,
                    Token::Kind token_kind,
                    ZoneGrowableArray<Value*>* arguments,
                    const Array& argument_names,
                    intptr_t checked_argument_count)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         function_name_(function_name),
         token_kind_(token_kind),
         arguments_(arguments),
         argument_names_(argument_names),
         checked_argument_count_(checked_argument_count) {
     ASSERT(function_name.IsZoneHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle());
     ASSERT(Token::IsBinaryToken(token_kind) ||
            Token::IsUnaryToken(token_kind) ||
            token_kind == Token::kGET ||
            token_kind == Token::kILLEGAL);
   }
 
   DECLARE_COMPUTATION(InstanceCall)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
   virtual void SetInputAt(intptr_t i, Value* value) {
     (*arguments_)[i] = value;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   bool VerifyComputation();
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<Value*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
 };
 
@@ skipping 74 matching lines @@
 
  private:
   const Token::Kind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class EqualityCompareComp : public ComparisonComp {
  public:
-  EqualityCompareComp(intptr_t token_index,
+  EqualityCompareComp(intptr_t token_pos,
                       intptr_t try_index,
                       Value* left,
                       Value* right)
       : ComparisonComp(left, right),
-        token_index_(token_index),
+        token_pos_(token_pos),
         try_index_(try_index) {
   }
 
   DECLARE_COMPUTATION(EqualityCompare)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
 };
 
 
 class RelationalOpComp : public ComparisonComp {
  public:
-  RelationalOpComp(intptr_t token_index,
+  RelationalOpComp(intptr_t token_pos,
                    intptr_t try_index,
                    Token::Kind kind,
                    Value* left,
                    Value* right)
       : ComparisonComp(left, right),
-        token_index_(token_index),
+        token_pos_(token_pos),
         try_index_(try_index),
         kind_(kind),
         operands_class_id_(kObject) {
     ASSERT(Token::IsRelationalOperator(kind));
   }
 
   DECLARE_COMPUTATION(RelationalOp)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Token::Kind kind() const { return kind_; }
 
   // TODO(srdjan): instead of class-id pass an enum that can differentiate
   // between boxed and unboxed doubles and integers.
   void set_operands_class_id(intptr_t value) {
     operands_class_id_ = value;
   }
 
   intptr_t operands_class_id() const { return operands_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const Token::Kind kind_;
   intptr_t operands_class_id_;  // class id of both operands.
 
   DISALLOW_COPY_AND_ASSIGN(RelationalOpComp);
 };
 
 
 class StaticCallComp : public Computation {
  public:
-  StaticCallComp(intptr_t token_index,
+  StaticCallComp(intptr_t token_pos,
                  intptr_t try_index,
                  const Function& function,
                  const Array& argument_names,
                  ZoneGrowableArray<Value*>* arguments)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         recognized_(MethodRecognizer::kUnknown) {
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle());
   }
 
   DECLARE_COMPUTATION(StaticCall)
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
   const Array& argument_names() const { return argument_names_; }
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
   MethodRecognizer::Kind recognized() const { return recognized_; }
   void set_recognized(MethodRecognizer::Kind kind) { recognized_ = kind; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
   virtual void SetInputAt(intptr_t i, Value* value) {
     (*arguments_)[i] = value;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<Value*>* arguments_;
   MethodRecognizer::Kind recognized_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
@@ skipping 46 matching lines @@
 };
 
 
 class NativeCallComp : public TemplateComputation<0> {
  public:
   NativeCallComp(NativeBodyNode* node, intptr_t try_index)
       : ast_node_(*node), try_index_(try_index) {}
 
   DECLARE_COMPUTATION(NativeCall)
 
-  intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
 
   const String& native_name() const {
     return ast_node_.native_c_function_name();
   }
 
   NativeFunction native_c_function() const {
     return ast_node_.native_c_function();
   }
 
@@ skipping 110 matching lines @@
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldComp);
 };
 
 
 class LoadIndexedComp : public TemplateComputation<2> {
  public:
-  LoadIndexedComp(intptr_t token_index,
+  LoadIndexedComp(intptr_t token_pos,
                   intptr_t try_index,
                   Value* array,
                   Value* index)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         receiver_type_(kIllegalObjectKind) {
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
   }
 
   DECLARE_COMPUTATION(LoadIndexed)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
 
   void set_receiver_type(ObjectKind receiver_type) {
     receiver_type_ = receiver_type;
   }
 
   ObjectKind receiver_type() const {
     return receiver_type_;
   }
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   ObjectKind receiver_type_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
 class StoreIndexedComp : public TemplateComputation<3> {
  public:
-  StoreIndexedComp(intptr_t token_index,
+  StoreIndexedComp(intptr_t token_pos,
                    intptr_t try_index,
                    Value* array,
                    Value* index,
                    Value* value)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         receiver_type_(kIllegalObjectKind) {
     inputs_[0] = array;
     inputs_[1] = index;
     inputs_[2] = value;
   }
 
   DECLARE_COMPUTATION(StoreIndexed)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   Value* value() const { return inputs_[2]; }
 
   void set_receiver_type(ObjectKind receiver_type) {
     receiver_type_ = receiver_type;
   }
 
   ObjectKind receiver_type() const {
     return receiver_type_;
   }
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   ObjectKind receiver_type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
 class InstanceSetterComp : public TemplateComputation<2> {
  public:
-  InstanceSetterComp(intptr_t token_index,
+  InstanceSetterComp(intptr_t token_pos,
                      intptr_t try_index,
                      const String& field_name,
                      Value* receiver,
                      Value* value)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         field_name_(field_name) {
     inputs_[0] = receiver;
     inputs_[1] = value;
   }
 
   DECLARE_COMPUTATION(InstanceSetter)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const String& field_name() const { return field_name_; }
   Value* receiver() const { return inputs_[0]; }
   Value* value() const { return inputs_[1]; }
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const String& field_name_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceSetterComp);
 };
 
 
 // Not simply a StaticCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
 class StaticSetterComp : public TemplateComputation<1> {
  public:
-  StaticSetterComp(intptr_t token_index,
+  StaticSetterComp(intptr_t token_pos,
                    intptr_t try_index,
                    const Function& setter_function,
                    Value* value)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         setter_function_(setter_function) {
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StaticSetter)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const Function& setter_function() const { return setter_function_; }
   Value* value() const { return inputs_[0]; }
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const Function& setter_function_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSetterComp);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateComp : public TemplateComputation<1> {
  public:
   explicit BooleanNegateComp(Value* value) {
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(BooleanNegate)
 
   Value* value() const { return inputs_[0]; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateComp);
 };
 
 
 class InstanceOfComp : public TemplateComputation<3> {
  public:
-  InstanceOfComp(intptr_t token_index,
+  InstanceOfComp(intptr_t token_pos,
                  intptr_t try_index,
                  Value* value,
                  Value* instantiator,
                  Value* instantiator_type_arguments,
                  const AbstractType& type,
                  bool negate_result)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         type_(type),
         negate_result_(negate_result) {
     ASSERT(value != NULL);
     ASSERT(instantiator != NULL);
     ASSERT(instantiator_type_arguments != NULL);
     ASSERT(!type.IsNull());
     inputs_[0] = value;
     inputs_[1] = instantiator;
     inputs_[2] = instantiator_type_arguments;
   }
 
   DECLARE_COMPUTATION(InstanceOf)
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* value_;
   Value* instantiator_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfComp);
 };
 
 
 class AllocateObjectComp : public Computation {
  public:
   AllocateObjectComp(ConstructorCallNode* node,
                      intptr_t try_index,
                      ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node), try_index_(try_index), arguments_(arguments) {
     // Either no arguments or one type-argument and one instantiator.
     ASSERT(arguments->is_empty() || (arguments->length() == 2));
   }
 
   DECLARE_COMPUTATION(AllocateObject)
 
   const Function& constructor() const { return ast_node_.constructor(); }
-  intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
   const ZoneGrowableArray<Value*>& arguments() const { return *arguments_; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return arguments()[i]; }
   virtual void SetInputAt(intptr_t i, Value* value) {
     (*arguments_)[i] = value;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 12 matching lines @@
                                     intptr_t try_index,
                                     ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node), try_index_(try_index), arguments_(arguments) {
     // One type-argument and one instantiator.
     ASSERT(arguments->length() == 2);
   }
 
   DECLARE_COMPUTATION(AllocateObjectWithBoundsCheck)
 
   const Function& constructor() const { return ast_node_.constructor(); }
-  intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
   const ZoneGrowableArray<Value*>& arguments() const { return *arguments_; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return arguments()[i]; }
   virtual void SetInputAt(intptr_t i, Value* value) {
     (*arguments_)[i] = value;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckComp);
 };
 
 
 class CreateArrayComp : public TemplateComputation<1> {
  public:
-  CreateArrayComp(intptr_t token_index,
+  CreateArrayComp(intptr_t token_pos,
                   intptr_t try_index,
                   ZoneGrowableArray<Value*>* elements,
                   Value* element_type)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         elements_(elements) {
 #if defined(DEBUG)
     for (int i = 0; i < ElementCount(); ++i) {
       ASSERT(ElementAt(i) != NULL);
     }
     ASSERT(element_type != NULL);
 #endif
     inputs_[0] = element_type;
   }
 
   DECLARE_COMPUTATION(CreateArray)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   intptr_t ElementCount() const { return elements_->length(); }
   Value* ElementAt(intptr_t i) const { return (*elements_)[i]; }
   Value* element_type() const { return inputs_[0]; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const;
   virtual void SetInputAt(intptr_t i, Value* value);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const elements_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
 };
 
 
 class CreateClosureComp : public TemplateComputation<2> {
  public:
   CreateClosureComp(ClosureNode* node,
                     intptr_t try_index,
                     Value* type_arguments,
                     Value* receiver)
       : ast_node_(*node),
         try_index_(try_index) {
     ASSERT(type_arguments != NULL);
     ASSERT(receiver != NULL);
     inputs_[0] = type_arguments;
     inputs_[1] = receiver;
   }
 
   DECLARE_COMPUTATION(CreateClosure)
 
-  intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
   const Function& function() const { return ast_node_.function(); }
   Value* type_arguments() const { return inputs_[0]; }
   Value* receiver() const { return inputs_[1]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const ClosureNode& ast_node_;
   const intptr_t try_index_;
@@ skipping 60 matching lines @@
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreVMFieldComp);
 };
 
 
 class InstantiateTypeArgumentsComp : public TemplateComputation<1> {
  public:
-  InstantiateTypeArgumentsComp(intptr_t token_index,
+  InstantiateTypeArgumentsComp(intptr_t token_pos,
                                intptr_t try_index,
                                const AbstractTypeArguments& type_arguments,
                                Value* instantiator)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         type_arguments_(type_arguments) {
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_COMPUTATION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsComp);
 };
 
 
 class ExtractConstructorTypeArgumentsComp : public TemplateComputation<1> {
  public:
   ExtractConstructorTypeArgumentsComp(
-      intptr_t token_index,
+      intptr_t token_pos,
       intptr_t try_index,
       const AbstractTypeArguments& type_arguments,
       Value* instantiator)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         type_arguments_(type_arguments) {
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_COMPUTATION(ExtractConstructorTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsComp);
 };
 
 
 class ExtractConstructorInstantiatorComp : public TemplateComputation<1> {
  public:
   ExtractConstructorInstantiatorComp(ConstructorCallNode* ast_node,
                                      Value* instantiator)
       : ast_node_(*ast_node) {
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_COMPUTATION(ExtractConstructorInstantiator)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
-  intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t token_pos() const { return ast_node_.token_pos(); }
 
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorComp);
 };
 
 
 class AllocateContextComp : public TemplateComputation<0> {
  public:
-  AllocateContextComp(intptr_t token_index,
+  AllocateContextComp(intptr_t token_pos,
                       intptr_t try_index,
                       intptr_t num_context_variables)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_COMPUTATION(AllocateContext);
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextComp);
 };
 
 
 class ChainContextComp : public TemplateComputation<1> {
  public:
   explicit ChainContextComp(Value* context_value) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   DECLARE_COMPUTATION(ChainContext)
 
   Value* context_value() const { return inputs_[0]; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChainContextComp);
 };
 
 
 class CloneContextComp : public TemplateComputation<1> {
  public:
-  CloneContextComp(intptr_t token_index,
+  CloneContextComp(intptr_t token_pos,
                    intptr_t try_index,
                    Value* context_value)
-      : token_index_(token_index),
+      : token_pos_(token_pos),
         try_index_(try_index) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_COMPUTATION(CloneContext)
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextComp);
 };
 
 
 class CatchEntryComp : public TemplateComputation<0> {
  public:
   CatchEntryComp(const LocalVariable& exception_var,
                  const LocalVariable& stacktrace_var)
@@ skipping 103 matching lines @@
 
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(NumberNegateComp);
 };
 
 
 class CheckStackOverflowComp : public TemplateComputation<0> {
  public:
-  CheckStackOverflowComp(intptr_t token_index, intptr_t try_index)
-      : token_index_(token_index),
+  CheckStackOverflowComp(intptr_t token_pos, intptr_t try_index)
+      : token_pos_(token_pos),
         try_index_(try_index) {}
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   DECLARE_COMPUTATION(CheckStackOverflow)
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowComp);
 };
 
 
 class ToDoubleComp : public TemplateComputation<1> {
  public:
   ToDoubleComp(Value* value,
                ObjectKind from,
@@ skipping 540 matching lines @@
 
  private:
   GrowableArray<Value*> inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ReturnInstr : public InstructionWithInputs {
  public:
-  ReturnInstr(intptr_t token_index, Value* value)
-      : InstructionWithInputs(), token_index_(token_index), value_(value) {
+  ReturnInstr(intptr_t token_pos, Value* value)
+      : InstructionWithInputs(), token_pos_(token_pos), value_(value) {
     ASSERT(value_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   Value* value() const { return value_; }
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
 
   virtual Instruction* StraightLineSuccessor() const { return NULL; }
   virtual void SetSuccessor(Instruction* instr) { UNREACHABLE(); }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public InstructionWithInputs {
  public:
-  ThrowInstr(intptr_t token_index,
+  ThrowInstr(intptr_t token_pos,
              intptr_t try_index,
              Value* exception)
       : InstructionWithInputs(),
-        token_index_(token_index),
+        token_pos_(token_pos),
         try_index_(try_index),
         exception_(exception),
         successor_(NULL) {
     ASSERT(exception_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Throw)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
 
   // Parser can generate a throw within an expression tree.  We never
   // add successor instructions to the graph.
   virtual Instruction* StraightLineSuccessor() const { return NULL; }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
   }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* exception_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public InstructionWithInputs {
  public:
-  ReThrowInstr(intptr_t token_index,
+  ReThrowInstr(intptr_t token_pos,
                intptr_t try_index,
                Value* exception,
                Value* stack_trace)
       : InstructionWithInputs(),
-        token_index_(token_index),
+        token_pos_(token_pos),
         try_index_(try_index),
         exception_(exception),
         stack_trace_(stack_trace),
         successor_(NULL) {
     ASSERT(exception_ != NULL);
     ASSERT(stack_trace_ != NULL);
   }
 
   DECLARE_INSTRUCTION(ReThrow)
 
-  intptr_t token_index() const { return token_index_; }
+  intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
   Value* stack_trace() const { return stack_trace_; }
 
   // Parser can generate a rethrow within an expression tree.  We
   // never add successor instructions to the graph.
   virtual Instruction* StraightLineSuccessor() const {
     return NULL;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
   }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
  private:
-  const intptr_t token_index_;
+  const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* exception_;
   Value* stack_trace_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class BranchInstr : public InstructionWithInputs {
@@ skipping 119 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_