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

vm/code_generator_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 305 matching lines @@
     __ pushl(FieldAddress(base, Context::variable_offset(variable.index())));
   } else {
     // The variable lives in the current stack frame.
     __ pushl(Address(EBP, variable.index() * kWordSize));
   }
 }
 
 
 void CodeGenerator::GenerateInstanceCall(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const String& function_name,
     int num_arguments,
     const Array& optional_arguments_names,
     intptr_t num_args_checked) {
   if (FLAG_print_ic_in_optimized && IsOptimizing()) {
     OS::Print("Generate IC in optimized code: id %d name: '%s'\n",
         node_id, function_name.ToCString());
   }
   ASSERT(num_args_checked > 0);  // At least receiver check is necessary.
   // Set up the function name and number of arguments (including the receiver)
@@ skipping 16 matching lines @@
       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_arguments * kWordSize));
 }
 
 
 // Input parameters:
 //   ESP : points to return address.
 //   ESP + 4 : address of last argument (arg n-1).
 //   ESP + 4*n : address of first argument (arg 0).
 //   EDX : arguments descriptor array.
 void CodeGenerator::GenerateEntryCode() {
@@ skipping 326 matching lines @@
     __ popl(EAX);  // Remove argument.
     __ popl(EAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
   // Add a NOP to make return code pattern 5 bytes long for patching
   // in breakpoints during debugging.
   __ nop(1);
   AddCurrentDescriptor(PcDescriptors::kReturn,
                        node->id(),
-                       node->token_index());
+                       node->token_pos());
 
 #ifdef DEBUG
   __ Bind(&wrong_stack);
   __ Stop("Exit stack size does not match the entry stack size.");
 #endif  // DEBUG.
 }
 
 
 void CodeGenerator::VisitReturnNode(ReturnNode* node) {
   ASSERT(!IsResultNeeded(node));
@@ skipping 28 matching lines @@
     const RawFunction::Kind kind = parsed_function().function().kind();
     const bool is_implicit_getter =
         (kind == RawFunction::kImplicitGetter) ||
         (kind == RawFunction::kConstImplicitGetter);
     const bool is_static = 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) {
       GenerateAssertAssignable(
           node->id(),
-          node->value()->token_index(),
+          node->value()->token_pos(),
           node->value(),
           AbstractType::ZoneHandle(parsed_function().function().result_type()),
           String::ZoneHandle(String::NewSymbol("function result")));
     }
   }
   GenerateReturnEpilog(node);
 }
 
 
 void CodeGenerator::VisitLiteralNode(LiteralNode* node) {
   if (!IsResultNeeded(node)) return;
   __ PushObject(node->literal());
 }
 
 
 void CodeGenerator::VisitTypeNode(TypeNode* node) {
   // Type nodes are handled specially by the code generator.
   UNREACHABLE();
 }
 
 
 void CodeGenerator::VisitAssignableNode(AssignableNode* node) {
   ASSERT(FLAG_enable_type_checks);
   node->expr()->Visit(this);
   __ popl(EAX);
   GenerateAssertAssignable(node->id(),
-                           node->token_index(),
+                           node->token_pos(),
                            node->expr(),
                            node->type(),
                            node->dst_name());
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitClosureNode(ClosureNode* node) {
@@ skipping 19 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.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     const bool kPushInstantiator = false;
-    GenerateInstantiatorTypeArguments(node->token_index(), kPushInstantiator);
+    GenerateInstantiatorTypeArguments(node->token_pos(), kPushInstantiator);
   } else {
     __ pushl(raw_null);  // No type arguments.
   }
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(function));
   const ExternalLabel label(function.ToCString(), stub.EntryPoint());
-  GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
+  GenerateCall(node->token_pos(), &label, PcDescriptors::kOther);
   __ popl(ECX);  // Pop type arguments.
   __ popl(ECX);  // Pop receiver.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitPrimaryNode(PrimaryNode* node) {
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
 void CodeGenerator::VisitCloneContextNode(CloneContextNode *node) {
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushl(CTX);
   GenerateCallRuntime(node->id(),
-      node->token_index(), kCloneContextRuntimeEntry);
+      node->token_pos(), kCloneContextRuntimeEntry);
   __ popl(EAX);
   __ popl(CTX);  // result: cloned context. Set as current context.
 }
 
 
 void CodeGenerator::VisitSequenceNode(SequenceNode* node_sequence) {
   CodeGeneratorState codegen_state(this);
   LocalScope* scope = node_sequence->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   intptr_t previous_context_level = context_level();
   if (num_context_variables > 0) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     __ movl(EDX, Immediate(num_context_variables));
     const ExternalLabel label("alloc_context",
                               StubCode::AllocateContextEntryPoint());
-    GenerateCall(node_sequence->token_index(), &label, PcDescriptors::kOther);
+    GenerateCall(node_sequence->token_pos(), &label, PcDescriptors::kOther);
 
     // 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 ((node_sequence == parsed_function_.node_sequence()) &&
         (parsed_function_.saved_context_var() != NULL)) {
       GenerateStoreVariable(
           *parsed_function_.saved_context_var(), CTX, kNoRegister);
       __ StoreIntoObjectNoBarrier(EAX,
@@ skipping 77 matching lines @@
 void CodeGenerator::VisitArrayNode(ArrayNode* node) {
   // Evaluate the array elements.
   for (int i = 0; i < node->length(); i++) {
     AstNode* element = node->ElementAt(i);
     element->Visit(this);
   }
 
   const AbstractTypeArguments& element_type = node->type_arguments();
   const bool instantiate_type_arguments =  true;
   GenerateTypeArguments(node->id(),
-                        node->token_index(),
+                        node->token_pos(),
                         element_type,
                         instantiate_type_arguments);
   __ popl(ECX);
   __ movl(EDX, Immediate(Smi::RawValue(node->length())));
 
   // Allocate the array.
   //   EDX : Array length as Smi.
   //   ECX : element type for the array.
-  GenerateCall(node->token_index(),
+  GenerateCall(node->token_pos(),
                &StubCode::AllocateArrayLabel(),
                PcDescriptors::kOther);
 
   // Pop the element values from the stack into the array.
   __ leal(ECX, FieldAddress(EAX, Array::data_offset()));
   for (int i = node->length() - 1; i >= 0; i--) {
     __ popl(Address(ECX, i * kWordSize));
   }
 
   if (IsResultNeeded(node)) {
@@ skipping 12 matching lines @@
     GeneratePushVariable(node->local(), EAX);
   }
 }
 
 
 void CodeGenerator::VisitStoreLocalNode(StoreLocalNode* node) {
   node->value()->Visit(this);
   __ popl(EAX);
   if (FLAG_enable_type_checks) {
     GenerateAssertAssignable(node->id(),
-                             node->value()->token_index(),
+                             node->value()->token_pos(),
                              node->value(),
                              node->local().type(),
                              node->local().name());
   }
   GenerateStoreVariable(node->local(), EAX, EDX);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitLoadInstanceFieldNode(LoadInstanceFieldNode* node) {
   node->instance()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   __ popl(EAX);  // Instance.
   __ movl(EAX, FieldAddress(EAX, node->field().Offset()));
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitStoreInstanceFieldNode(StoreInstanceFieldNode* node) {
   node->instance()->Visit(this);
   node->value()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   __ popl(EAX);  // Value.
   if (FLAG_enable_type_checks) {
     GenerateAssertAssignable(node->id(),
-                             node->value()->token_index(),
+                             node->value()->token_pos(),
                              node->value(),
                              AbstractType::ZoneHandle(node->field().type()),
                              String::ZoneHandle(node->field().name()));
   }
   __ popl(EDX);  // Instance.
   __ StoreIntoObject(EDX, FieldAddress(EDX, node->field().Offset()), EAX);
   ASSERT(!IsResultNeeded(node));
 }
 
 
 // Expects array and index on stack and returns result in EAX.
 void CodeGenerator::GenerateLoadIndexed(intptr_t node_id,
-                                        intptr_t token_index) {
+                                        intptr_t token_pos) {
   // Invoke the [] operator on the receiver object with the index as argument.
   const String& operator_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
   const int kNumArguments = 2;  // Receiver and index.
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
-                       token_index,
+                       token_pos,
                        operator_name,
                        kNumArguments,
                        kNoArgumentNames,
                        kNumArgumentsChecked);
 }
 
 
 void CodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
   node->array()->Visit(this);
   // Now compute the index.
   node->index_expr()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
-  GenerateLoadIndexed(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
+  GenerateLoadIndexed(node->id(), node->token_pos());
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Expected arguments.
 // TOS(0): value.
 // TOS(1): index.
 // TOS(2): array.
 void CodeGenerator::GenerateStoreIndexed(intptr_t node_id,
-                                         intptr_t token_index,
+                                         intptr_t token_pos,
                                          bool preserve_value) {
   // It is not necessary to generate a type test of the assigned value here,
   // because the []= operator will check the type of its incoming arguments.
   if (preserve_value) {
     __ popl(EAX);
     __ popl(EDX);
     __ popl(ECX);
     __ pushl(EAX);  // Preserve stored value.
     __ pushl(ECX);  // Restore arguments.
     __ pushl(EDX);
     __ pushl(EAX);
   }
   // Invoke the []= operator on the receiver object with index and
   // value as arguments.
   const String& operator_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
   const int kNumArguments = 3;  // Receiver, index and value.
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
-                       token_index,
+                       token_pos,
                        operator_name,
                        kNumArguments,
                        kNoArgumentNames,
                        kNumArgumentsChecked);
 }
 
 
 void CodeGenerator::VisitStoreIndexedNode(StoreIndexedNode* node) {
   // Compute the receiver object and pass as first argument to call.
   node->array()->Visit(this);
   // Now compute the index.
   node->index_expr()->Visit(this);
   // Finally compute the value to assign.
   node->value()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
-  GenerateStoreIndexed(node->id(), node->token_index(), IsResultNeeded(node));
+  MarkDeoptPoint(node->id(), node->token_pos());
+  GenerateStoreIndexed(node->id(), node->token_pos(), IsResultNeeded(node));
 }
 
 
 void CodeGenerator::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   __ LoadObject(EDX, node->field());
   __ movl(EAX, FieldAddress(EDX, Field::value_offset()));
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   node->value()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   __ popl(EAX);  // Value.
   if (FLAG_enable_type_checks) {
     GenerateAssertAssignable(node->id(),
-                             node->value()->token_index(),
+                             node->value()->token_pos(),
                              node->value(),
                              AbstractType::ZoneHandle(node->field().type()),
                              String::ZoneHandle(node->field().name()));
   }
   __ LoadObject(EDX, node->field());
   __ StoreIntoObject(EDX, FieldAddress(EDX, Field::value_offset()), EAX);
   if (IsResultNeeded(node)) {
     // The result is the input value.
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::GenerateLogicalNotOp(UnaryOpNode* node) {
   // Generate false if operand is true, otherwise generate true.
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   node->operand()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   Label done;
-  GenerateConditionTypeCheck(node->id(), node->operand()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->operand()->token_pos());
   __ popl(EDX);
   __ LoadObject(EAX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(EAX, bool_false);
   __ Bind(&done);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitUnaryOpNode(UnaryOpNode* node) {
   if (node->kind() == Token::kNOT) {
     // "!" cannot be overloaded, therefore inline it.
     GenerateLogicalNotOp(node);
     return;
   }
   node->operand()->Visit(this);
   if (node->kind() == Token::kADD) {
     // TODO(srdjan): Remove this as it is not part of Dart language any longer.
     // Unary operator '+' does not exist, it's a NOP, skip it.
     if (!IsResultNeeded(node)) {
       __ popl(EAX);
     }
     return;
   }
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   String& operator_name = String::ZoneHandle();
   if (node->kind() == Token::kSUB) {
     operator_name = String::NewSymbol(Token::Str(Token::kNEGATE));
   } else {
     operator_name = String::NewSymbol(node->Name());
   }
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node->id(),
-                       node->token_index(),
+                       node->token_pos(),
                        operator_name,
                        kNumberOfArguments,
                        kNoArgumentNames,
                        kNumArgumentsChecked);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Instance to test is in EAX. Test if its class is in subtype test cache array
 // and use the result in the array to jump to one of the labels. Fall through
 // if the instance is not in the cache array.
 // TODO(srdjan): Implement a quicker subtype check, as type test
 // arrays can grow too high, but they may be useful when optimizing
 // code (type-feedback).
 RawSubtypeTestCache* CodeGenerator::GenerateSubtype1TestCacheLookup(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const Class& type_class,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Check immediate equality.
   __ LoadClass(ECX, EAX, EDI);
@@ skipping 27 matching lines @@
   return type_test_cache.raw();
 }
 
 
 // Inline tests according to the 'type' being tested. Jump to labels
 // if we can compute the type-test, otherwise fallthrough.
 // EAX: instance to be tested, must be preserved.
 // Clobbers many registers.
 RawSubtypeTestCache* CodeGenerator::GenerateInlineInstanceof(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   if (type.IsInstantiated()) {
     const Class& type_class = Class::ZoneHandle(type.type_class());
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (type_class.HasTypeArguments()) {
       return GenerateInstantiatedTypeWithArgumentsTest(node_id,
-                                                       token_index,
+                                                       token_pos,
                                                        type,
                                                        is_instance_lbl,
                                                        is_not_instance_lbl);
       // Fall through to runtime call.
     } else {
       GenerateInstantiatedTypeNoArgumentsTest(node_id,
-                                              token_index,
+                                              token_pos,
                                               type,
                                               is_instance_lbl,
                                               is_not_instance_lbl);
       // If test non-conclusive so far, try the inlined type-test cache.
       // 'type' is known at compile time.
       return GenerateSubtype1TestCacheLookup(
-          node_id, token_index, type_class,
+          node_id, token_pos, type_class,
           is_instance_lbl, is_not_instance_lbl);
     }
   } else {
     return GenerateUninstantiatedTypeTest(type,
                                           node_id,
-                                          token_index,
+                                          token_pos,
                                           is_instance_lbl,
                                           is_not_instance_lbl);
   }
   return SubtypeTestCache::null();
 }
 
 
 // If instanceof type test cannot be performed successfully at compile time and
 // therefore eliminated, optimize it by adding inlined tests for:
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - EAX: object.
 // Destroys ECX.
 // Returns:
 // - true or false on stack.
 void CodeGenerator::GenerateInstanceOf(intptr_t node_id,
-                                       intptr_t token_index,
+                                       intptr_t token_pos,
                                        AstNode* value,
                                        const AbstractType& type,
                                        bool negate_result) {
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type =
       Type::Handle(Isolate::Current()->object_store()->object_type());
@@ skipping 46 matching lines @@
     // time, since an uninstantiated type at compile time could be Object or
     // Dynamic at run time.
     Label non_null;
     __ cmpl(EAX, raw_null);
     __ j(NOT_EQUAL, &non_null, Assembler::kNearJump);
     __ PushObject(negate_result ? bool_true : bool_false);
     __ jmp(&done);
     __ Bind(&non_null);
   }
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
-  test_cache = GenerateInlineInstanceof(node_id, token_index, type,
+  test_cache = GenerateInlineInstanceof(node_id, token_pos, type,
                                         &is_instance_of, &is_not_instance_of);
 
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
-  const Immediate location = Immediate(Smi::RawValue(token_index));
+  const Immediate location = Immediate(Smi::RawValue(token_pos));
   const Immediate node_id_as_smi = Immediate(Smi::RawValue(node_id));
   __ pushl(location);  // Push the source location.
   __ pushl(node_id_as_smi);  // node-id.
   __ pushl(EAX);  // Push the instance.
   __ PushObject(type);  // Push the type.
   if (type.IsInstantiated()) {
     __ pushl(raw_null);  // Null instantiator.
     __ pushl(raw_null);  // Null instantiator.
   } else {
     const bool kPushInstantiator = true;
-    GenerateInstantiatorTypeArguments(token_index, kPushInstantiator);
+    GenerateInstantiatorTypeArguments(token_pos, kPushInstantiator);
   }
   __ LoadObject(EAX, test_cache);
   __ pushl(EAX);
-  GenerateCallRuntime(node_id, token_index, kInstanceofRuntimeEntry);
+  GenerateCallRuntime(node_id, token_pos, kInstanceofRuntimeEntry);
   // Pop the two parameters supplied to the runtime entry. The result of the
   // instanceof runtime call will be left as the result of the operation.
   __ addl(ESP, Immediate(7 * kWordSize));
   if (negate_result) {
     __ popl(EDX);
     __ CompareObject(EDX, bool_false);
     __ j(EQUAL, &is_not_instance_of, Assembler::kNearJump);
     // Fall through to is_instance_of.
   } else {
     __ jmp(&done);
   }
 
   __ Bind(&is_instance_of);
   __ PushObject(negate_result ? bool_false: bool_true);
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&is_not_instance_of);
   __ PushObject(negate_result ? bool_true: bool_false);
   __ Bind(&done);
 }
 
 
 // EAX: instance to test.
 // Clobbers: ECX.
 // Jumps to labels 'is_instance' or 'is_not_instance' respectively, if
 // type test is conclusive, otherwise fallthrough if a type test could not
 // be completed.
 RawSubtypeTestCache* CodeGenerator::GenerateInstantiatedTypeWithArgumentsTest(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::ZoneHandle(type.type_class());
   ASSERT(type_class.HasTypeArguments());
   // A Smi object cannot be the instance of a parameterized class.
   // A class equality check is only applicable with a dst type of a
   // non-parameterized class or with a raw dst type of a parameterized class.
   __ testl(EAX, Immediate(kSmiTagMask));
@@ skipping 10 matching lines @@
       __ j(EQUAL, is_instance_lbl);
     }
     if (type.IsListInterface()) {
       // TODO(srdjan) also accept List<Object>.
       __ cmpl(ECX, Immediate(kArray));
       __ j(EQUAL, is_instance_lbl);
       __ cmpl(ECX, Immediate(kGrowableObjectArray));
       __ j(EQUAL, is_instance_lbl);
     }
     return
-        GenerateSubtype1TestCacheLookup(node_id, token_index, type_class,
+        GenerateSubtype1TestCacheLookup(node_id, token_pos, type_class,
                                         is_instance_lbl, is_not_instance_lbl);
   }
   // If one type argument only, quick check.
   if (type_arguments.Length() == 1) {
     const AbstractType& tp_argument = AbstractType::ZoneHandle(
         type_arguments.TypeAt(0));
     if (tp_argument.IsType()) {
       // Malformed type has been caught in the caller chain of this function.
       ASSERT(tp_argument.HasResolvedTypeClass());
       // Check if type argument is dynamic or Object.
       const Type& object_type =
           Type::Handle(Isolate::Current()->object_store()->object_type());
       Error& malformed_error = Error::Handle();
       if (object_type.IsSubtypeOf(tp_argument, &malformed_error)) {
         // Instance class test only necessary.
         return GenerateSubtype1TestCacheLookup(
             node_id,
-            token_index,
+            token_pos,
             type_class,
             is_instance_lbl,
             is_not_instance_lbl);
       }
     }
   }
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
   Label inlined_check, fall_through;
   const Immediate raw_null =
@@ skipping 16 matching lines @@
   __ jmp(is_not_instance_lbl);
   __ Bind(&fall_through);
   return type_test_cache.raw();
 }
 
 
 // EAX: instance to test.
 // Clobbers: EBX, ECX, EDX.
 void CodeGenerator::GenerateInstantiatedTypeNoArgumentsTest(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::Handle(type.type_class());
   ASSERT(!type_class.HasTypeArguments());
 
   Label compare_classes;
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &compare_classes, Assembler::kNearJump);
@@ skipping 66 matching lines @@
   }
   // Otherwise fallthrough.
 }
 
 
 // EAX: instance to test.
 // Clobbers: EBX, EDX, ECX.
 RawSubtypeTestCache* CodeGenerator::GenerateUninstantiatedTypeTest(
     const AbstractType& type,
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(!type.IsInstantiated());
   // Skip check if destination is a dynamic type.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   if (type.IsTypeParameter()) {
     // EAX must be preserved!
     Label fall_through;
     const bool kPushInstantiator = false;
-    GenerateInstantiatorTypeArguments(token_index, kPushInstantiator);
+    GenerateInstantiatorTypeArguments(token_pos, kPushInstantiator);
     // Type arguments are on stack.
     __ popl(EBX);
     // Check if type argument is dynamic.
     __ cmpl(EBX, raw_null);
     __ j(EQUAL, is_instance_lbl);
 
     // EBX: instantiator type arguments.
     // For now handle only TypeArguments and bail out if InstantiatedTypeArgs.
     // We expect that frequently checked objects wull have their type arguments
     // converted into instance of TypeArguments.
@@ skipping 49 matching lines @@
     __ testl(EAX, Immediate(kSmiTagMask));  // Is instance Smi?
     __ j(ZERO, is_not_instance_lbl);
     // Uninstantiated type class is known at compile time, but the type
     // arguments are determined at runtime by the instantiator.
     const SubtypeTestCache& type_test_cache =
         SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
     __ LoadObject(EDX, type_test_cache);
     __ pushl(EDX);  // Subtype test cache.
     __ pushl(EAX);  // Instance.
     const bool kPushInstantiator = false;
-    GenerateInstantiatorTypeArguments(token_index, kPushInstantiator);
+    GenerateInstantiatorTypeArguments(token_pos, kPushInstantiator);
     __ call(&StubCode::Subtype3TestCacheLabel());
     __ popl(EDX);  // Discard type arguments.
     __ popl(EAX);  // Restore receiver.
     __ popl(EDX);  // Discard subtype test cache.
     // Result is in ECX: null -> not found, otherwise Bool::True or Bool::False.
     __ cmpl(ECX, raw_null);
     __ j(EQUAL, &fall_through, Assembler::kNearJump);
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     __ CompareObject(ECX, bool_true);
     __ j(EQUAL, is_instance_lbl);
@@ skipping 11 matching lines @@
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - EAX: object.
 // Destroys ECX and EDX.
 // Returns:
 // - object in EAX for successful assignable check (or throws TypeError).
 // Performance notes: positive checks must be quick, negative checks can be slow
 // as they throw an exception.
 void CodeGenerator::GenerateAssertAssignable(intptr_t node_id,
-                                             intptr_t token_index,
+                                             intptr_t token_pos,
                                              AstNode* value,
                                              const AbstractType& dst_type,
                                              const String& dst_name) {
   ASSERT(FLAG_enable_type_checks);
-  ASSERT(token_index >= 0);
+  ASSERT(token_pos >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
   // Any expression is assignable to the Dynamic type and to the Object type.
   // Skip the test.
   if (!dst_type.IsMalformed() &&
       (dst_type.IsDynamicType() || dst_type.IsObjectType())) {
     return;
   }
 
@@ skipping 32 matching lines @@
   Label done, runtime_call;
   __ cmpl(EAX, raw_null);
   __ j(EQUAL, &done);
 
   // Generate throw new TypeError() if the type is malformed.
   if (dst_type.IsMalformed()) {
     const Error& error = Error::Handle(dst_type.malformed_error());
     const String& error_message = String::ZoneHandle(
         String::NewSymbol(error.ToErrorCString()));
     __ PushObject(Object::ZoneHandle());  // Make room for the result.
-    __ pushl(Immediate(Smi::RawValue(token_index)));  // Source location.
+    __ pushl(Immediate(Smi::RawValue(token_pos)));  // Source location.
     __ pushl(EAX);  // Push the source object.
     __ PushObject(dst_name);  // Push the name of the destination.
     __ PushObject(error_message);
-    GenerateCallRuntime(node_id, token_index, kMalformedTypeErrorRuntimeEntry);
+    GenerateCallRuntime(node_id, token_pos, kMalformedTypeErrorRuntimeEntry);
     // We should never return here.
     __ int3();
 
     __ Bind(&done);  // For a null object.
     return;
   }
 
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
-  test_cache = GenerateInlineInstanceof(node_id, token_index, dst_type,
+  test_cache = GenerateInlineInstanceof(node_id, token_pos, dst_type,
                                         &done, &runtime_call);
 
   __ Bind(&runtime_call);
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
-  __ pushl(Immediate(Smi::RawValue(token_index)));  // Source location.
+  __ pushl(Immediate(Smi::RawValue(token_pos)));  // Source location.
   __ pushl(Immediate(Smi::RawValue(node_id)));  // node-id.
   __ pushl(EAX);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   if (dst_type.IsInstantiated()) {
     __ pushl(raw_null);  // Null instantiator.
     __ pushl(raw_null);  // Null instantiator type argument.
   } else {
     const bool kPushInstantiator = true;
-    GenerateInstantiatorTypeArguments(token_index, kPushInstantiator);
+    GenerateInstantiatorTypeArguments(token_pos, kPushInstantiator);
   }
   __ PushObject(dst_name);  // Push the name of the destination.
   __ LoadObject(EAX, test_cache);
   __ pushl(EAX);
-  GenerateCallRuntime(node_id, token_index, kTypeCheckRuntimeEntry);
+  GenerateCallRuntime(node_id, token_pos, kTypeCheckRuntimeEntry);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ addl(ESP, Immediate(8 * kWordSize));
   __ popl(EAX);
 
   // EAX: value.
   __ Bind(&done);
 }
 
 
 void CodeGenerator::GenerateArgumentTypeChecks() {
   const Function& function = parsed_function_.function();
   const SequenceNode& sequence_node = *parsed_function_.node_sequence();
   LocalScope* scope = sequence_node.scope();
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_opt_params = function.num_optional_parameters();
   ASSERT(num_fixed_params + num_opt_params <= scope->num_variables());
   for (intptr_t i = 0; i < num_fixed_params + num_opt_params; i++) {
     LocalVariable* parameter = scope->VariableAt(i);
     GenerateLoadVariable(EAX, *parameter);
     GenerateAssertAssignable(sequence_node.ParameterIdAt(i),
-                             parameter->token_index(),
+                             parameter->token_pos(),
                              NULL,
                              parameter->type(),
                              parameter->name());
   }
 }
 
 
 void CodeGenerator::GenerateConditionTypeCheck(intptr_t node_id,
-                                               intptr_t token_index) {
+                                               intptr_t token_pos) {
   if (!FLAG_enable_type_checks) {
     return;
   }
 
   // Check that the type of the object on the stack is allowed in conditional
   // context.
   // Call the runtime if the object is null or not of type bool.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label runtime_call, done;
   __ movl(EAX, Address(ESP, 0));
   __ cmpl(EAX, raw_null);
   __ j(EQUAL, &runtime_call, Assembler::kNearJump);
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(ZERO, &runtime_call, Assembler::kNearJump);  // Call runtime for Smi.
   // This check should pass if the receiver's class implements the interface
   // 'bool'. Check only class 'Bool' since it is the only legal implementation
   // of the interface 'bool'.
   __ CompareClassId(EAX, kBool, ECX);
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ Bind(&runtime_call);
-  __ pushl(Immediate(Smi::RawValue(token_index)));  // Source location.
+  __ pushl(Immediate(Smi::RawValue(token_pos)));  // Source location.
   __ pushl(EAX);  // Push the source object.
-  GenerateCallRuntime(node_id, token_index, kConditionTypeErrorRuntimeEntry);
+  GenerateCallRuntime(node_id, token_pos, kConditionTypeErrorRuntimeEntry);
   // We should never return here.
   __ int3();
 
   __ Bind(&done);
 }
 
 
 void CodeGenerator::VisitComparisonNode(ComparisonNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   node->left()->Visit(this);
 
   // The instanceof operator needs special handling.
   if (Token::IsInstanceofOperator(node->kind())) {
     __ popl(EAX);  // Left operand.
     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;
   }
 
   node->right()->Visit(this);
@@ skipping 17 matching lines @@
     __ LoadObject(EAX, bool_false);
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&load_true);
     __ LoadObject(EAX, bool_true);
     __ Bind(&done);
     // Result is in EAX.
     __ pushl(EAX);
     return;
   }
 
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
 
   // '!=' not overloadable, always implements negation of '=='.
   // Call operator for '=='.
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     // Null is a special receiver with a special type and frequently used on
     // operators "==" and "!=". Emit inlined code for null so that it does not
     // pollute type information at call site.
     Label null_done;
     {
       const Immediate raw_null =
@@ skipping 18 matching lines @@
       __ LoadObject(EAX, bool_true);
       __ jmp(&null_done, Assembler::kNearJump);
       __ Bind(&non_null_compare);
     }
     // Do '==' first then negate if necessary,
     const String& operator_name = String::ZoneHandle(String::NewSymbol("=="));
     const int kNumberOfArguments = 2;
     const Array& kNoArgumentNames = Array::Handle();
     const int kNumArgumentsChecked = 1;
     GenerateInstanceCall(node->id(),
-                         node->token_index(),
+                         node->token_pos(),
                          operator_name,
                          kNumberOfArguments,
                          kNoArgumentNames,
                          kNumArgumentsChecked);
 
     // Result is in EAX. No need to negate if result is not needed.
     if ((node->kind() == Token::kNE) && IsResultNeeded(node)) {
       // Negate result.
       Label load_true, done;
       __ LoadObject(EDX, bool_false);
       __ cmpl(EAX, EDX);
       __ j(EQUAL, &load_true, Assembler::kNearJump);
       __ movl(EAX, EDX);  // false.
       __ jmp(&done, Assembler::kNearJump);
       __ Bind(&load_true);
       __ LoadObject(EAX, bool_true);
       __ Bind(&done);
     }
     __ Bind(&null_done);
     // Result is in EAX.
     if (IsResultNeeded(node)) {
       __ pushl(EAX);
     }
     return;
   }
 
   // Call operator.
-  GenerateBinaryOperatorCall(node->id(), node->token_index(), node->Name());
+  GenerateBinaryOperatorCall(node->id(), node->token_pos(), node->Name());
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::HandleBackwardBranch(
-    intptr_t loop_id, intptr_t token_index) {
+    intptr_t loop_id, intptr_t token_pos) {
   // Use stack overflow check to eventually stop execution of loops.
   // This is necessary only if a loop does not have calls.
   __ cmpl(ESP,
           Address::Absolute(Isolate::Current()->stack_limit_address()));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow);
   GenerateCallRuntime(loop_id,
-                      token_index,
+                      token_pos,
                       kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
 
 void CodeGenerator::VisitWhileNode(WhileNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   SourceLabel* label = node->label();
   __ Bind(label->continue_label());
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_pos());
   __ 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 CodeGenerator::VisitDoWhileNode(DoWhileNode* node) {
   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());
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_pos());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(EQUAL, &loop);
   __ Bind(label->break_label());
 }
 
 
 void CodeGenerator::VisitForNode(ForNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   node->initializer()->Visit(this);
   SourceLabel* label = node->label();
   Label loop;
   __ Bind(&loop);
   if (node->condition() != NULL) {
     node->condition()->Visit(this);
-    GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
+    GenerateConditionTypeCheck(node->id(), node->condition()->token_pos());
     __ 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 CodeGenerator::VisitJumpNode(JumpNode* node) {
   SourceLabel* label = node->label();
 
@@ skipping 35 matching lines @@
   } else {
     __ jmp(label->continue_label());
   }
 }
 
 
 void CodeGenerator::VisitConditionalExprNode(ConditionalExprNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   Label false_label, done;
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_pos());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, &false_label);
   node->true_expr()->Visit(this);
   __ jmp(&done);
   __ Bind(&false_label);
   node->false_expr()->Visit(this);
   __ Bind(&done);
   if (!IsResultNeeded(node)) {
@@ skipping 39 matching lines @@
   __ Bind(&case_statements);
   node->statements()->Visit(this);
   __ Bind(&end_case);
 }
 
 
 void CodeGenerator::VisitIfNode(IfNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   Label false_label;
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_pos());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, &false_label);
   node->true_branch()->Visit(this);
   if (node->false_branch() != NULL) {
     Label done;
     __ jmp(&done);
     __ Bind(&false_label);
     node->false_branch()->Visit(this);
     __ Bind(&done);
   } else {
     __ Bind(&false_label);
   }
 }
 
 
 // Operators '&&' and '||' are not overloadabled, inline them.
 void CodeGenerator::GenerateLogicalAndOrOp(BinaryOpNode* node) {
   // Generate true if (left == true) op (right == true), otherwise generate
   // false, with op being either || or &&.
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label load_false, done;
   node->left()->Visit(this);
-  GenerateConditionTypeCheck(node->id(), node->left()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->left()->token_pos());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   if (node->kind() == Token::kAND) {
     __ j(NOT_EQUAL, &load_false);
   } else {
     ASSERT(node->kind() == Token::kOR);
     __ j(EQUAL, &done);
   }
   node->right()->Visit(this);
-  GenerateConditionTypeCheck(node->id(), node->right()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->right()->token_pos());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(EQUAL, &done);
   __ Bind(&load_false);
   __ LoadObject(EAX, bool_false);
   __ Bind(&done);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Expect receiver(left operand) and right operand on stack.
 // Return result in EAX.
 void CodeGenerator::GenerateBinaryOperatorCall(intptr_t node_id,
-                                               intptr_t token_index,
+                                               intptr_t token_pos,
                                                const char* name) {
   const String& operator_name = String::ZoneHandle(String::NewSymbol(name));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
   GenerateInstanceCall(node_id,
-                       token_index,
+                       token_pos,
                        operator_name,
                        kNumberOfArguments,
                        kNoArgumentNames,
                        kNumArgumentsChecked);
 }
 
 
 void CodeGenerator::VisitBinaryOpNode(BinaryOpNode* node) {
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Operators "&&" and "||" cannot be overloaded, therefore inline them
     // instead of calling the operator.
     GenerateLogicalAndOrOp(node);
     return;
   }
   node->left()->Visit(this);
   node->right()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
-  GenerateBinaryOperatorCall(node->id(), node->token_index(), node->Name());
+  MarkDeoptPoint(node->id(), node->token_pos());
+  GenerateBinaryOperatorCall(node->id(), node->token_pos(), node->Name());
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitStringConcatNode(StringConcatNode* node) {
   const String& cls_name = String::Handle(String::NewSymbol("StringBase"));
   const Library& core_lib = Library::Handle(
       Isolate::Current()->object_store()->core_library());
@@ skipping 29 matching lines @@
     interpolate_arg.Add(&literals);
     const Array& kNoArgumentNames = Array::Handle();
     // Call the interpolation function.
     String& concatenated = String::ZoneHandle();
     concatenated ^= DartEntry::InvokeStatic(interpol_func,
                                             interpolate_arg,
                                             kNoArgumentNames);
     if (concatenated.IsUnhandledException()) {
       // TODO(hausner): Shouldn't we generate a throw?
       // Then remove unused CodeGenerator::ErrorMsg().
-      ErrorMsg(node->token_index(),
+      ErrorMsg(node->token_pos(),
           "Exception thrown in CodeGenerator::VisitStringConcatNode");
     }
     ASSERT(!concatenated.IsNull());
     concatenated = String::NewSymbol(concatenated);
 
     __ LoadObject(EAX, concatenated);
     __ pushl(EAX);
     return;
   }
 
   // Could not concatenate at compile time, generate a call to
   // interpolation function.
-  ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_index());
+  ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_pos());
   interpol_arg->Add(node->values());
   node->values()->Visit(this);
   __ LoadObject(ECX, interpol_func);
   __ LoadObject(EDX, ArgumentsDescriptor(interpol_arg->length(),
                                          interpol_arg->names()));
-  GenerateCall(node->token_index(),
+  GenerateCall(node->token_pos(),
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
   __ addl(ESP, Immediate(interpol_arg->length() * kWordSize));
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::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);
   // Some method may be inlined using type feedback, therefore this may be a
   // deoptimization point.
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node->id(),
-                       node->token_index(),
+                       node->token_pos(),
                        node->function_name(),
                        number_of_arguments,
                        node->arguments()->names(),
                        kNumArgumentsChecked);
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitStaticCallNode(StaticCallNode* node) {
   node->arguments()->Visit(this);
   __ LoadObject(ECX, node->function());
   __ LoadObject(EDX, ArgumentsDescriptor(node->arguments()->length(),
                                          node->arguments()->names()));
-  GenerateCall(node->token_index(),
+  GenerateCall(node->token_pos(),
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
   __ addl(ESP, Immediate(node->arguments()->length() * kWordSize));
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitClosureCallNode(ClosureCallNode* node) {
   // The spec states that the closure is evaluated before the arguments.
   // Preserve the current context, since it will be overridden by the closure
   // context during the call.
   __ pushl(CTX);
   // Compute the closure object and pass it as first argument to the stub.
   node->closure()->Visit(this);
   // Now compute the arguments to the call.
   node->arguments()->Visit(this);
   // Set up the number of arguments (excluding the closure) to the ClosureCall
   // stub which will setup the closure context and jump to the entrypoint of the
   // closure function (the function will be compiled if it has not already been
   // compiled).
   // NOTE: The stub accesses the closure before the parameter list.
   __ LoadObject(EDX, ArgumentsDescriptor(node->arguments()->length(),
                                          node->arguments()->names()));
-  GenerateCall(node->token_index(),
+  GenerateCall(node->token_pos(),
                &StubCode::CallClosureFunctionLabel(),
                PcDescriptors::kOther);
   __ addl(ESP, Immediate((node->arguments()->length() + 1) * kWordSize));
   // Restore the context.
   __ popl(CTX);
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Pushes either the instantiator or null.
 // Pushes the type arguments of the instantiator on the stack.
 // Destroys EBX, ECX.
-void CodeGenerator::GenerateInstantiatorTypeArguments(intptr_t token_index,
+void CodeGenerator::GenerateInstantiatorTypeArguments(intptr_t token_pos,
                                                       bool push_instantiator) {
   if (push_instantiator) {
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ pushl(raw_null);  // Initial instantiator.
   }
   const Class& instantiator_class = Class::Handle(
       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();
     __ PushObject(type_arguments);
   } else {
     ASSERT(parsed_function().instantiator() != NULL);
     parsed_function().instantiator()->Visit(this);
     Function& outer_function =
         Function::Handle(parsed_function().function().raw());
     while (outer_function.IsLocalFunction()) {
@@ skipping 24 matching lines @@
 
 // Pushes the type arguments on the stack in preparation of an allocation call.
 // If instantiate_type_arguments is true, the instantiated type arguments
 // are pushed on the stack (after an instantiation run time call, if necessary).
 // If instantiate_type_arguments is false, the (possibly uninstantiated) type
 // arguments are pushed on the stack, as well as the type arguments of the
 // instantiator (or the special kNoInstantiator Smi marker, if the type
 // arguments are instantiated).
 void CodeGenerator::GenerateTypeArguments(
     intptr_t node_id,
-    intptr_t token_index,
+    intptr_t token_pos,
     const AbstractTypeArguments& type_arguments,
     bool instantiate_type_arguments) {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     // The type arguments are instantiated.
     __ PushObject(type_arguments);
     if (!instantiate_type_arguments) {
       // The type arguments of the instantiator are not needed, since the
       // type arguments are instantiated.
       __ pushl(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
     }
   } else {
     // The type arguments are uninstantiated.
     const bool kPushInstantiator = false;
-    GenerateInstantiatorTypeArguments(token_index, kPushInstantiator);
+    GenerateInstantiatorTypeArguments(token_pos, kPushInstantiator);
     __ popl(EAX);  // Pop instantiator.
     // EAX is the instantiator AbstractTypeArguments object (or null).
     // If the instantiator is null and if the type argument vector
     // instantiated from null becomes a vector of Dynamic, then use null as
     // the type arguments.
     Label type_arguments_instantiated;
     const intptr_t len = type_arguments.Length();
     if (type_arguments.IsRawInstantiatedRaw(len)) {
       __ cmpl(EAX, raw_null);
       __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
@@ skipping 11 matching lines @@
               Immediate(Smi::RawValue(len)));
       __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
       __ Bind(&type_arguments_uninstantiated);
     }
     if (instantiate_type_arguments) {
       // A runtime call to instantiate the type arguments is required.
       __ PushObject(Object::ZoneHandle());  // Make room for the result.
       __ PushObject(type_arguments);
       __ pushl(EAX);  // Push instantiator type arguments.
       GenerateCallRuntime(node_id,
-                          token_index,
+                          token_pos,
                           kInstantiateTypeArgumentsRuntimeEntry);
       __ popl(EAX);  // Pop instantiator type arguments.
       __ popl(EAX);  // Pop uninstantiated type arguments.
       __ popl(EAX);  // Pop instantiated type arguments.
       __ Bind(&type_arguments_instantiated);
       __ pushl(EAX);  // Instantiated type arguments.
     } else {
       // The allocation stub will instantiate the type arguments.
       __ PushObject(type_arguments);
       __ pushl(EAX);  // Instantiator type arguments.
       Label type_arguments_pushed;
       __ jmp(&type_arguments_pushed, Assembler::kNearJump);
 
       __ Bind(&type_arguments_instantiated);
       __ pushl(EAX);  // Instantiated type arguments.
       __ pushl(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
       __ Bind(&type_arguments_pushed);
     }
   }
 }
 
 
 void CodeGenerator::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     const bool instantiate_type_arguments = true;  // First argument to factory.
     GenerateTypeArguments(node->id(),
-                          node->token_index(),
+                          node->token_pos(),
                           node->type_arguments(),
                           instantiate_type_arguments);
     // The top of stack is an instantiated AbstractTypeArguments object
     // (or null).
     int num_args = node->arguments()->length() + 1;  // +1 to include type args.
     node->arguments()->Visit(this);
     // Call the factory.
     __ LoadObject(ECX, node->constructor());
     __ LoadObject(EDX, ArgumentsDescriptor(num_args,
                                            node->arguments()->names()));
-    GenerateCall(node->token_index(),
+    GenerateCall(node->token_pos(),
                  &StubCode::CallStaticFunctionLabel(),
                  PcDescriptors::kFuncCall);
     // Factory constructor returns object in EAX.
     __ addl(ESP, Immediate(num_args * kWordSize));
     if (IsResultNeeded(node)) {
       __ pushl(EAX);
     }
     return;
   }
 
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
   const bool instantiate_type_arguments = false;  // Done in stub or runtime.
   if (requires_type_arguments) {
     GenerateTypeArguments(node->id(),
-                          node->token_index(),
+                          node->token_pos(),
                           node->type_arguments(),
                           instantiate_type_arguments);
   }
 
   // If cls is parameterized, the type arguments and the instantiator's
   // type arguments are on the stack.
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
   Error& malformed_error = Error::Handle();
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
       !node->type_arguments().IsWithinBoundsOf(cls,
                                                node->type_arguments(),
                                                &malformed_error)) {
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
     // Although the type arguments may be uninstantiated at compile time, they
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
     __ popl(ECX);  // Pop instantiator type arguments.
     __ popl(EAX);  // Pop type arguments.
 
     // Push the result place holder initialized to NULL.
     __ PushObject(Object::ZoneHandle());
-    __ pushl(Immediate(Smi::RawValue(node->token_index())));
+    __ pushl(Immediate(Smi::RawValue(node->token_pos())));
     __ PushObject(cls);
     __ pushl(EAX);  // Push type arguments.
     __ pushl(ECX);  // Push instantiator type arguments.
     GenerateCallRuntime(node->id(),
-                        node->token_index(),
+                        node->token_pos(),
                         kAllocateObjectWithBoundsCheckRuntimeEntry);
     __ popl(ECX);  // Pop instantiator type arguments.
     __ popl(ECX);  // Pop type arguments.
     __ popl(ECX);  // Pop class.
     __ popl(ECX);  // Pop source location.
     __ popl(EAX);  // Pop new instance.
   } else {
     const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
     const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
-    GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
+    GenerateCall(node->token_pos(), &label, PcDescriptors::kOther);
     if (requires_type_arguments) {
       __ popl(ECX);  // Pop instantiator type arguments.
       __ popl(ECX);  // Pop type arguments.
     }
   }
 
   if (IsResultNeeded(node)) {
     __ pushl(EAX);  // Set up return value from allocate.
   }
 
   // First argument(this) for constructor call which follows.
   __ pushl(EAX);
   // Second argument is the implicit construction phase parameter.
   // Run both the constructor initializer list and the constructor body.
   __ pushl(Immediate(Smi::RawValue(Function::kCtorPhaseAll)));
 
   // Now setup rest of the arguments for the constructor call.
   node->arguments()->Visit(this);
 
   // Call the constructor.
   // +2 to include implicit receiver and phase arguments.
   int num_args = node->arguments()->length() + 2;
   __ LoadObject(ECX, node->constructor());
   __ LoadObject(EDX, ArgumentsDescriptor(num_args, node->arguments()->names()));
-  GenerateCall(node->token_index(),
+  GenerateCall(node->token_pos(),
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
   // Constructors do not return any value.
 
   // Pop out all the other arguments on the stack.
   __ addl(ESP, Immediate(num_args * kWordSize));
 }
 
 
 // Expects receiver on stack, returns result in EAX..
 void CodeGenerator::GenerateInstanceGetterCall(intptr_t node_id,
-                                               intptr_t token_index,
+                                               intptr_t token_pos,
                                                const String& field_name) {
   const String& getter_name =
       String::ZoneHandle(Field::GetterSymbol(field_name));
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
-                       token_index,
+                       token_pos,
                        getter_name,
                        kNumberOfArguments,
                        kNoArgumentNames,
                        kNumArgumentsChecked);
 }
 
 
 // Call to the instance getter.
 void CodeGenerator::VisitInstanceGetterNode(InstanceGetterNode* node) {
   node->receiver()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   GenerateInstanceGetterCall(node->id(),
-                             node->token_index(),
+                             node->token_pos(),
                              node->field_name());
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Expects receiver and value on stack.
 void CodeGenerator::GenerateInstanceSetterCall(intptr_t node_id,
-                                               intptr_t token_index,
+                                               intptr_t token_pos,
                                                const String& field_name) {
   const String& setter_name =
       String::ZoneHandle(Field::SetterSymbol(field_name));
   const int kNumberOfArguments = 2;  // receiver + value.
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
-                       token_index,
+                       token_pos,
                        setter_name,
                        kNumberOfArguments,
                        kNoArgumentNames,
                        kNumArgumentsChecked);
 }
 
 
 // The call to the instance setter implements the assignment to a field.
 // The result of the assignment to a field is the value being stored.
 void CodeGenerator::VisitInstanceSetterNode(InstanceSetterNode* node) {
   // Compute the receiver object and pass it as first argument to call.
   node->receiver()->Visit(this);
   node->value()->Visit(this);
-  MarkDeoptPoint(node->id(), node->token_index());
+  MarkDeoptPoint(node->id(), node->token_pos());
   if (IsResultNeeded(node)) {
     __ popl(EAX);   // value.
     __ popl(EDX);   // receiver.
     __ pushl(EAX);  // Preserve value.
     __ pushl(EDX);  // arg0: receiver.
     __ pushl(EAX);  // arg1: value.
   }
   // It is not necessary to generate a type test of the assigned value here,
   // because the setter will check the type of its incoming arguments.
   GenerateInstanceSetterCall(node->id(),
-                             node->token_index(),
+                             node->token_pos(),
                              node->field_name());
 }
 
 
 // Return result in EAX.
-void CodeGenerator::GenerateStaticGetterCall(intptr_t token_index,
+void CodeGenerator::GenerateStaticGetterCall(intptr_t token_pos,
                                              const Class& field_class,
                                              const String& field_name) {
   const String& getter_name = String::Handle(Field::GetterName(field_name));
   const Function& function =
       Function::ZoneHandle(field_class.LookupStaticFunction(getter_name));
   ASSERT(!function.IsNull());
   __ LoadObject(ECX, function);
   const int kNumberOfArguments = 0;
   const Array& kNoArgumentNames = Array::Handle();
   __ LoadObject(EDX, ArgumentsDescriptor(kNumberOfArguments, kNoArgumentNames));
-  GenerateCall(token_index,
+  GenerateCall(token_pos,
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
   // No arguments were pushed, hence nothing to pop.
 }
 
 
 // Call to static getter.
 void CodeGenerator::VisitStaticGetterNode(StaticGetterNode* node) {
-  GenerateStaticGetterCall(node->token_index(),
+  GenerateStaticGetterCall(node->token_pos(),
                            node->cls(),
                            node->field_name());
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Expects value on stack.
-void CodeGenerator::GenerateStaticSetterCall(intptr_t token_index,
+void CodeGenerator::GenerateStaticSetterCall(intptr_t token_pos,
                                              const Class& field_class,
                                              const String& field_name) {
   const String& setter_name = String::Handle(Field::SetterName(field_name));
   const Function& function =
       Function::ZoneHandle(field_class.LookupStaticFunction(setter_name));
   ASSERT(!function.IsNull());
   __ LoadObject(ECX, function);
   const int kNumberOfArguments = 1;  // value.
   const Array& kNoArgumentNames = Array::Handle();
   __ LoadObject(EDX, ArgumentsDescriptor(kNumberOfArguments, kNoArgumentNames));
-  GenerateCall(token_index,
+  GenerateCall(token_pos,
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
   __ addl(ESP, Immediate(kNumberOfArguments * kWordSize));
 }
 
 
 // The call to static setter implements assignment to a static field.
 // The result of the assignment is the value being stored.
 void CodeGenerator::VisitStaticSetterNode(StaticSetterNode* node) {
   node->value()->Visit(this);
   if (IsResultNeeded(node)) {
     // Preserve the original value when returning from setter.
     __ movl(EAX, Address(ESP, 0));
     __ pushl(EAX);  // arg0: value.
   }
   // It is not necessary to generate a type test of the assigned value here,
   // because the setter will check the type of its incoming arguments.
-  GenerateStaticSetterCall(node->token_index(),
+  GenerateStaticSetterCall(node->token_pos(),
                            node->cls(),
                            node->field_name());
 }
 
 
 void CodeGenerator::VisitNativeBodyNode(NativeBodyNode* node) {
   intptr_t argument_count = node->argument_count();
   if (node->is_native_instance_closure()) {
     argument_count += 1;
   }
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in EAX.
   if (!node->has_optional_parameters() && !node->is_native_instance_closure()) {
     __ leal(EAX, Address(EBP, (1 + argument_count) * kWordSize));
   } else {
     __ leal(EAX,
             Address(EBP, ParsedFunction::kFirstLocalSlotIndex * kWordSize));
   }
   __ movl(ECX, Immediate(reinterpret_cast<uword>(node->native_c_function())));
   __ movl(EDX, Immediate(argument_count));
-  GenerateCall(node->token_index(),
+  GenerateCall(node->token_pos(),
                &StubCode::CallNativeCFunctionLabel(),
                PcDescriptors::kOther);
   // Result is on the stack.
   if (!IsResultNeeded(node)) {
     __ popl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitCatchClauseNode(CatchClauseNode* node) {
@@ skipping 72 matching lines @@
     node->finally_block()->Visit(this);
   }
 }
 
 
 void CodeGenerator::VisitThrowNode(ThrowNode* node) {
   node->exception()->Visit(this);
   // Exception object is on TOS.
   if (node->stacktrace() != NULL) {
     node->stacktrace()->Visit(this);
-    GenerateCallRuntime(node->id(), node->token_index(), kReThrowRuntimeEntry);
+    GenerateCallRuntime(node->id(), node->token_pos(), kReThrowRuntimeEntry);
   } else {
-    GenerateCallRuntime(node->id(), node->token_index(), kThrowRuntimeEntry);
+    GenerateCallRuntime(node->id(), node->token_pos(), kThrowRuntimeEntry);
   }
   // We should never return here.
   __ int3();
 }
 
 
 void CodeGenerator::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   int try_index = state()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     // the code generator state.
     state()->set_try_index((try_index - 1));
   }
 
   // Restore CTX from local variable ':saved_context'.
   GenerateLoadVariable(CTX, node->context_var());
   node->finally_block()->Visit(this);
 
   if (try_index >= 0) {
     state()->set_try_index(try_index);
   }
 }
 
 
-void CodeGenerator::GenerateCall(intptr_t token_index,
+void CodeGenerator::GenerateCall(intptr_t token_pos,
                                  const ExternalLabel* ext_label,
                                  PcDescriptors::Kind desc_kind) {
   __ call(ext_label);
-  AddCurrentDescriptor(desc_kind, AstNode::kNoId, token_index);
+  AddCurrentDescriptor(desc_kind, AstNode::kNoId, token_pos);
 }
 
 
 void CodeGenerator::GenerateCallRuntime(intptr_t node_id,
-                                        intptr_t token_index,
+                                        intptr_t token_pos,
                                         const RuntimeEntry& entry) {
   __ CallRuntime(entry);
-  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_pos);
 }
 
 
 void CodeGenerator::MarkDeoptPoint(intptr_t node_id,
-                                   intptr_t token_index) {
+                                   intptr_t token_pos) {
   ASSERT(node_id != AstNode::kNoId);
-  AddCurrentDescriptor(PcDescriptors::kDeopt, node_id, token_index);
+  AddCurrentDescriptor(PcDescriptors::kDeopt, node_id, token_pos);
 }
 
 
 // Uses current pc position and try-index.
 void CodeGenerator::AddCurrentDescriptor(PcDescriptors::Kind kind,
                                          intptr_t node_id,
-                                         intptr_t token_index) {
+                                         intptr_t token_pos) {
   pc_descriptors_list_->AddDescriptor(kind,
                                       assembler_->CodeSize(),
                                       node_id,
-                                      token_index,
+                                      token_pos,
                                       state()->try_index());
 }
 
 
-void CodeGenerator::ErrorMsg(intptr_t token_index, const char* format, ...) {
+void CodeGenerator::ErrorMsg(intptr_t token_pos, const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Class& cls = Class::Handle(parsed_function_.function().owner());
   const Script& script = Script::Handle(cls.script());
   const Error& error = Error::Handle(
-      Parser::FormatError(script, token_index, "Error", format, args));
+      Parser::FormatError(script, token_pos, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32