Replace intptr_t with TokenDescriptor

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
 #include "vm/cpu.h"
@@ skipping 1110 matching lines @@
                                       insert_before->token_pos()),
                  deopt_environment,
                  FlowGraph::kEffect);
   }
 }
 
 
 Instruction* FlowGraphOptimizer::GetCheckClass(Definition* to_check,
                                                const ICData& unary_checks,
                                                intptr_t deopt_id,
-                                               intptr_t token_pos) {
+                                               TokenPosition token_pos) {
   if ((unary_checks.NumberOfUsedChecks() == 1) &&
       unary_checks.HasReceiverClassId(kSmiCid)) {
     return new(Z) CheckSmiInstr(new(Z) Value(to_check),
                                 deopt_id,
                                 token_pos);
   }
   return new(Z) CheckClassInstr(
       new(Z) Value(to_check), deopt_id, unary_checks, token_pos);
 }
 
@@ skipping 133 matching lines @@
   }
   return TryReplaceInstanceCallWithInline(call);
 }
 
 
 bool FlowGraphOptimizer::InlineSetIndexed(
     MethodRecognizer::Kind kind,
     const Function& target,
     Instruction* call,
     Definition* receiver,
-    intptr_t token_pos,
+    TokenPosition token_pos,
     const ICData& value_check,
     TargetEntryInstr** entry,
     Definition** last) {
   intptr_t array_cid = MethodKindToCid(kind);
   ASSERT(array_cid != kIllegalCid);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
 
@@ skipping 150 matching lines @@
                          call->env(),
                          FlowGraph::kEffect);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target,
                                                    Instruction* call,
                                                    Definition* receiver,
-                                                   intptr_t token_pos,
+                                                   TokenPosition token_pos,
                                                    const ICData& ic_data,
                                                    TargetEntryInstr** entry,
                                                    Definition** last) {
   ICData& value_check = ICData::ZoneHandle(Z);
   MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(target);
   switch (kind) {
     // Recognized [] operators.
     case MethodRecognizer::kImmutableArrayGetIndexed:
     case MethodRecognizer::kObjectArrayGetIndexed:
     case MethodRecognizer::kGrowableArrayGetIndexed:
@@ skipping 7379 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
 
 }  // namespace dart