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

vm/opt_code_generator_ia32.cc

 // Copyright (c) 2011, 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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 106 matching lines @@
         deopt_reason_id_(deopt_reason_id) {}
 
   void Push(Register reg) { registers_.Add(reg); }
 
   void Generate(OptimizingCodeGenerator* codegen) {
     codegen->assembler()->Bind(&label_);
     for (int i = 0; i < registers_.length(); i++) {
       codegen->assembler()->pushl(registers_[i]);
     }
     codegen->assembler()->movl(EAX, Immediate(Smi::RawValue(deopt_reason_id_)));
-    codegen->CallDeoptimize(node_->id(), node_->token_index());
+    codegen->CallDeoptimize(node_->id(), node_->token_pos());
 #if defined(DEBUG)
     // Check that deoptimization point exists in unoptimized code.
     const Code& unoptimized_code =
         Code::Handle(codegen->parsed_function().function().unoptimized_code());
     ASSERT(!unoptimized_code.IsNull());
     uword continue_at_pc =
         unoptimized_code.GetDeoptPcAtNodeId(node_->id());
     ASSERT(continue_at_pc != 0);
 #endif  // DEBUG
   }
@@ skipping 201 matching lines @@
 // Debugging helper function. TODO(srdjan): Remove
 void OptimizingCodeGenerator::PrintCollectedClasses(AstNode* node) {
   const ICData& ic_data = node->ic_data();
   OS::Print("Collected classes id %d num: %d\n",
       node->id(), ic_data.NumberOfChecks());
 }
 
 
 void OptimizingCodeGenerator::TraceOpt(AstNode* node, const char* message) {
   if (FLAG_trace_optimization) {
-    OS::Print("Opt node ix: %d; %s\n", node->token_index(), message);
+    OS::Print("Opt node ix: %d; %s\n", node->token_pos(), message);
   }
 }
 
 
 void OptimizingCodeGenerator::TraceNotOpt(AstNode* node, const char* message) {
   if (FLAG_trace_optimization) {
-    OS::Print("NOTOpt node ix: %d; %s: ", node->token_index(), message);
+    OS::Print("NOTOpt node ix: %d; %s: ", node->token_pos(), message);
     AstPrinter::PrintNode(node);
     OS::Print("\n");
   }
 }
 
 
 void OptimizingCodeGenerator::CallDeoptimize(intptr_t node_id,
-                                             intptr_t token_index) {
+                                             intptr_t token_pos) {
   __ call(&StubCode::DeoptimizeLabel());
-  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_pos);
 #if defined(DEBUG)
   __ int3();
 #endif
 }
 
 
 // Quick loads do not clobber registers.
 static bool IsQuickLoad(AstNode* node) {
   if (node->IsLoadLocalNode() && (!node->AsLoadLocalNode()->HasPseudo())) {
     return true;
@@ skipping 288 matching lines @@
       __ j(NOT_EQUAL, &slow_case, Assembler::kNearJump);  // Overflow.
       __ shll(EAX, imm);  // Shift for result now we know there is no overflow.
       __ jmp(&done);
       __ Bind(&slow_case);
       __ pushl(EAX);
       __ pushl(Immediate(reinterpret_cast<int32_t>(smi.raw())));
       const int number_of_arguments = 2;
       const Array& no_optional_argument_names = Array::Handle();
       GenerateCheckedInstanceCalls(node,
                                    node->left(),
-                                   node->token_index(),
+                                   node->token_pos(),
                                    number_of_arguments,
                                    no_optional_argument_names);
       __ Bind(&done);
       return;
     }
   }
 
   Label slow_case, done;
   CodeGenInfo left_info(node->left());
   CodeGenInfo right_info(node->right());
@@ skipping 23 matching lines @@
   __ shll(EAX, ECX);  // Shift for result now we know there is no overflow.
   // EAX is the correctly tagged Smi.
   __ jmp(&done);
   __ Bind(&slow_case);
   __ pushl(EAX);
   __ pushl(EDX);
   const int number_of_arguments = 2;
   const Array& no_optional_argument_names = Array::Handle();
   GenerateCheckedInstanceCalls(node,
                                node->left(),
-                               node->token_index(),
+                               node->token_pos(),
                                number_of_arguments,
                                no_optional_argument_names);
   __ Bind(&done);
 }
 
 
 // Implement Token::kSUB and Token::kBIT_NOT.
 void OptimizingCodeGenerator::GenerateSmiUnaryOp(UnaryOpNode* node) {
   const ICData& ic_data = node->ic_data();
   ASSERT(ic_data.num_args_tested() == 1);
@@ skipping 52 matching lines @@
                        deopt_blob->label());
     PropagateBackLocalClass(node->operand(), double_class_);
   }
   const bool using_temp =
       (node->info() != NULL) && node->info()->allow_temp();
   if (!using_temp) {
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
     const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
     __ pushl(kOperandRegister);
-    GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
+    GenerateCall(node->token_pos(), &label, PcDescriptors::kOther);
     ASSERT(kResultRegister == EAX);
     __ popl(kOperandRegister);
   } else if (info.is_temp()) {
     __ movl(kResultRegister, kOperandRegister);
   } else {
     const Double& double_object =
         Double::ZoneHandle(Double::New(0.0, Heap::kOld));
     __ LoadObject(kResultRegister, double_object);
   }
   __ movsd(XMM0, FieldAddress(kOperandRegister, Double::value_offset()));
@@ skipping 125 matching lines @@
         UNREACHABLE();
     }
   } else if ((kind == Token::kSHL) || (kind == Token::kSHR)) {
     GenerateSmiShiftBinaryOp(node);
   } else {
     // Unhandled node kind.
     TraceNotOpt(node, kOptMessage);
     node->left()->Visit(this);
     node->right()->Visit(this);
     CodeGenerator::GenerateBinaryOperatorCall(node->id(),
-                                              node->token_index(),
+                                              node->token_pos(),
                                               node->Name());
   }
   __ Bind(&done);
   HandleResult(node, EAX);
 }
 
 
 // Supports some mixed Smi/Mint operations.
 // For BIT_AND operation with right operand being Smi, we can throw away
 // any Mint bits above the Smi range as long as the right operand is positive.
@@ skipping 27 matching lines @@
     __ Bind(&is_smi);
     __ andl(EAX, EDX);
     __ jmp(&done);
     __ Bind(&slow_case);
     __ pushl(EAX);
     __ pushl(EDX);
     const int number_of_arguments = 2;
     const Array& no_optional_argument_names = Array::Handle();
     GenerateCheckedInstanceCalls(node,
                                  node->left(),
-                                 node->token_index(),
+                                 node->token_pos(),
                                  number_of_arguments,
                                  no_optional_argument_names);
     __ Bind(&done);
     HandleResult(node, EAX);
     return;
   }
   if ((kind == Token::kSHL) && allow_smi) {
     GenerateSmiShiftBinaryOp(node);
     HandleResult(node, EAX);
     return;
@@ skipping 72 matching lines @@
         (node->info() != NULL) && node->info()->allow_temp();
     if (!using_temp) {
       // Parent node cannot handle a temporary double object, allocate one
       // each time.
       result_register = kAllocatedRegister;
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
       __ pushl(kLeftRegister);
       __ pushl(kRightRegister);
-      GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
+      GenerateCall(node->token_pos(), &label, PcDescriptors::kOther);
       __ movl(result_register, EAX);
       __ popl(kRightRegister);
       __ popl(kLeftRegister);
     } else if (left_info.IsClass(double_class_) && left_info.is_temp()) {
       result_register = kLeftRegister;
     } else if (right_info.IsClass(double_class_) && right_info.is_temp()) {
       result_register = kRightRegister;
     } else {
       result_register = kAllocatedRegister;
       // Use inlined temporary double object.
@@ skipping 230 matching lines @@
   // TODO(srdjan): Implement "+" for Strings.
   // Type feedback tells this is not a Smi or Double operation.
   TraceNotOpt(node,
       "BinaryOp: type feedback tells this is not a Smi, Mint or Double op");
   node->left()->Visit(this);
   node->right()->Visit(this);
   const int number_of_arguments = 2;
   const Array& no_optional_argument_names = Array::Handle();
   GenerateCheckedInstanceCalls(node,
                                node->left(),
-                               node->token_index(),
+                               node->token_pos(),
                                number_of_arguments,
                                no_optional_argument_names);
   HandleResult(node, EAX);
   return;
 }
 
 
 // Return offset of a field or -1 if field is not found.
 static intptr_t GetFieldOffset(const Class& field_class,
                                const String& field_name) {
@@ skipping 158 matching lines @@
                                         receiver,
                                         field_name,
                                         recv_reg);
   } else {
     // TODO(srdjan): Inline access.
     __ pushl(recv_reg);
     const int kNumberOfArguments = 1;
     const Array& kNoArgumentNames = Array::Handle();
     GenerateCheckedInstanceCalls(node,
                                  receiver,
-                                 node->token_index(),
+                                 node->token_pos(),
                                  kNumberOfArguments,
                                  kNoArgumentNames);
   }
 }
 
 
 // TODO(srdjan): Implement for multiple getter targets.
 // For every class inline its implicit getter, or call the instance getter.
 void OptimizingCodeGenerator::VisitInstanceGetterNode(
     InstanceGetterNode* node) {
@@ skipping 18 matching lines @@
 
 
 // Helper struct to pass arguments to 'GenerateInstanceSetter'.
 struct InstanceSetterArgs {
   const Class* cls;
   const Function* target;
   const String* field_name;
   Register recv_reg;
   Register value_reg;
   intptr_t id;
-  intptr_t token_index;
+  intptr_t token_pos;
 };
 
 
 // Preserves 'args.value_reg'. Either stores instance field directly or
 // calls the setter method.
 void OptimizingCodeGenerator::GenerateInstanceSetter(
     const InstanceSetterArgs& args) {
   if (args.target->kind() == RawFunction::kImplicitSetter) {
     intptr_t field_offset = GetFieldOffset(*(args.cls), *(args.field_name));
     ASSERT(field_offset >= 0);
     __ StoreIntoObject(args.recv_reg,
         FieldAddress(args.recv_reg, field_offset), args.value_reg);
   } else {
     __ pushl(args.value_reg);
     __ pushl(args.recv_reg);
     __ pushl(args.value_reg);
     const Array& no_optional_argument_names = Array::Handle();
     GenerateDirectCall(args.id,
-                       args.token_index,
+                       args.token_pos,
                        *(args.target),
                        2,
                        no_optional_argument_names);
     __ popl(args.value_reg);
   }
 }
 
 
 // Returns value in 'value_reg', clobbers EBX.
 void OptimizingCodeGenerator::InlineInstanceSetter(AstNode* node,
@@ skipping 31 matching lines @@
       node, recv_reg, value_reg, kDeoptInstanceSetterSameTarget);
   // Deoptimize if Smi, since they do not have setters.
   if (NodeMayBeSmi(receiver)) {
     __ testl(recv_reg, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
   __ LoadClassId(EBX, recv_reg);
   // Initialize setter arguments, but leave the class and target fields NULL.
   InstanceSetterArgs setter_args =
       {NULL, NULL, &field_name, recv_reg, value_reg,
-      node->id(), node->token_index()};
+      node->id(), node->token_pos()};
 
   if (unique_target) {
     Label store_field;
     for (intptr_t i = 0; i < classes.length(); i++) {
       __ cmpl(EBX, Immediate(classes[i]->id()));
       if (i == (classes.length() - 1)) {
         __ j(NOT_EQUAL, deopt_blob->label());
       } else {
         __ j(EQUAL, &store_field);
       }
@@ skipping 171 matching lines @@
     __ jmp(&evaluate_comparison);
 
     __ Bind(&call_operator);
     // Left is Smi.
     const int kNumberOfArguments = 2;
     const Array& kNoArgumentNames = Array::Handle();
     __ pushl(EAX);
     __ pushl(EDX);
     GenerateCheckedInstanceCalls(node,
                                  node->left(),
-                                 node->token_index(),
+                                 node->token_pos(),
                                  kNumberOfArguments,
                                  kNoArgumentNames);
     __ CompareObject(EAX, bool_true);
     // Fall through to evaluate result.
   }
   __ Bind(&evaluate_comparison);
   // Condition is set by a previous comparison operation.
   Condition condition = OVERFLOW;  // Initialize to something.
   bool ok = SupportedTokenKindToSmiCondition(node->kind(), &condition);
   ASSERT(ok);
@@ skipping 273 matching lines @@
       __ PushObject(bool_true);
       __ Bind(&done);
     }
     return;
   }
 
   if (Token::IsInstanceofOperator(node->kind())) {
     VisitLoadOne(node->left(), EAX);
     ASSERT(node->right()->IsTypeNode());
     GenerateInstanceOf(node->id(),
-                       node->token_index(),
+                       node->token_pos(),
                        node->left(),
                        node->right()->AsTypeNode()->type(),
                        (node->kind() == Token::kISNOT));
     if (!IsResultNeeded(node)) {
       __ popl(EAX);  // Pop the result of the instanceof operation.
     }
     return;
   }
 
   if (NodeHasClassAt(node, smi_class_, 0)) {
@@ skipping 201 matching lines @@
     // Note that EAX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EDX,
                        FieldAddress(EDX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
     HandleResult(node, ECX);
     return;
   }
   node->index_expr()->Visit(this);
   node->value()->Visit(this);
-  GenerateStoreIndexed(node->id(), node->token_index(), IsResultNeeded(node));
+  GenerateStoreIndexed(node->id(), node->token_pos(), IsResultNeeded(node));
 }
 
 
 void OptimizingCodeGenerator::VisitForNode(ForNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitForNode(node);
     return;
   }
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   node->initializer()->Visit(this);
@@ skipping 10 matching lines @@
     if (condition_info.labels_used()) {
       __ Bind(&iterate_label);
     } else {
       __ popl(EAX);
       __ LoadObject(EDX, bool_true);
       __ cmpl(EAX, EDX);
       __ j(NOT_EQUAL, label->break_label());
     }
   }
   node->body()->Visit(this);
-  HandleBackwardBranch(node->id(), node->token_index());
+  HandleBackwardBranch(node->id(), node->token_pos());
   __ Bind(label->continue_label());
   node->increment()->Visit(this);
   __ jmp(&loop);
   __ Bind(label->break_label());
 }
 
 
 void OptimizingCodeGenerator::VisitDoWhileNode(DoWhileNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitDoWhileNode(node);
     return;
   }
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   SourceLabel* label = node->label();
   Label loop;
   __ Bind(&loop);
   node->body()->Visit(this);
-  HandleBackwardBranch(node->id(), node->token_index());
+  HandleBackwardBranch(node->id(), node->token_pos());
   __ Bind(label->continue_label());
   CodeGenInfo condition_info(node->condition());
   condition_info.set_false_label(label->break_label());
   condition_info.set_true_label(&loop);
   condition_info.set_fallthrough_label(label->break_label());
   node->condition()->Visit(this);
   if (!condition_info.labels_used()) {
     __ popl(EAX);
     __ LoadObject(EDX, bool_true);
     __ cmpl(EAX, EDX);
@@ skipping 19 matching lines @@
   node->condition()->Visit(this);
   if (condition_info.labels_used()) {
     __ Bind(&iterate_label);
   } else {
     __ popl(EAX);
     __ LoadObject(EDX, bool_true);
     __ cmpl(EAX, EDX);
     __ j(NOT_EQUAL, label->break_label());
   }
   node->body()->Visit(this);
-  HandleBackwardBranch(node->id(), node->token_index());
+  HandleBackwardBranch(node->id(), node->token_pos());
   __ jmp(label->continue_label());
   __ Bind(label->break_label());
 }
 
 
 void OptimizingCodeGenerator::VisitIfNode(IfNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitIfNode(node);
     return;
   }
@@ skipping 20 matching lines @@
     __ Bind(&done);
   } else {
     __ Bind(&false_label);
   }
   __ Bind(&done);
 }
 
 
 void OptimizingCodeGenerator::GenerateDirectCall(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const Function& target,
     intptr_t arg_count,
     const Array& optional_argument_names) {
   ASSERT(!target.IsNull());
   const Code& code = Code::Handle(target.CurrentCode());
   ASSERT(!code.IsNull());
   ExternalLabel target_label("DirectInstanceCall", code.EntryPoint());
 
   __ LoadObject(ECX, target);
   __ LoadObject(EDX, ArgumentsDescriptor(arg_count, optional_argument_names));
   __ call(&target_label);
-  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_pos);
   __ addl(ESP, Immediate(arg_count * kWordSize));
 }
 
 
 // Generate inline cache calls instead of deoptimizing when no type feedback is
 // provided.
 // TODO(srdjan): Recompilation framework should recognize active IC calls
 // in optimized code and mark them for reoptimization since type feedback was
 // collected in the meantime.
 void OptimizingCodeGenerator::GenerateInlineCacheCall(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const ICData& ic_data,
     intptr_t num_args,
     const Array& optional_arguments_names) {
   __ LoadObject(ECX, ic_data);
   __ LoadObject(EDX, ArgumentsDescriptor(num_args, optional_arguments_names));
 
   uword label_address = 0;
   switch (ic_data.num_args_tested()) {
     case 1:
       label_address = StubCode::OneArgCheckInlineCacheEntryPoint();
       break;
     case 2:
       label_address = StubCode::TwoArgsCheckInlineCacheEntryPoint();
       break;
     default:
       UNIMPLEMENTED();
   }
 
   ExternalLabel target_label("InlineCache", label_address);
 
   __ call(&target_label);
   AddCurrentDescriptor(PcDescriptors::kIcCall,
                        node_id,
-                       token_index);
+                       token_pos);
   __ addl(ESP, Immediate(num_args * kWordSize));
 }
 
 
 // Normalizes the ic_data class/target pairs:
 // - If Smi class exists, make it the first one.
 // - If 'null_target' not null, append null-class/'null_target'
 void OptimizingCodeGenerator::NormalizeClassChecks(
     const ICData& ic_data,
     const Function& null_target,
@@ skipping 35 matching lines @@
     targets->Add(&null_target);
   }
 }
 
 
 // Use IC data in 'node' to issues checks and calls.
 // IC data can contain one or more argument checks.
 void OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
     AstNode* node,
     AstNode* receiver,
-    intptr_t token_index,
+    intptr_t token_pos,
     intptr_t num_args,
     const Array& optional_arguments_names) {
   ASSERT(node != NULL);
   ASSERT(receiver != NULL);
   ASSERT(num_args > 0);
   const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback means node was never executed. However that can be
     // a common case especially in case of large switch statements.
     // Use a special inline cache call which can help us decide when to
     // re-optimize this optiumized function.
     GenerateInlineCacheCall(
-        node->id(), token_index, ic_data, num_args, optional_arguments_names);
+        node->id(), token_pos, ic_data, num_args, optional_arguments_names);
     return;
   }
 
   Function& target_for_null = Function::ZoneHandle();
   ObjectStore* object_store = Isolate::Current()->object_store();
   int num_optional_args =
       optional_arguments_names.IsNull() ? 0 : optional_arguments_names.Length();
   target_for_null = Resolver::ResolveDynamicForReceiverClass(
       Class::Handle(object_store->object_class()),
       String::Handle(ic_data.target_name()),
@@ skipping 12 matching lines @@
   if (classes[0]->raw() == smi_class_.raw()) {
     start_ix++;
     // Smi test is needed.
     __ testl(EAX, Immediate(kSmiTagMask));
     if (classes.length() == 1) {
       // Only Smi test.
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, kDeoptPolymorphicInstanceCallSmiOnly);
       __ j(NOT_ZERO, deopt_blob->label());
       GenerateDirectCall(node->id(),
-                         token_index,
+                         token_pos,
                          *targets[0],
                          num_args,
                          optional_arguments_names);
       return;
     }
     Label not_smi;
     __ j(NOT_ZERO, &not_smi);
     GenerateDirectCall(node->id(),
-                       token_index,
+                       token_pos,
                        *targets[0],
                        num_args,
                        optional_arguments_names);
     __ jmp(&done);
     __ Bind(&not_smi);  // Continue with other test below.
   } else if (NodeMayBeSmi(receiver)) {
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, kDeoptPolymorphicInstanceCallSmiFail);
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   } else {
     // Receiver cannot be Smi, no need to test it.
   }
   __ LoadClassId(EAX, EAX);  // Receiver's class id.
   for (intptr_t i = start_ix; i < classes.length(); i++) {
     const Class& cls = *classes[i];
     const Function& target = *targets[i];
     __ cmpl(EAX, Immediate(cls.id()));
     if (i == (classes.length() - 1)) {
       // Last check.
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, kDeoptPolymorphicInstanceCallTestFail);
       __ j(NOT_EQUAL, deopt_blob->label());
       GenerateDirectCall(node->id(),
-                         token_index,
+                         token_pos,
                          target,
                          num_args,
                          optional_arguments_names);
     } else {
       Label next;
       __ j(NOT_EQUAL, &next);
       GenerateDirectCall(node->id(),
-                         token_index,
+                         token_pos,
                          target,
                          num_args,
                          optional_arguments_names);
       __ jmp(&done);
       __ Bind(&next);
     }
   }
   __ Bind(&done);
 }
 
 
 void OptimizingCodeGenerator::VisitInstanceCallNode(InstanceCallNode* node) {
   const int number_of_arguments = node->arguments()->length() + 1;
   // Compute the receiver object and pass it as first argument to call.
   node->receiver()->Visit(this);
   // Now compute rest of the arguments to the call.
   node->arguments()->Visit(this);
   if (TryInlineInstanceCall(node)) {
     // Instance call is inlined.
   } else {
     GenerateCheckedInstanceCalls(node,
                                  node->receiver(),
-                                 node->token_index(),
+                                 node->token_pos(),
                                  number_of_arguments,
                                  node->arguments()->names());
   }
   // Result is in EAX.
   HandleResult(node, EAX);
 }
 
 
 // Returns true if an instance call was replaced with its intrinsic.
 // Returns result in EAX.
@@ skipping 14 matching lines @@
           target.ToFullyQualifiedCString(),
           Recognizer::KindToCString(recognized));
     }
     if ((recognized == Recognizer::kIntegerToDouble) &&
         NodeHasClassAt(node, smi_class_, 0)) {
       // TODO(srdjan): Check if we could use temporary double instead of
       // allocating a new object every time.
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
-      GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
+      GenerateCall(node->token_pos(), &label, PcDescriptors::kOther);
       // EAX is double object.
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, EBX, kDeoptIntegerToDouble);
       __ popl(EBX);  // Receiver
       __ testl(EBX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Deoptimize if not Smi.
       __ SmiUntag(EBX);
       __ cvtsi2sd(XMM0, EBX);
       __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
       return true;
@@ skipping 26 matching lines @@
                                  double_class_,
                                  &call_method,
                                  EAX);  // Result register.
     __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
     __ jmp(&done);
     __ Bind(&smi_to_double);
     __ Bind(&call_method);
     __ LoadObject(ECX, node->function());
     __ LoadObject(EDX, ArgumentsDescriptor(node->arguments()->length(),
                                            node->arguments()->names()));
-    GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel(),
+    GenerateCall(node->token_pos(), &StubCode::CallStaticFunctionLabel(),
                  PcDescriptors::kFuncCall);
     __ Bind(&done);
     return true;
   }
   return false;
 }
 
 
 void OptimizingCodeGenerator::VisitStaticCallNode(StaticCallNode* node) {
   node->arguments()->Visit(this);
   if (TryInlineStaticCall(node)) {
     // Static method is inlined, result is in EAX.
   } else {
     __ LoadObject(ECX, node->function());
     __ LoadObject(EDX, ArgumentsDescriptor(node->arguments()->length(),
                                            node->arguments()->names()));
-    GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel(),
+    GenerateCall(node->token_pos(), &StubCode::CallStaticFunctionLabel(),
                  PcDescriptors::kFuncCall);
   }
   __ addl(ESP, Immediate(node->arguments()->length() * kWordSize));
   // Result is in EAX.
   HandleResult(node, EAX);
 }
 
 
 void OptimizingCodeGenerator::VisitReturnNode(ReturnNode* node) {
   if ((node->inlined_finally_list_length() > 0) || FLAG_enable_type_checks) {
@@ skipping 98 matching lines @@
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32