Replace intptr_t with TokenDescriptor

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 109 matching lines @@
 
 
 static int LowestFirst(const intptr_t* a, const intptr_t* b) {
   return *a - *b;
 }
 
 
 CheckClassInstr::CheckClassInstr(Value* value,
                                  intptr_t deopt_id,
                                  const ICData& unary_checks,
-                                 intptr_t token_pos)
+                                 TokenPosition token_pos)
     : TemplateInstruction(deopt_id),
       unary_checks_(unary_checks),
       cids_(unary_checks.NumberOfChecks()),
       licm_hoisted_(false),
       token_pos_(token_pos) {
   ASSERT(unary_checks.IsZoneHandle());
   // Expected useful check data.
   ASSERT(!unary_checks_.IsNull());
   ASSERT(unary_checks_.NumberOfChecks() > 0);
   ASSERT(unary_checks_.NumArgsTested() == 1);
@@ skipping 272 matching lines @@
 }
 
 
 const Field& LoadStaticFieldInstr::StaticField() const {
   Field& field = Field::Handle();
   field ^= field_value()->BoundConstant().raw();
   return field;
 }
 
 
-ConstantInstr::ConstantInstr(const Object& value, intptr_t token_pos)
+ConstantInstr::ConstantInstr(const Object& value, TokenPosition token_pos)
     : value_(value),
       token_pos_(token_pos) {
   // Check that the value is not an incorrect Integer representation.
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoSmi());
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoInt64());
   ASSERT(!value.IsMint() || !Smi::IsValid(Mint::Cast(value).AsInt64Value()));
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
@@ skipping 2293 matching lines @@
   UNREACHABLE();
   return NULL;
 }
 
 
 void JoinEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
                                    GetDeoptId(),
-                                   Token::kNoSourcePos);
+                                   TokenPosition::kNoSource);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
 LocationSummary* TargetEntryInstr::MakeLocationSummary(Zone* zone,
                                                        bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void TargetEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     if (compiler->NeedsEdgeCounter(this)) {
       compiler->EmitEdgeCounter(preorder_number());
     }
     // The deoptimization descriptor points after the edge counter code for
     // uniformity with ARM and MIPS, where we can reuse pattern matching
     // code that matches backwards from the end of the pattern.
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
                                    GetDeoptId(),
-                                   Token::kNoSourcePos);
+                                   TokenPosition::kNoSource);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
 void IndirectGotoInstr::ComputeOffsetTable() {
   if (GetBlock()->offset() < 0) {
     // Don't generate a table when contained in an unreachable block.
@@ skipping 180 matching lines @@
 
 
 void DropTempsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   // Assert that register assignment is correct.
   ASSERT((InputCount() == 0) || (locs()->out(0).reg() == locs()->in(0).reg()));
   __ Drop(num_temps());
 }
 
 
-StrictCompareInstr::StrictCompareInstr(intptr_t token_pos,
+StrictCompareInstr::StrictCompareInstr(TokenPosition token_pos,
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
                                        bool needs_number_check)
     : ComparisonInstr(token_pos,
                       kind,
                       left,
                       right,
                       Thread::Current()->GetNextDeoptId()),
       needs_number_check_(needs_number_check) {
@@ skipping 537 matching lines @@
   const String& concatenated = String::ZoneHandle(zone,
       Symbols::FromConcatAll(pieces));
   return flow_graph->GetConstant(concatenated);
 }
 
 
 InvokeMathCFunctionInstr::InvokeMathCFunctionInstr(
     ZoneGrowableArray<Value*>* inputs,
     intptr_t deopt_id,
     MethodRecognizer::Kind recognized_kind,
-    intptr_t token_pos)
+    TokenPosition token_pos)
     : PureDefinition(deopt_id),
       inputs_(inputs),
       recognized_kind_(recognized_kind),
       token_pos_(token_pos) {
   ASSERT(inputs_->length() == ArgumentCountFor(recognized_kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
     (*inputs)[i]->set_use_index(i);
   }
@@ skipping 164 matching lines @@
   set_native_c_function(native_function);
   function().SetIsNativeAutoSetupScope(auto_setup_scope);
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
   set_is_bootstrap_native(is_bootstrap_native);
 }
 
 #undef __
 
 }  // namespace dart