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

vm/flow_graph_builder.cc

 // 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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 203 matching lines @@
   DoInstr* store_context =
       new DoInstr(new StoreContextComp(new UseVal(load_saved_context)));
   AddInstruction(store_context);
 }
 
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     BindInstr* assert_boolean =
-        new BindInstr(new AssertBooleanComp(condition_token_index(),
+        new BindInstr(new AssertBooleanComp(condition_token_pos(),
                                             owner()->try_index(),
                                             value));
     AddInstruction(assert_boolean);
     value = new UseVal(assert_boolean);
   }
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
@@ skipping 27 matching lines @@
         (kind == RawFunction::kConstImplicitGetter);
     const bool is_static = owner()->parsed_function().function().is_static();
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     if (is_static || !is_implicit_getter) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
       const String& dst_name =
           String::ZoneHandle(String::NewSymbol("function result"));
-      return_value = BuildAssignableValue(node->value()->token_index(),
+      return_value = BuildAssignableValue(node->value()->token_pos(),
                                           return_value,
                                           dst_type,
                                           dst_name);
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
   AddInstruction(
-      new ReturnInstr(node->token_index(), return_value));
+      new ReturnInstr(node->token_pos(), return_value));
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
@@ skipping 85 matching lines @@
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   UNREACHABLE();
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
-  ReturnValue(BuildAssignableValue(node->expr()->token_index(),
+  ReturnValue(BuildAssignableValue(node->expr()->token_pos(),
                                    for_value.value(),
                                    node->type(),
                                    node->dst_name()));
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(),
                               temp_index(),
-                              node->left()->token_index());
+                              node->left()->token_pos());
     node->left()->Visit(&for_left);
     EffectGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     EffectGraphVisitor empty(owner(), temp_index());
     if (node->kind() == Token::kAND) {
       Join(for_left, for_right, empty);
     } else {
       Join(for_left, empty, for_right);
     }
     return;
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
-  InstanceCallComp* call = new InstanceCallComp(node->token_index(),
+  InstanceCallComp* call = new InstanceCallComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 name,
                                                 node->kind(),
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 2);
   ReturnComputation(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
     TestGraphVisitor for_test(owner(),
                               temp_index(),
-                              node->left()->token_index());
+                              node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       BindInstr* assert_boolean =
-          new BindInstr(new AssertBooleanComp(node->right()->token_index(),
+          new BindInstr(new AssertBooleanComp(node->right()->token_pos(),
                                               owner()->try_index(),
                                               right_value));
       for_right.AddInstruction(assert_boolean);
       right_value = new UseVal(assert_boolean);
     }
     BindInstr* constant_true = new BindInstr(new ConstantVal(bool_true));
     for_right.AddInstruction(constant_true);
     BindInstr* comp =
         new BindInstr(new StrictCompareComp(Token::kEQ_STRICT,
                                             right_value,
@@ skipping 89 matching lines @@
       break;
     }
   }
   if (compile_time_interpolation) {
     // Not needed for effect, only for value
     CompiletimeStringInterpolation(interpol_func, literals);
     return;
   }
   // Runtime string interpolation.
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
-  ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_index());
+  ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_pos());
   interpol_arg->Add(node->values());
   TranslateArgumentList(*interpol_arg, values);
   StaticCallComp* call =
-      new StaticCallComp(node->token_index(),
+      new StaticCallComp(node->token_pos(),
                          owner()->try_index(),
                          interpol_func,
                          interpol_arg->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckArguments(
-    intptr_t token_index,
+    intptr_t token_pos,
     Value** instantiator_result,
     Value** instantiator_type_arguments_result) {
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   instantiator = BuildInstantiator();
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator = BuildNullValue();
     instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_index, NULL);
+        BuildInstantiatorTypeArguments(token_pos, NULL);
   } else {
     // Preserve instantiator.
     const LocalVariable& expr_temp =
         *owner()->parsed_function().expression_temp_var();
     BindInstr* saved =
         new BindInstr(BuildStoreLocal(expr_temp, instantiator));
     AddInstruction(saved);
     instantiator = new UseVal(saved);
     BindInstr* loaded = new BindInstr(BuildLoadLocal(expr_temp));
     AddInstruction(loaded);
     instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_index, new UseVal(loaded));
+        BuildInstantiatorTypeArguments(token_pos, new UseVal(loaded));
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
   BindInstr* instr = new BindInstr(new ConstantVal(Object::ZoneHandle()));
   AddInstruction(instr);
   return new UseVal(instr);
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableComp* EffectGraphVisitor::BuildAssertAssignable(
-    intptr_t token_index,
+    intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (dst_type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
-    BuildTypecheckArguments(token_index,
+    BuildTypecheckArguments(token_pos,
                             &instantiator,
                             &instantiator_type_arguments);
   }
-  return new AssertAssignableComp(token_index,
+  return new AssertAssignableComp(token_pos,
                                   owner()->try_index(),
                                   value,
                                   instantiator,
                                   instantiator_type_arguments,
                                   dst_type,
                                   dst_name);
 }
 
 
 // Used to to test assignments.
-Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_index,
+Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_pos,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(value, dst_type)) {
     return value;
   }
-  AssertAssignableComp* comp = BuildAssertAssignable(token_index,
+  AssertAssignableComp* comp = BuildAssertAssignable(token_pos,
                                                      value,
                                                      dst_type,
                                                      dst_name);
   BindInstr* assert_assignable = new BindInstr(comp);
   AddInstruction(assert_assignable);
   return new UseVal(assert_assignable);
 }
 
 
 void EffectGraphVisitor::BuildInstanceOf(ComparisonNode* node) {
@@ skipping 55 matching lines @@
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
-    BuildTypecheckArguments(node->token_index(),
+    BuildTypecheckArguments(node->token_pos(),
                             &instantiator,
                             &instantiator_type_arguments);
   }
   InstanceOfComp* instance_of =
-      new InstanceOfComp(node->token_index(),
+      new InstanceOfComp(node->token_pos(),
                          owner()->try_index(),
                          for_left_value.value(),
                          instantiator,
                          instantiator_type_arguments,
                          node->right()->AsTypeNode()->type(),
                          (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
@@ skipping 21 matching lines @@
   }
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     EqualityCompareComp* comp = new EqualityCompareComp(
-        node->token_index(), owner()->try_index(),
+        node->token_pos(), owner()->try_index(),
         for_left_value.value(), for_right_value.value());
     if (node->kind() == Token::kEQ) {
       ReturnComputation(comp);
     } else {
       BindInstr* eq_result = new BindInstr(comp);
       AddInstruction(eq_result);
       if (FLAG_enable_type_checks) {
         eq_result =
-            new BindInstr(new AssertBooleanComp(node->token_index(),
+            new BindInstr(new AssertBooleanComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 new UseVal(eq_result)));
         AddInstruction(eq_result);
       }
       BooleanNegateComp* negate = new BooleanNegateComp(new UseVal(eq_result));
       ReturnComputation(negate);
     }
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  RelationalOpComp* comp = new RelationalOpComp(node->token_index(),
+  RelationalOpComp* comp = new RelationalOpComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 node->kind(),
                                                 for_left_value.value(),
                                                 for_right_value.value());
   ReturnComputation(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       BindInstr* assert_boolean =
-          new BindInstr(new AssertBooleanComp(node->operand()->token_index(),
+          new BindInstr(new AssertBooleanComp(node->operand()->token_pos(),
                                               owner()->try_index(),
                                               value));
       AddInstruction(assert_boolean);
       value = new UseVal(assert_boolean);
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
   Token::Kind token_kind =
       (node->kind() == Token::kSUB) ? Token::kNEGATE : node->kind();
 
   const String& name =
       String::ZoneHandle(String::NewSymbol(Token::Str(token_kind)));
   InstanceCallComp* call = new InstanceCallComp(
-      node->token_index(), owner()->try_index(), name, token_kind,
+      node->token_pos(), owner()->try_index(), name, token_kind,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->token_index());
+                            node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   EffectGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->token_index());
+                            node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
   for_true.AddInstruction(new DoInstr(BuildStoreLocal(
       *owner()->parsed_function().expression_temp_var(), for_true.value())));
 
   ValueGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
   ASSERT(for_false.is_open());
   for_false.AddInstruction(new DoInstr(BuildStoreLocal(
       *owner()->parsed_function().expression_temp_var(), for_false.value())));
 
   Join(for_test, for_true, for_false);
   ReturnComputation(
       BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->token_index());
+                            node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   EffectGraphVisitor for_true(owner(), temp_index());
   EffectGraphVisitor for_false(owner(), temp_index());
 
   node->true_branch()->Visit(&for_true);
   // The for_false graph fragment will be empty (default graph fragment) if
   // we do not call Visit.
   if (node->false_branch() != NULL) node->false_branch()->Visit(&for_false);
   Join(for_test, for_true, for_false);
@@ skipping 69 matching lines @@
 
   // Generate instructions for all case expressions and collect data to
   // connect them.
   GrowableArray<TargetEntryInstr**> case_true_addresses;
   GrowableArray<TargetEntryInstr**> case_false_addresses;
   GrowableArray<TargetEntryInstr*> case_entries;
   for (intptr_t i = 0; i < len; i++) {
     AstNode* case_expr = node->case_expressions()->NodeAt(i);
     TestGraphVisitor for_case_expression(owner(),
                                          temp_index(),
-                                         case_expr->token_index());
+                                         case_expr->token_pos());
     if (i == 0) {
       case_entries.Add(NULL);  // Not to be used
       case_expr->Visit(&for_case_expression);
       // Append only the first one, everything else is connected from it.
       Append(for_case_expression);
     } else {
       TargetEntryInstr* case_entry_target = new TargetEntryInstr();
       case_entries.Add(case_entry_target);
       for_case_expression.AddInstruction(case_entry_target);
       case_expr->Visit(&for_case_expression);
@@ skipping 61 matching lines @@
 // a) continue-join (optional)
 // b) loop-join
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ] -> (loop-join)
 // f) loop-exit-target
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->token_index());
+                            node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
   EffectGraphVisitor for_body(owner(), temp_index());
   CheckStackOverflowComp* comp =
-      new CheckStackOverflowComp(node->token_index(), owner()->try_index());
+      new CheckStackOverflowComp(node->token_pos(), owner()->try_index());
   for_body.AddInstruction(new DoInstr(comp));
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
   if (lbl->join_for_continue() != NULL) {
     AddInstruction(lbl->join_for_continue());
   }
   TieLoop(for_test, for_body);
   if (lbl->join_for_break() != NULL) {
     AddInstruction(lbl->join_for_break());
   }
 }
 
 
 // The fragment is composed as follows:
 // a) body-entry-join
 // b) [ body ]
 // c) test-entry (continue-join or body-exit-target)
 // d) [ test-entry ] -> (back-target, loop-exit-target)
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   CheckStackOverflowComp* comp =
-      new CheckStackOverflowComp(node->token_index(), owner()->try_index());
+      new CheckStackOverflowComp(node->token_pos(), owner()->try_index());
   for_body.AddInstruction(new DoInstr(comp));
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(),
                             temp_index(),
-                            node->condition()->token_index());
+                            node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
   // Tie do-while loop (test is after the body).
   JoinEntryInstr* body_entry_join = new JoinEntryInstr();
   AddInstruction(body_entry_join);
   body_entry_join->SetSuccessor(for_body.entry());
   Instruction* body_exit =
       for_body.is_empty() ? body_entry_join : for_body.exit();
 
@@ skipping 40 matching lines @@
   EffectGraphVisitor for_initializer(owner(), temp_index());
   node->initializer()->Visit(&for_initializer);
   Append(for_initializer);
   ASSERT(is_open());
 
   // Compose body to set any jump labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   TargetEntryInstr* body_entry = new TargetEntryInstr();
   for_body.AddInstruction(body_entry);
   CheckStackOverflowComp* comp =
-      new CheckStackOverflowComp(node->token_index(), owner()->try_index());
+      new CheckStackOverflowComp(node->token_pos(), owner()->try_index());
   for_body.AddInstruction(new DoInstr(comp));
   node->body()->Visit(&for_body);
 
   // Join loop body, increment and compute their end instruction.
   ASSERT(!for_body.is_empty());
   Instruction* loop_increment_end = NULL;
   EffectGraphVisitor for_increment(owner(), temp_index());
   if ((node->label()->join_for_continue() == NULL) && for_body.is_open()) {
     // Do not insert an extra basic block.
     node->increment()->Visit(&for_increment);
@@ skipping 29 matching lines @@
     if (node->label()->join_for_break() == NULL) {
       CloseFragment();
     } else {
       // Control flow of ForLoop continues into join_for_break.
       exit_ = node->label()->join_for_break();
     }
   } else {
     TargetEntryInstr* loop_exit = new TargetEntryInstr();
     TestGraphVisitor for_test(owner(),
                               temp_index(),
-                              node->condition()->token_index());
+                              node->condition()->token_pos());
     node->condition()->Visit(&for_test);
     Append(for_test);
     *for_test.true_successor_address() = body_entry;
     *for_test.false_successor_address() = loop_exit;
     if (node->label()->join_for_break() == NULL) {
       exit_ = loop_exit;
     } else {
       loop_exit->SetSuccessor(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
@@ skipping 63 matching lines @@
   // Translate the array elements and collect their values.
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(node->length());
   for (int i = 0; i < node->length(); ++i) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     values->Add(for_value.value());
   }
   Value* element_type = new UseVal(
-      BuildInstantiatedTypeArguments(node->token_index(),
+      BuildInstantiatedTypeArguments(node->token_pos(),
                                      node->type_arguments()));
-  CreateArrayComp* create = new CreateArrayComp(node->token_index(),
+  CreateArrayComp* create = new CreateArrayComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 values,
                                                 element_type);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
@@ skipping 20 matching lines @@
   ASSERT(function.context_scope() != ContextScope::null());
 
   // The function type of a closure may have type arguments. In that case, pass
   // the type arguments of the instantiator. Otherwise, pass null object.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
-    type_arguments = BuildInstantiatorTypeArguments(node->token_index(), NULL);
+    type_arguments = BuildInstantiatorTypeArguments(node->token_pos(), NULL);
   } else {
     type_arguments = BuildNullValue();
   }
 
   CreateClosureComp* create = new CreateClosureComp(
       node, owner()->try_index(), type_arguments, receiver);
   ReturnComputation(create);
 }
 
 
@@ skipping 13 matching lines @@
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
 
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   values->Add(for_receiver.value());
 
   TranslateArgumentList(*arguments, values);
   InstanceCallComp* call = new InstanceCallComp(
-      node->token_index(), owner()->try_index(),
+      node->token_pos(), owner()->try_index(),
       node->function_name(), Token::kILLEGAL, values,
       arguments->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
   TranslateArgumentList(*node->arguments(), values);
   StaticCallComp* call =
-      new StaticCallComp(node->token_index(),
+      new StaticCallComp(node->token_pos(),
                          owner()->try_index(),
                          node->function(),
                          node->arguments()->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 ClosureCallComp* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
@@ skipping 30 matching lines @@
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
 
   ReturnValue(new UseVal(result));
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   BindInstr* context = new BindInstr(new CurrentContextComp());
   AddInstruction(context);
   BindInstr* clone =
-      new BindInstr(new CloneContextComp(node->token_index(),
+      new BindInstr(new CloneContextComp(node->token_pos(),
                                          owner()->try_index(),
                                          new UseVal(context)));
   AddInstruction(clone);
   ReturnComputation(new StoreContextComp(new UseVal(clone)));
 }
 
 
 BindInstr* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
@@ skipping 40 matching lines @@
       new BindInstr(new ConstantVal(
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   AddInstruction(ctor_arg);
 
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
   values->Add(alloc_value);
   values->Add(new UseVal(ctor_arg));
 
   TranslateArgumentList(*node->arguments(), values);
   StaticCallComp* call =
-      new StaticCallComp(node->token_index(),
+      new StaticCallComp(node->token_pos(),
                          owner()->try_index(),
                          node->constructor(),
                          node->arguments()->names(),
                          values);
   AddInstruction(new DoInstr(call));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<Value*>* factory_arguments =
         new ZoneGrowableArray<Value*>();
     factory_arguments->Add(
-        new UseVal(BuildInstantiatedTypeArguments(node->token_index(),
+        new UseVal(BuildInstantiatedTypeArguments(node->token_pos(),
                                                   node->type_arguments())));
     ASSERT(factory_arguments->length() == 1);
     TranslateArgumentList(*node->arguments(), factory_arguments);
     StaticCallComp* call =
-        new StaticCallComp(node->token_index(),
+        new StaticCallComp(node->token_pos(),
                            owner()->try_index(),
                            node->constructor(),
                            node->arguments()->names(),
                            factory_arguments);
     ReturnComputation(call);
     return;
   }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
@@ skipping 24 matching lines @@
   ValueGraphVisitor for_instantiator(owner(), temp_index());
   owner()->parsed_function().instantiator()->Visit(&for_instantiator);
   Append(for_instantiator);
   return for_instantiator.value();
 }
 
 
 // 'expression_temp_var' may not be used inside this method if 'instantiator'
 // is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
-    intptr_t token_index, Value* instantiator) {
+    intptr_t token_pos, Value* instantiator) {
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
-        Type::New(instantiator_class, type_arguments, token_index));
+        Type::New(instantiator_class, type_arguments, token_pos));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalizeWellFormed);
     type_arguments = type.arguments();
     BindInstr* args = new BindInstr(new ConstantVal(type_arguments));
     AddInstruction(args);
     return new UseVal(args);
   }
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
@@ skipping 23 matching lines @@
       new BindInstr(new LoadVMFieldComp(
                         instantiator,
                         type_arguments_instance_field_offset,
                         Type::ZoneHandle()));  // Not an instance, no type.
   AddInstruction(load);
   return new UseVal(load);
 }
 
 
 BindInstr* EffectGraphVisitor::BuildInstantiatedTypeArguments(
-    intptr_t token_index,
+    intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     BindInstr* type_args =
         new BindInstr(new ConstantVal(type_arguments));
     AddInstruction(type_args);
     return type_args;
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
-      BuildInstantiatorTypeArguments(token_index, NULL);
+      BuildInstantiatorTypeArguments(token_pos, NULL);
   BindInstr* instantiate =
-      new BindInstr(new InstantiateTypeArgumentsComp(token_index,
+      new BindInstr(new InstantiateTypeArgumentsComp(token_pos,
                                                      owner()->try_index(),
                                                      type_arguments,
                                                      instantiator_value));
   AddInstruction(instantiate);
   return instantiate;
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
@@ skipping 20 matching lines @@
   //   t2 = ExtractConstructorTypeArguments(t1);
   //   t1 = ExtractConstructorInstantiator(t1);
   //   t_n   <- t2
   //   t_n+1 <- t1
   // Use expression_temp_var and node->allocated_object_var() locals to keep
   // intermediate results around (t1 and t2 above).
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& t1 = *owner()->parsed_function().expression_temp_var();
   const LocalVariable& t2 = node->allocated_object_var();
   Value* instantiator_type_arguments = BuildInstantiatorTypeArguments(
-      node->token_index(), NULL);
+      node->token_pos(), NULL);
   ASSERT(instantiator_type_arguments->IsUse());
   BindInstr* stored_instantiator = new BindInstr(
       BuildStoreLocal(t1, instantiator_type_arguments));
   AddInstruction(stored_instantiator);
   // t1: instantiator type arguments.
 
   BindInstr* extract_type_arguments = new BindInstr(
       new ExtractConstructorTypeArgumentsComp(
-          node->token_index(),
+          node->token_pos(),
           owner()->try_index(),
           node->type_arguments(),
           new UseVal(stored_instantiator)));
   AddInstruction(extract_type_arguments);
 
   Instruction* stored_type_arguments = new DoInstr(
       BuildStoreLocal(t2, new UseVal(extract_type_arguments)));
   AddInstruction(stored_type_arguments);
   // t2: extracted constructor type arguments.
   BindInstr* load_instantiator = new BindInstr(BuildLoadLocal(t1));
@@ skipping 48 matching lines @@
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallComp* call = new InstanceCallComp(
-      node->token_index(), owner()->try_index(), name, Token::kGET,
+      node->token_pos(), owner()->try_index(), name, Token::kGET,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterValues(
     InstanceSetterNode* node, Value** receiver, Value** value) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ValueGraphVisitor for_value(owner(), for_receiver.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   *receiver = for_receiver.value();
   *value = for_value.value();
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   Value *receiver, *value;
   BuildInstanceSetterValues(node, &receiver, &value);
   InstanceSetterComp* setter =
-      new InstanceSetterComp(node->token_index(),
+      new InstanceSetterComp(node->token_pos(),
                              owner()->try_index(),
                              node->field_name(),
                              receiver,
                              value);
   ReturnComputation(setter);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   Value *receiver, *value;
   BuildInstanceSetterValues(node, &receiver, &value);
   BindInstr* store_local_instr = new BindInstr(
       BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                       value));
   AddInstruction(store_local_instr);
   UseVal* saved_value = new UseVal(store_local_instr);
   InstanceSetterComp* setter =
-      new InstanceSetterComp(node->token_index(),
+      new InstanceSetterComp(node->token_pos(),
                              owner()->try_index(),
                              node->field_name(),
                              receiver,
                              saved_value);
   AddInstruction(new DoInstr(setter));
   ReturnComputation(
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   const Function& getter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(getter_name));
   ASSERT(!getter_function.IsNull());
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
-  StaticCallComp* call = new StaticCallComp(node->token_index(),
+  StaticCallComp* call = new StaticCallComp(node->token_pos(),
                                             owner()->try_index(),
                                             getter_function,
                                             Array::ZoneHandle(),  // No names.
                                             values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   const String& setter_name =
       String::Handle(Field::SetterName(node->field_name()));
   const Function& setter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(setter_name));
   ASSERT(!setter_function.IsNull());
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
-  StaticSetterComp* call = new StaticSetterComp(node->token_index(),
+  StaticSetterComp* call = new StaticSetterComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 setter_function,
                                                 for_value.value());
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
   NativeCallComp* native_call =
       new NativeCallComp(node, owner()->try_index());
@@ skipping 25 matching lines @@
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
-    store_value = BuildAssignableValue(node->value()->token_index(),
+    store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
   Computation* store = BuildStoreLocal(node->local(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
@@ skipping 12 matching lines @@
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
-    store_value = BuildAssignableValue(node->value()->token_index(),
+    store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
   StoreInstanceFieldComp* store = new StoreInstanceFieldComp(
       node->field(), for_instance.value(), store_value, NULL);
   ReturnComputation(store);
 }
 
 
@@ skipping 11 matching lines @@
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
-    store_value = BuildAssignableValue(node->value()->token_index(),
+    store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   ValueGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
 
   LoadIndexedComp* load = new LoadIndexedComp(
-      node->token_index(),
+      node->token_pos(),
       owner()->try_index(),
       for_array.value(),
       for_index.value());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node, Value** array, Value** index, Value** value) {
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   ValueGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   ValueGraphVisitor for_value(owner(), for_index.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   *array = for_array.value();
   *index = for_index.value();
   *value = for_value.value();
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   Value *array, *index, *value;
   BuildStoreIndexedValues(node, &array, &index, &value);
-  StoreIndexedComp* store = new StoreIndexedComp(node->token_index(),
+  StoreIndexedComp* store = new StoreIndexedComp(node->token_pos(),
                                                  owner()->try_index(),
                                                  array,
                                                  index,
                                                  value);
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   Value *array, *index, *value;
   BuildStoreIndexedValues(node, &array, &index, &value);
   BindInstr* store_local_instr = new BindInstr(
       BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                       value));
   AddInstruction(store_local_instr);
   UseVal* saved_value = new UseVal(store_local_instr);
-  StoreIndexedComp* store = new StoreIndexedComp(node->token_index(),
+  StoreIndexedComp* store = new StoreIndexedComp(node->token_pos(),
                                                  owner()->try_index(),
                                                  array,
                                                  index,
                                                  saved_value);
   AddInstruction(new DoInstr(store));
   ReturnComputation(
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
@@ skipping 23 matching lines @@
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   int previous_context_level = owner()->context_level();
   if (num_context_variables > 0) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     // Allocate context computation (uses current CTX)
     BindInstr* allocated_context =
-        new BindInstr(new AllocateContextComp(node->token_index(),
+        new BindInstr(new AllocateContextComp(node->token_pos(),
                                               owner()->try_index(),
                                               num_context_variables));
     AddInstruction(allocated_context);
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
       BindInstr* current_context = new BindInstr(new CurrentContextComp());
@@ skipping 69 matching lines @@
       // Skip type checking of receiver for instance functions.
       pos = 1;
     }
     while (pos < num_params) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(NULL, parameter.type())) {
         BindInstr* load = new BindInstr(BuildLoadLocal(parameter));
         AddInstruction(load);
         AssertAssignableComp* assert_assignable =
-            BuildAssertAssignable(parameter.token_index(),
+            BuildAssertAssignable(parameter.token_pos(),
                                   new UseVal(load),
                                   parameter.type(),
                                   parameter.name());
         AddInstruction(new DoInstr(assert_assignable));
       }
       pos++;
     }
   }
 
   intptr_t i = 0;
@@ skipping 97 matching lines @@
   }
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   ValueGraphVisitor for_exception(owner(), temp_index());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
-    instr = new ThrowInstr(node->token_index(),
+    instr = new ThrowInstr(node->token_pos(),
                            owner()->try_index(),
                            for_exception.value());
   } else {
     ValueGraphVisitor for_stack_trace(owner(), temp_index());
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
-    instr = new ReThrowInstr(node->token_index(),
+    instr = new ReThrowInstr(node->token_pos(),
                              owner()->try_index(),
                              for_exception.value(),
                              for_stack_trace.value());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
@@ skipping 440 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart