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

vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
@@ skipping 911 matching lines @@
 
 
 void StoreInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyValues(instance(), value()));
   Register instance_reg = locs()->in(0).reg();
   Register value_reg = locs()->in(1).reg();
 
   if (HasICData()) {
     ASSERT(original() != NULL);
     Label* deopt = compiler->AddDeoptStub(original()->cid(),
-                                          original()->token_index(),
+                                          original()->token_pos(),
                                           original()->try_index(),
                                           kDeoptInstanceGetterSameTarget,
                                           instance_reg,
                                           value_reg);
     // Smis do not have instance fields (Smi class is always first).
     Register temp_reg = locs()->temp(0).reg();
     ASSERT(temp_reg != instance_reg);
     ASSERT(temp_reg != value_reg);
     ASSERT(ic_data() != NULL);
     compiler->EmitClassChecksNoSmi(*ic_data(), instance_reg, temp_reg, deopt);
   }
   __ StoreIntoObject(instance_reg, FieldAddress(instance_reg, field().Offset()),
                      value_reg);
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary() const {
   const int kNumInputs = 0;
   const int kNumTemps = 0;
   return new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
 }
 
 
 
 void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(exception()->IsUse());
   compiler->GenerateCallRuntime(cid(),
-                                token_index(),
+                                token_pos(),
                                 try_index(),
                                 kThrowRuntimeEntry);
   __ int3();
 }
 
 
 LocationSummary* ReThrowInstr::MakeLocationSummary() const {
   const int kNumInputs = 0;
   const int kNumTemps = 0;
   return new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
 }
 
 
 void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(exception()->IsUse());
   ASSERT(stack_trace()->IsUse());
   compiler->GenerateCallRuntime(cid(),
-                                token_index(),
+                                token_pos(),
                                 try_index(),
                                 kReThrowRuntimeEntry);
   __ int3();
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary() const {
   if (is_fused_with_comparison()) {
     return LocationSummary::Make(0,
                                  Location::NoLocation(),
@@ skipping 122 matching lines @@
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count - 1,
                                          argument_names());
   __ LoadObject(temp_reg, arguments_descriptor);
 
-  compiler->GenerateCall(token_index(),
+  compiler->GenerateCall(token_pos(),
                          try_index(),
                          &StubCode::CallClosureFunctionLabel(),
                          PcDescriptors::kOther);
   __ Drop(argument_count);
 }
 
 
 LocationSummary* InstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void InstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyCallComputation(this));
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  cid(),
-                                 token_index(),
+                                 token_pos(),
                                  try_index());
   compiler->GenerateInstanceCall(cid(),
-                                 token_index(),
+                                 token_pos(),
                                  try_index(),
                                  function_name(),
                                  ArgumentCount(),
                                  argument_names(),
                                  checked_argument_count());
 }
 
 
 bool InstanceCallComp::VerifyComputation() {
   return VerifyCallComputation(this);
 }
 
 
 LocationSummary* StaticCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void StaticCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyCallComputation(this));
   Label done;
   if (recognized() == MethodRecognizer::kMathSqrt) {
     compiler->GenerateInlinedMathSqrt(&done);
     // Falls through to static call when operand type is not double or smi.
   }
   compiler->GenerateStaticCall(cid(),
-                               token_index(),
+                               token_pos(),
                                try_index(),
                                function(),
                                ArgumentCount(),
                                argument_names());
   __ Bind(&done);
 }
 
 
 LocationSummary* UseVal::MakeLocationSummary() const {
   return NULL;
 }
 
 
 void UseVal::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 void AssertAssignableComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateAssertAssignable(cid(),
-                                     token_index(),
+                                     token_pos(),
                                      try_index(),
                                      dst_type(),
                                      dst_name());
   ASSERT(locs()->in(0).reg() == locs()->out().reg());
 }
 
 
 LocationSummary* AssertBooleanComp::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::SameAsFirstInput(),
@@ skipping 72 matching lines @@
 
 LocationSummary* AllocateObjectComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
-  compiler->GenerateCall(token_index(),
+  compiler->GenerateCall(token_pos(),
                          try_index(),
                          &label,
                          PcDescriptors::kOther);
   __ Drop(arguments().length());  // Discard arguments.
 }
 
 
 LocationSummary* CreateClosureComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void CreateClosureComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Function& closure_function = function();
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
-  compiler->GenerateCall(token_index(), try_index(), &label,
+  compiler->GenerateCall(token_pos(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
 #undef __
 
 }  // namespace dart