Replace intptr_t with TokenDescriptor

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 31 matching lines @@
 
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, profile_vm);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 DECLARE_FLAG(bool, use_field_guards);
 
 // Quick access to the locally defined zone() method.
 #define Z (zone())
 
 // Quick synthetic token position.
-#define ST(token_pos) Token::ToSynthetic(token_pos)
+#define ST(token_pos) ((token_pos).ToSynthetic())
 
 // TODO(srdjan): Allow compiler to add constants as they are encountered in
 // the compilation.
 const double kCommonDoubleConstants[] =
     {-1.0, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 2.0, 4.0, 5.0,
      10.0, 20.0, 30.0, 64.0, 255.0, NAN,
      // From dart:math
      2.718281828459045, 2.302585092994046, 0.6931471805599453,
      1.4426950408889634, 0.4342944819032518, 3.1415926535897932,
      0.7071067811865476, 1.4142135623730951};
@@ skipping 490 matching lines @@
     TargetEntryInstr* false_block =
         new(Z) TargetEntryInstr(caller_graph_->allocate_block_id(),
                                 call_block->try_index());
     false_block->InheritDeoptTargetAfter(caller_graph_, call_, NULL);
     false_block->LinkTo(call_->next());
     call_block->ReplaceAsPredecessorWith(false_block);
 
     ConstantInstr* true_const = caller_graph_->GetConstant(Bool::True());
     BranchInstr* branch =
         new(Z) BranchInstr(
-            new(Z) StrictCompareInstr(call_block->start_pos(),
+            new(Z) StrictCompareInstr(TokenPosition::kNoSource,
                                       Token::kEQ_STRICT,
                                       new(Z) Value(true_const),
                                       new(Z) Value(true_const),
                                       false));  // No number check.
     branch->InheritDeoptTarget(zone(), call_);
     *branch->true_successor_address() = callee_entry;
     *branch->false_successor_address() = false_block;
 
     call_->previous()->AppendInstruction(branch);
     call_block->set_last_instruction(branch);
@@ skipping 126 matching lines @@
   owner()->add_args_pushed(-instruction->ArgumentCount());
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     exit()->LinkTo(instruction);
     exit_ = instruction;
   }
 }
 
 
-void EffectGraphVisitor::AddReturnExit(intptr_t token_pos, Value* value) {
+void EffectGraphVisitor::AddReturnExit(TokenPosition token_pos,
+                                       Value* value) {
   ASSERT(is_open());
   ReturnInstr* return_instr = new(Z) ReturnInstr(token_pos, value);
   AddInstruction(return_instr);
   InlineExitCollector* exit_collector = owner()->exit_collector();
   if (exit_collector != NULL) {
     exit_collector->AddExit(return_instr);
   }
   CloseFragment();
 }
 
@@ skipping 53 matching lines @@
     JoinEntryInstr* join =
         new(Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     true_exit->Goto(join);
     false_exit->Goto(join);
     exit_ = join;
   }
 }
 
 
 void EffectGraphVisitor::TieLoop(
-    intptr_t token_pos,
+    TokenPosition token_pos,
     const TestGraphVisitor& test_fragment,
     const EffectGraphVisitor& body_fragment,
     const EffectGraphVisitor& test_preamble_fragment) {
   // We have: a test graph fragment with zero, one, or two available exits;
   // and an effect graph fragment with zero or one available exits.  We want
   // to append the 'while loop' consisting of the test graph fragment as
   // condition and the effect graph fragment as body.
   ASSERT(is_open());
 
   // 1. Connect the body to the test if it is reachable, and if so record
@@ skipping 31 matching lines @@
 PushArgumentInstr* EffectGraphVisitor::PushArgument(Value* value) {
   owner_->add_args_pushed(1);
   PushArgumentInstr* result = new(Z) PushArgumentInstr(value);
   AddInstruction(result);
   return result;
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreTemp(const LocalVariable& local,
                                                Value* value,
-                                               intptr_t token_pos) {
+                                               TokenPosition token_pos) {
   ASSERT(!local.is_captured());
-  ASSERT(!Token::IsClassifying(token_pos));
+  ASSERT(!token_pos.IsClassifying());
   return new(Z) StoreLocalInstr(local, value, ST(token_pos));
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreExprTemp(Value* value,
-                                                   intptr_t token_pos) {
+                                                   TokenPosition token_pos) {
   return BuildStoreTemp(*owner()->parsed_function().expression_temp_var(),
                         value,
                         token_pos);
 }
 
 
-Definition* EffectGraphVisitor::BuildLoadExprTemp(intptr_t token_pos) {
-  ASSERT(!Token::IsClassifying(token_pos));
+Definition* EffectGraphVisitor::BuildLoadExprTemp(TokenPosition token_pos) {
+  ASSERT(!token_pos.IsClassifying());
   return BuildLoadLocal(*owner()->parsed_function().expression_temp_var(),
                         token_pos);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
                                                 Value* value,
-                                                intptr_t token_pos) {
+                                                TokenPosition token_pos) {
   if (local.is_captured()) {
     LocalVariable* tmp_var = EnterTempLocalScope(value, token_pos);
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(BuildCurrentContext(token_pos));
     while (delta-- > 0) {
       context = Bind(new(Z) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(Z, Type::null()),
           token_pos));
     }
     Value* tmp_val = Bind(new(Z) LoadLocalInstr(*tmp_var, token_pos));
     StoreInstanceFieldInstr* store =
         new(Z) StoreInstanceFieldInstr(Context::variable_offset(local.index()),
                                        context,
                                        tmp_val,
                                        kEmitStoreBarrier,
                                        token_pos);
     Do(store);
     return ExitTempLocalScope(tmp_var, token_pos);
   } else {
     return new(Z) StoreLocalInstr(local, value, token_pos);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local,
-                                               intptr_t token_pos) {
+                                               TokenPosition token_pos) {
   if (local.IsConst()) {
     return new(Z) ConstantInstr(*local.ConstValue(), token_pos);
   } else if (local.is_captured()) {
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(BuildCurrentContext(token_pos));
     while (delta-- > 0) {
       context = Bind(new(Z) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(Z, Type::null()),
           token_pos));
     }
     return new(Z) LoadFieldInstr(context,
                                  Context::variable_offset(local.index()),
                                  local.type(),
                                  token_pos);
   } else {
     return new(Z) LoadLocalInstr(local, token_pos);
   }
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildSaveContext(
     const LocalVariable& variable,
-    intptr_t token_pos) {
-  ASSERT(Token::IsSynthetic(token_pos) || Token::IsNoSource(token_pos));
+    TokenPosition token_pos) {
+  ASSERT(token_pos.IsSynthetic() || token_pos.IsNoSource());
   Value* context = Bind(BuildCurrentContext(token_pos));
   Do(BuildStoreLocal(variable, context, token_pos));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildRestoreContext(
     const LocalVariable& variable,
-    intptr_t token_pos) {
+    TokenPosition token_pos) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable, token_pos));
   Do(BuildStoreContext(load_saved_context, token_pos));
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreContext(
-    Value* value, intptr_t token_pos) {
+    Value* value, TokenPosition token_pos) {
   return new(Z) StoreLocalInstr(
       *owner()->parsed_function().current_context_var(), value, token_pos);
 }
 
 
-Definition* EffectGraphVisitor::BuildCurrentContext(intptr_t token_pos) {
+Definition* EffectGraphVisitor::BuildCurrentContext(TokenPosition token_pos) {
   return new(Z) LoadLocalInstr(
       *owner()->parsed_function().current_context_var(),
       token_pos);
 }
 
 
 void TestGraphVisitor::ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const {
   ASSERT(!branches.is_empty());
@@ skipping 177 matching lines @@
   Append(for_value);
   Value* return_value = for_value.value();
 
   // Call to stub that checks whether the debugger is in single
   // step mode. This call must happen before the contexts are
   // unchained so that captured variables can be inspected.
   // No debugger check is done in native functions or for return
   // statements for which there is no associated source position.
   const Function& function = owner()->function();
   if (FLAG_support_debugger &&
-      Token::IsDebugPause(node->token_pos()) && !function.is_native()) {
+      node->token_pos().IsDebugPause() &&
+      !function.is_native()) {
     AddInstruction(new(Z) DebugStepCheckInstr(node->token_pos(),
                                               RawPcDescriptors::kRuntimeCall));
   }
 
   NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
 
   if (node->inlined_finally_list_length() > 0) {
     LocalVariable* temp = owner()->parsed_function().finally_return_temp_var();
     ASSERT(temp != NULL);
     Do(BuildStoreLocal(*temp, return_value, node->token_pos()));
@@ skipping 113 matching lines @@
         node->token_pos(), instantiator_class, NULL);
     ReturnDefinition(new(Z) InstantiateTypeInstr(
         node->token_pos(), type, instantiator_class, instantiator_value));
   }
 }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is dynamic or if the compile type of the value is a subtype
 // of the destination type.
-bool EffectGraphVisitor::CanSkipTypeCheck(intptr_t token_pos,
+bool EffectGraphVisitor::CanSkipTypeCheck(TokenPosition token_pos,
                                           Value* value,
                                           const AbstractType& dst_type,
                                           const String& dst_name) {
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
   // If the destination type is malformed or malbounded, a dynamic type error
   // must be thrown at run time.
   if (dst_type.IsMalformedOrMalbounded()) {
     return false;
@@ skipping 220 matching lines @@
                                                      Token::kILLEGAL,
                                                      arguments,
                                                      Object::null_array(),
                                                      kNumArgsChecked,
                                                      owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckPushArguments(
-    intptr_t token_pos,
+    TokenPosition token_pos,
     PushArgumentInstr** push_instantiator_type_arguments_result) {
   const Class& instantiator_class = Class::Handle(
       Z, owner()->function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.IsGeneric());
   Value* instantiator_type_arguments = NULL;
   Value* instantiator = BuildInstantiator(token_pos);
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(
         token_pos, instantiator_class, instantiator);
   }
   *push_instantiator_type_arguments_result =
       PushArgument(instantiator_type_arguments);
 }
 
 
 
 void EffectGraphVisitor::BuildTypecheckArguments(
-    intptr_t token_pos,
+    TokenPosition token_pos,
     Value** instantiator_type_arguments_result) {
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   const Class& instantiator_class = Class::Handle(
       Z, owner()->function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.IsGeneric());
   instantiator = BuildInstantiator(token_pos);
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(
         token_pos, instantiator_class, instantiator);
   }
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
-Value* EffectGraphVisitor::BuildNullValue(intptr_t token_pos) {
+Value* EffectGraphVisitor::BuildNullValue(TokenPosition token_pos) {
   return Bind(new(Z) ConstantInstr(Object::ZoneHandle(Z, Object::null()),
                                    token_pos));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
-    intptr_t token_pos,
+    TokenPosition token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (dst_type.IsInstantiated()) {
     instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
     BuildTypecheckArguments(token_pos, &instantiator_type_arguments);
   }
 
   const intptr_t deopt_id = Thread::Current()->GetNextDeoptId();
   return new(Z) AssertAssignableInstr(token_pos,
                                       value,
                                       instantiator_type_arguments,
                                       dst_type,
                                       dst_name,
                                       deopt_id);
 }
 
 
 // Used for type casts and to test assignments.
-Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_pos,
+Value* EffectGraphVisitor::BuildAssignableValue(TokenPosition token_pos,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(token_pos, value, dst_type, dst_name)) {
     return value;
   }
   return Bind(BuildAssertAssignable(token_pos, value, dst_type, dst_name));
 }
 
 
@@ skipping 149 matching lines @@
       Library::PrivateCoreLibName(Symbols::_as()),
       node->kind(),
       arguments,
       Object::null_array(),  // No argument names.
       kNumArgsChecked,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
-StrictCompareInstr* EffectGraphVisitor::BuildStrictCompare(AstNode* left,
-                                                           AstNode* right,
-                                                           Token::Kind kind,
-                                                           intptr_t token_pos) {
+StrictCompareInstr* EffectGraphVisitor::BuildStrictCompare(
+    AstNode* left,
+    AstNode* right,
+    Token::Kind kind,
+    TokenPosition token_pos) {
   ValueGraphVisitor for_left_value(owner());
   left->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner());
   right->Visit(&for_right_value);
   Append(for_right_value);
   StrictCompareInstr* comp = new(Z) StrictCompareInstr(token_pos,
                                                        kind,
                                                        for_left_value.value(),
                                                        for_right_value.value(),
@@ skipping 510 matching lines @@
 void EffectGraphVisitor::VisitAwaitNode(AwaitNode* node) {
   // Await nodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
 void EffectGraphVisitor::VisitAwaitMarkerNode(AwaitMarkerNode* node) {
   // We need to create a new await state which involves:
   // * Increase the jump counter. Sanity check against the list of targets.
   // * Save the current context for resuming.
-  ASSERT(Token::IsSynthetic(node->token_pos()) ||
-         Token::IsNoSource(node->token_pos()));
+  ASSERT(node->token_pos().IsSynthetic() || node->token_pos().IsNoSource());
   ASSERT(node->async_scope() != NULL);
   ASSERT(node->await_scope() != NULL);
   LocalVariable* jump_var = node->async_scope()->LookupVariable(
       Symbols::AwaitJumpVar(), false);
   LocalVariable* ctx_var = node->async_scope()->LookupVariable(
       Symbols::AwaitContextVar(), false);
   ASSERT((jump_var != NULL) && jump_var->is_captured());
   ASSERT((ctx_var != NULL) && ctx_var->is_captured());
   const intptr_t jump_count = owner()->next_await_counter();
   ASSERT(jump_count >= 0);
@@ skipping 12 matching lines @@
 intptr_t EffectGraphVisitor::GetCurrentTempLocalIndex() const {
   return kFirstLocalSlotFromFp
       - owner()->num_stack_locals()
       - owner()->num_copied_params()
       - owner()->args_pushed()
       - owner()->temp_count() + 1;
 }
 
 
 LocalVariable* EffectGraphVisitor::EnterTempLocalScope(
-    Value* value, intptr_t token_pos) {
+    Value* value, TokenPosition token_pos) {
   Do(new(Z) PushTempInstr(value));
   owner()->AllocateTemp();
 
   ASSERT(value->definition()->temp_index() == (owner()->temp_count() - 1));
   intptr_t index = GetCurrentTempLocalIndex();
   char name[64];
   OS::SNPrint(name, 64, ":tmp_local%" Pd, index);
   LocalVariable*  var =
-      new(Z) LocalVariable(Token::kNoSourcePos,
+      new(Z) LocalVariable(TokenPosition::kNoSource,
                            String::ZoneHandle(Z, Symbols::New(name)),
                            *value->Type()->ToAbstractType());
   var->set_index(index);
   return var;
 }
 
 
 Definition* EffectGraphVisitor::ExitTempLocalScope(
-    LocalVariable* var, intptr_t token_pos) {
+    LocalVariable* var, TokenPosition token_pos) {
   Value* tmp = Bind(new(Z) LoadLocalInstr(*var, token_pos));
   owner()->DeallocateTemps(1);
   ASSERT(GetCurrentTempLocalIndex() == var->index());
   return new(Z) DropTempsInstr(1, tmp);
 }
 
 
 void EffectGraphVisitor::BuildLetTempExpressions(LetNode* node) {
   intptr_t num_temps = node->num_temps();
   for (intptr_t i = 0; i < num_temps; ++i) {
@@ skipping 267 matching lines @@
     ValueGraphVisitor for_argument(owner());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
   }
 }
 
 
 void EffectGraphVisitor::BuildInstanceCallConditional(InstanceCallNode* node) {
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
   LoadLocalNode* load_temp = new(Z) LoadLocalNode(token_pos, temp_var);
 
   LiteralNode* null_constant =
       new(Z) LiteralNode(ST(token_pos), Object::null_instance());
   ComparisonNode* check_is_null =
       new(Z) ComparisonNode(ST(token_pos),
                             Token::kEQ,
                             load_temp,
                             null_constant);
@@ skipping 271 matching lines @@
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Value* allocated_value = BuildObjectAllocation(node);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
 }
 
 
-Value* EffectGraphVisitor::BuildInstantiator(intptr_t token_pos) {
+Value* EffectGraphVisitor::BuildInstantiator(TokenPosition token_pos) {
   Function& outer_function = Function::Handle(Z, owner()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     return NULL;
   }
 
   LocalVariable* instantiator = owner()->parsed_function().instantiator();
   ASSERT(instantiator != NULL);
   Value* result = Bind(BuildLoadLocal(*instantiator, token_pos));
   return result;
 }
 
 
 // 'expression_temp_var' may not be used inside this method if 'instantiator'
 // is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
-    intptr_t token_pos,
+    TokenPosition token_pos,
     const Class& instantiator_class,
     Value* instantiator) {
   if (!instantiator_class.IsGeneric()) {
     // The type arguments are compile time constants.
     TypeArguments& type_arguments =
         TypeArguments::ZoneHandle(Z, TypeArguments::null());
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(
         Z,
         Type::New(instantiator_class, type_arguments, token_pos, Heap::kNew));
@@ skipping 29 matching lines @@
 
   return Bind(new(Z) LoadFieldInstr(
       instantiator,
       type_arguments_field_offset,
       Type::ZoneHandle(Z, Type::null()),  // Not an instance, no type.
       token_pos));
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
-    intptr_t token_pos,
+    TokenPosition token_pos,
     const TypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new(Z) ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
   const Class& instantiator_class = Class::ZoneHandle(
       Z, owner()->function().Owner());
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   const bool use_instantiator_type_args =
@@ skipping 31 matching lines @@
     PushArgumentInstr* push_allocated_value = PushArgument(allocated_tmp);
     BuildConstructorCall(node, push_allocated_value);
     ReturnDefinition(ExitTempLocalScope(tmp_var, node->token_pos()));
   }
 }
 
 
 
 void EffectGraphVisitor::BuildInstanceGetterConditional(
     InstanceGetterNode* node) {
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
   LoadLocalNode* load_temp = new(Z) LoadLocalNode(token_pos, temp_var);
 
   LiteralNode* null_constant =
       new(Z) LiteralNode(ST(token_pos), Object::null_instance());
   ComparisonNode* check_is_null =
       new(Z) ComparisonNode(ST(token_pos),
                             Token::kEQ,
                             load_temp,
                             null_constant);
@@ skipping 75 matching lines @@
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value(), node->token_pos()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), token_pos));
 
     LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
     LoadLocalNode* load_temp =
         new(Z) LoadLocalNode(ST(token_pos), temp_var);
     LiteralNode* null_constant =
@@ skipping 29 matching lines @@
                                                      Token::kSET,
                                                      arguments,
                                                      Object::null_array(),
                                                      kNumArgsChecked,
                                                      owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), token_pos));
 
     LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
     LoadLocalNode* load_temp =
         new(Z) LoadLocalNode(ST(token_pos), temp_var);
     LiteralNode* null_constant =
@@ skipping 111 matching lines @@
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(1);
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   // A super setter is an instance setter whose setter function is
   // resolved at compile time (in the caller instance getter's super class).
   // Unlike a static getter, a super getter has a receiver parameter.
   const bool is_super_setter = (node->receiver() != NULL);
   const Function& setter_function = node->function();
   StaticCallInstr* call;
   if (setter_function.IsNull()) {
     if (is_super_setter) {
       ASSERT(node->receiver() != NULL);
       // Resolve and call noSuchMethod.
@@ skipping 79 matching lines @@
     case MethodRecognizer::kGrowableArrayLength:
       return GrowableObjectArray::length_offset();
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 
 LoadLocalInstr* EffectGraphVisitor::BuildLoadThisVar(
-    LocalScope* scope, intptr_t token_pos) {
+    LocalScope* scope, TokenPosition token_pos) {
   LocalVariable* receiver_var = scope->LookupVariable(Symbols::This(),
                                                       true);  // Test only.
   return new(Z) LoadLocalInstr(*receiver_var, token_pos);
 }
 
 
 LoadFieldInstr* EffectGraphVisitor::BuildNativeGetter(
     NativeBodyNode* node,
     MethodRecognizer::Kind kind,
     intptr_t offset,
@@ skipping 24 matching lines @@
       value,
       emit_store_barrier,
       node->token_pos());
   Do(store);
   return new(Z) ConstantInstr(Object::ZoneHandle(Z, Object::null()));
 }
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
   const Function& function = owner()->function();
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   if (!function.IsClosureFunction()) {
     MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(function);
     switch (kind) {
       case MethodRecognizer::kObjectEquals: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope(), token_pos));
         LocalVariable* other_var =
             node->scope()->LookupVariable(Symbols::Other(),
                                           true);  // Test only.
         Value* other = Bind(new(Z) LoadLocalInstr(*other_var, token_pos));
         // Receiver is not a number because numbers override equality.
@@ skipping 182 matching lines @@
   // If the right hand side is an expression that does not contain
   // a safe point for the debugger to stop, add an explicit stub
   // call. Exception: don't do this when assigning to or from internal
   // variables, or for generated code that has no source position.
   if (FLAG_support_debugger) {
     if ((node->value()->IsLiteralNode() ||
         (node->value()->IsLoadLocalNode() &&
             !node->value()->AsLoadLocalNode()->local().IsInternal()) ||
         node->value()->IsClosureNode()) &&
         !node->local().IsInternal() &&
-        Token::IsDebugPause(node->token_pos())) {
+        node->token_pos().IsDebugPause()) {
       AddInstruction(new(Z) DebugStepCheckInstr(
           node->token_pos(), RawPcDescriptors::kRuntimeCall));
     }
   }
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (Isolate::Current()->flags().type_checks()) {
@@ skipping 25 matching lines @@
       load->set_result_cid(node->field().guarded_cid());
     }
     FlowGraph::AddToGuardedFields(owner()->guarded_fields(), &node->field());
   }
   ReturnDefinition(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (Isolate::Current()->flags().type_checks()) {
     const AbstractType& type =
         AbstractType::ZoneHandle(Z, node->field().type());
@@ skipping 25 matching lines @@
                                      store_value,
                                      kEmitStoreBarrier,
                                      token_pos);
   // Maybe initializing unboxed store.
   store->set_is_potential_unboxed_initialization(true);
   ReturnDefinition(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   if (node->field().is_const()) {
     ASSERT(node->field().StaticValue() != Object::sentinel().raw());
     ASSERT(node->field().StaticValue() !=
            Object::transition_sentinel().raw());
     Definition* result = new(Z) ConstantInstr(
         Instance::ZoneHandle(Z, node->field().StaticValue()), token_pos);
     return ReturnDefinition(result);
   }
   Value* field_value = Bind(new(Z) ConstantInstr(node->field(), token_pos));
   LoadStaticFieldInstr* load =
       new(Z) LoadStaticFieldInstr(field_value, token_pos);
   ReturnDefinition(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreStaticField(
     StoreStaticFieldNode* node,
     bool result_is_needed,
-    intptr_t token_pos) {
+    TokenPosition token_pos) {
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = NULL;
   if (result_is_needed) {
     store_value = Bind(BuildStoreExprTemp(for_value.value(), token_pos));
   } else {
     store_value = for_value.value();
   }
   StoreStaticFieldInstr* store =
@@ skipping 77 matching lines @@
         owner()->ic_data_array());
     ReturnDefinition(load);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   Function* super_function = NULL;
-  const intptr_t token_pos = node->token_pos();
+  const TokenPosition token_pos = node->token_pos();
   if (node->IsSuperStore()) {
     // Resolve the store indexed operator in the super class.
     super_function = &Function::ZoneHandle(
         Z, Resolver::ResolveDynamicAnyArgs(node->super_class(),
                                            Symbols::AssignIndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new(Z) ArgumentListNode(token_pos);
       arguments->Add(node->array());
@@ skipping 89 matching lines @@
 
 bool EffectGraphVisitor::HasContextScope() const {
   const ContextScope& context_scope = ContextScope::Handle(
       owner()->function().context_scope());
   return !context_scope.IsNull() && (context_scope.num_variables() > 0);
 }
 
 
 void EffectGraphVisitor::UnchainContexts(intptr_t n) {
   // TODO(johnmccutchan): Pass this in.
-  const intptr_t token_pos = ClassifyingTokenPositions::kContext;
+  const TokenPosition token_pos = TokenPosition::kContext;
   if (n > 0) {
     Value* context = Bind(BuildCurrentContext(token_pos));
     while (n-- > 0) {
       context = Bind(
           new(Z) LoadFieldInstr(context,
                                 Context::parent_offset(),
                                 // Not an instance, no type.
                                 Type::ZoneHandle(Z, Type::null()),
                                 token_pos));
     }
@@ skipping 77 matching lines @@
       const int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         const LocalVariable& parameter = *scope->VariableAt(pos);
         ASSERT(parameter.owner() == scope);
         if (parameter.is_captured()) {
           // Create a temporary local describing the original position.
           const String& temp_name = Symbols::TempParam();
           LocalVariable* temp_local = new(Z) LocalVariable(
-              Token::kNoSourcePos,  // Token index.
+              TokenPosition::kNoSource,  // Token index.
               temp_name,
               Object::dynamic_type());  // Type.
           temp_local->set_index(param_frame_index);
 
           // Mark this local as captured parameter so that the optimizer
           // correctly handles these when compiling try-catch: Captured
           // parameters are not in the stack environment, therefore they
           // must be skipped when emitting sync-code in try-blocks.
           temp_local->set_is_captured_parameter(true);
 
@@ skipping 14 matching lines @@
   }
 
   if (FLAG_support_debugger &&
       is_top_level_sequence &&
       function.is_debuggable()) {
     // Place a debug check at method entry to ensure breaking on a method always
     // happens, even if there are no assignments/calls/runtimecalls in the first
     // basic block. Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
     const int num_params = function.NumParameters();
-    intptr_t check_pos = Token::kNoSourcePos;
+    TokenPosition check_pos = TokenPosition::kNoSource;
     if (num_params > 0) {
       const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
       check_pos = parameter.token_pos();
     }
-    if (!Token::IsDebugPause(check_pos)) {
+
+    if (!check_pos.IsDebugPause()) {
       // No parameters or synthetic parameters.
       check_pos = node->token_pos();
-      ASSERT(Token::IsDebugPause(check_pos));
+      ASSERT(check_pos.IsDebugPause());
     }
     AddInstruction(new(Z) DebugStepCheckInstr(check_pos,
                                               RawPcDescriptors::kRuntimeCall));
   }
 
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
   if (is_top_level_sequence && !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
@@ skipping 283 matching lines @@
 
 // Looks up dynamic method noSuchMethod in target_class
 // (including its super class chain) and builds a static call to it.
 StaticCallInstr* EffectGraphVisitor::BuildStaticNoSuchMethodCall(
     const Class& target_class,
     AstNode* receiver,
     const String& method_name,
     ArgumentListNode* method_arguments,
     bool save_last_arg,
     bool is_super_invocation) {
-  intptr_t args_pos = method_arguments->token_pos();
+  TokenPosition args_pos = method_arguments->token_pos();
   LocalVariable* temp = NULL;
   if (save_last_arg) {
     temp = owner()->parsed_function().expression_temp_var();
   }
   ArgumentListNode* args =
       Parser::BuildNoSuchMethodArguments(args_pos,
                                          method_name,
                                          *method_arguments,
                                          temp,
                                          is_super_invocation);
   const Function& no_such_method_func = Function::ZoneHandle(Z,
       Resolver::ResolveDynamicAnyArgs(target_class, Symbols::NoSuchMethod()));
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
   ZoneGrowableArray<PushArgumentInstr*>* push_arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildPushArguments(*args, push_arguments);
   return new(Z) StaticCallInstr(args_pos,
                                 no_such_method_func,
                                 Object::null_array(),
                                 push_arguments,
                                 owner()->ic_data_array());
 }
 
 
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
-    intptr_t token_pos,
+    TokenPosition token_pos,
     const Class& function_class,
     const String& function_name,
     ArgumentListNode* function_arguments,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>();
   // Object receiver, actually a class literal of the unresolved method's owner.
   AbstractType& type = Type::ZoneHandle(
       Z,
       Type::New(function_class,
@@ skipping 196 matching lines @@
                    Script::Handle(function.script()),
                    function.token_pos(),
                    Report::AtLocation,
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart