Replace intptr_t with TokenDescriptor

runtime/vm/parser.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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 49 matching lines @@
 DECLARE_FLAG(bool, profile_vm);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
 // Quick access to the current thread, isolate and zone.
 #define T (thread())
 #define I (isolate())
 #define Z (zone())
 
 // Quick synthetic token position.
-#define ST(token_pos) Token::ToSynthetic(token_pos)
+#define ST(token_pos) TokenDescriptor::ToSynthetic(token_pos)
 
 #if defined(DEBUG)
 class TraceParser : public ValueObject {
  public:
-  TraceParser(intptr_t token_pos,
+  TraceParser(TokenDescriptor token_pos,
               const Script& script,
               intptr_t* trace_indent,
               const char* msg) {
     indent_ = trace_indent;
     if (FLAG_trace_parser) {
       // Skips tracing of bootstrap libraries.
       if (script.HasSource()) {
         intptr_t line, column;
         script.GetTokenLocation(token_pos, &line, &column);
         PrintIndent();
         OS::Print("%s (line %" Pd ", col %" Pd ", token %" Pd ")\n",
-                  msg, line, column, token_pos);
+                  msg, line, column, token_pos.value());
       }
       (*indent_)++;
     }
   }
   ~TraceParser() {
     if (FLAG_trace_parser) {
       (*indent_)--;
       ASSERT(*indent_ >= 0);
     }
   }
@@ skipping 157 matching lines @@
                                &found_captured_variables);
 
   // Frame indices are relative to the frame pointer and are decreasing.
   ASSERT(next_free_frame_index <= first_stack_local_index_);
   num_stack_locals_ = first_stack_local_index_ - next_free_frame_index;
 }
 
 
 struct CatchParamDesc {
   CatchParamDesc()
-      : token_pos(Token::kNoSourcePos), type(NULL), name(NULL), var(NULL) { }
-  intptr_t token_pos;
+      : token_pos(TokenDescriptor::kNoSource),
+        type(NULL),
+        name(NULL),
+        var(NULL) { }
+  TokenDescriptor token_pos;
   const AbstractType* type;
   const String* name;
   LocalVariable* var;
 };
 
 
 void ParsedFunction::AllocateIrregexpVariables(intptr_t num_stack_locals) {
   ASSERT(function().IsIrregexpFunction());
   ASSERT(function().NumOptionalParameters() == 0);
   const intptr_t num_params = function().num_fixed_parameters();
@@ skipping 65 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TryStack);
 };
 
 
 void Parser::TryStack::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
-Parser::Parser(const Script& script, const Library& library, intptr_t token_pos)
+Parser::Parser(const Script& script,
+               const Library& library,
+               TokenDescriptor token_pos)
     : isolate_(Thread::Current()->isolate()),
       thread_(Thread::Current()),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(TokenStream::Handle(zone(), script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       await_is_keyword_(false),
       current_member_(NULL),
@@ skipping 10 matching lines @@
       trace_indent_(0),
       recursion_counter_(0) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
-               intptr_t token_position)
+               TokenDescriptor token_pos)
     : isolate_(Thread::Current()->isolate()),
       thread_(Thread::Current()),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(TokenStream::Handle(zone(), script.tokens()),
-                       token_position),
+                       token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(parsed_function),
       innermost_function_(Function::Handle(zone(),
                                            parsed_function->function().raw())),
       literal_token_(LiteralToken::Handle(zone())),
@@ skipping 29 matching lines @@
 // Each try in this function gets its own try index.
 // See definition of RawPcDescriptors::PcDescriptor.
 int16_t Parser::AllocateTryIndex() {
   if (!Utils::IsInt(16, last_used_try_index_ - 1)) {
     ReportError("too many nested try statements");
   }
   return last_used_try_index_++;
 }
 
 
-void Parser::SetScript(const Script& script, intptr_t token_pos) {
+void Parser::SetScript(const Script& script, TokenDescriptor token_pos) {
   script_ = script.raw();
   tokens_iterator_.SetStream(
       TokenStream::Handle(Z, script.tokens()), token_pos);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
@@ skipping 18 matching lines @@
 
 
 void Parser::set_current_class(const Class& value) {
   current_class_ = value.raw();
 }
 
 
 void Parser::SetPosition(intptr_t position) {
   tokens_iterator_.SetCurrentPosition(position);
   token_kind_ = Token::kILLEGAL;
+  prev_token_pos_ = TokenDescriptor(position);
+}
+
+
+void Parser::SetPosition(TokenDescriptor position) {
+  tokens_iterator_.SetCurrentPosition(position.value());
+  token_kind_ = Token::kILLEGAL;
   prev_token_pos_ = position;
 }
 
 
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
   Thread* thread = Thread::Current();
   ASSERT(thread->long_jump_base()->IsSafeToJump());
   CSTAT_TIMER_SCOPE(thread, parser_timer);
   VMTagScope tagScope(thread, VMTag::kCompileTopLevelTagId);
   TimelineDurationScope tds(thread,
                             thread->isolate()->GetCompilerStream(),
                             "CompileTopLevel");
   if (tds.enabled()) {
     tds.SetNumArguments(1);
     tds.CopyArgument(0, "script", String::Handle(script.url()).ToCString());
   }
 
-  Parser parser(script, library, 0);
+  Parser parser(script, library, TokenDescriptor::kMinSource);
   parser.ParseTopLevel();
 }
 
 
 void Parser::ComputeCurrentToken() {
   ASSERT(token_kind_ == Token::kILLEGAL);
   token_kind_ = tokens_iterator_.CurrentTokenKind();
   if (token_kind_ == Token::kERROR) {
     ReportError(TokenPos(), "%s", CurrentLiteral()->ToCString());
   }
@@ skipping 31 matching lines @@
                   i.ToCString());
     }
   }
   return ri;
 }
 
 
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
-        name_pos(Token::kNoSourcePos),
+        name_pos(TokenDescriptor::kNoSource),
         name(NULL),
         default_value(NULL),
         metadata(NULL),
         var(NULL),
         is_final(false),
         is_field_initializer(false),
         has_explicit_type(false) { }
   const AbstractType* type;
-  intptr_t name_pos;
+  TokenDescriptor name_pos;
   const String* name;
   const Instance* default_value;  // NULL if not an optional parameter.
   const Object* metadata;  // NULL if no metadata or metadata not evaluated.
   LocalVariable* var;  // Scope variable allocated for this parameter.
   bool is_final;
   bool is_field_initializer;
   bool has_explicit_type;
 };
 
 
 struct ParamList {
   ParamList() {
     Clear();
   }
 
   void Clear() {
     num_fixed_parameters = 0;
     num_optional_parameters = 0;
     has_optional_positional_parameters = false;
     has_optional_named_parameters = false;
     has_explicit_default_values = false;
     has_field_initializer = false;
     implicitly_final = false;
     skipped = false;
     this->parameters = new ZoneGrowableArray<ParamDesc>();
   }
 
-  void AddFinalParameter(intptr_t name_pos,
+  void AddFinalParameter(TokenDescriptor name_pos,
                          const String* name,
                          const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
     param.name_pos = name_pos;
     param.name = name;
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
-  void AddReceiver(const AbstractType* receiver_type, intptr_t token_pos) {
+  void AddReceiver(const AbstractType* receiver_type,
+                   TokenDescriptor token_pos) {
     ASSERT(this->parameters->is_empty());
     AddFinalParameter(token_pos, &Symbols::This(), receiver_type);
   }
 
   void EraseParameterTypes() {
     const int num_parameters = parameters->length();
     for (int i = 0; i < num_parameters; i++) {
       (*parameters)[i].type = &Object::dynamic_type();
     }
   }
@@ skipping 35 matching lines @@
   void Clear() {
     has_abstract = false;
     has_external = false;
     has_final = false;
     has_const = false;
     has_static = false;
     has_var = false;
     has_factory = false;
     has_operator = false;
     has_native = false;
-    metadata_pos = Token::kNoSourcePos;
+    metadata_pos = TokenDescriptor::kNoSource;
     operator_token = Token::kILLEGAL;
     type = NULL;
-    name_pos = Token::kNoSourcePos;
+    name_pos = TokenDescriptor::kNoSource;
     name = NULL;
     redirect_name = NULL;
     dict_name = NULL;
     params.Clear();
     kind = RawFunction::kRegularFunction;
     field_ = NULL;
   }
 
   bool IsConstructor() const {
     return (kind == RawFunction::kConstructor) && !has_static;
@@ skipping 29 matching lines @@
   }
   bool has_abstract;
   bool has_external;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
   bool has_operator;
   bool has_native;
-  intptr_t metadata_pos;
+  TokenDescriptor metadata_pos;
   Token::Kind operator_token;
   const AbstractType* type;
-  intptr_t name_pos;
-  intptr_t decl_begin_pos;
+  TokenDescriptor name_pos;
+  TokenDescriptor decl_begin_pos;
   String* name;
   // For constructors: NULL or name of redirected to constructor.
   String* redirect_name;
   // dict_name is the name used for the class namespace, if it
   // differs from 'name'.
   // For constructors: NULL for unnamed constructor,
   // identifier after classname for named constructors.
   // For getters and setters: unmangled name.
   String* dict_name;
   ParamList params;
   RawFunction::Kind kind;
   // NULL for functions, field object for static or instance fields.
   Field* field_;
 };
 
 
 class ClassDesc : public ValueObject {
  public:
   ClassDesc(Zone* zone,
             const Class& cls,
             const String& cls_name,
             bool is_interface,
-            intptr_t token_pos)
+            TokenDescriptor token_pos)
       : zone_(zone),
         clazz_(cls),
         class_name_(cls_name),
         token_pos_(token_pos),
         functions_(zone, 4),
         fields_(zone, 4) {
   }
 
   void AddFunction(const Function& function) {
     functions_.Add(&Function::ZoneHandle(zone_, function.raw()));
@@ skipping 22 matching lines @@
   bool has_constructor() const {
     for (int i = 0; i < functions_.length(); i++) {
       const Function* func = functions_.At(i);
       if (func->kind() == RawFunction::kConstructor) {
         return true;
       }
     }
     return false;
   }
 
-  intptr_t token_pos() const {
+  TokenDescriptor token_pos() const {
     return token_pos_;
   }
 
   void AddMember(const MemberDesc& member) {
     members_.Add(member);
   }
 
   const GrowableArray<MemberDesc>& members() const {
     return members_;
   }
@@ skipping 13 matching lines @@
     for (intptr_t i = 0; i < len; i++) {
       res.SetAt(i, *functions_[i]);
     }
     return res.raw();
   }
 
  private:
   Zone* zone_;
   const Class& clazz_;
   const String& class_name_;
-  intptr_t token_pos_;   // Token index of "class" keyword.
+  TokenDescriptor token_pos_;   // Token index of "class" keyword.
   GrowableArray<const Function*> functions_;
   GrowableArray<const Field*> fields_;
   GrowableArray<MemberDesc> members_;
 };
 
 
 class TopLevel : public ValueObject {
  public:
   explicit TopLevel(Zone* zone) :
       zone_(zone),
@@ skipping 241 matching lines @@
 
 
 RawObject* Parser::ParseMetadata(const Field& meta_data) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     const Class& owner_class = Class::Handle(zone, meta_data.owner());
     const Script& script = Script::Handle(zone, meta_data.script());
-    const intptr_t token_pos = meta_data.token_pos();
+    const TokenDescriptor token_pos = meta_data.token_pos();
     // Parsing metadata can involve following paths in the parser that are
     // normally used for expressions and assume current_function is non-null,
     // so we create a fake function to use as the current_function rather than
     // scattering special cases throughout the parser.
     const Function& fake_function = Function::ZoneHandle(zone, Function::New(
         Symbols::At(),
         RawFunction::kRegularFunction,
         true,  // is_static
         false,  // is_const
         false,  // is_abstract
@@ skipping 24 matching lines @@
   return Object::null();
 }
 
 
 RawArray* Parser::EvaluateMetadata() {
   CheckToken(Token::kAT, "Metadata character '@' expected");
   GrowableObjectArray& meta_values =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
-    intptr_t expr_pos = TokenPos();
+    TokenDescriptor expr_pos = TokenPos();
     if (!IsIdentifier()) {
       ExpectIdentifier("identifier expected");
     }
     // Reject expressions with deferred library prefix eagerly.
     Object& obj =
         Object::Handle(Z, library_.LookupLocalObject(*CurrentLiteral()));
     if (!obj.IsNull() && obj.IsLibraryPrefix()) {
       if (LibraryPrefix::Cast(obj).is_deferred_load()) {
         ReportError("Metadata must be compile-time constant");
       }
@@ skipping 23 matching lines @@
         }
       }
       if (CurrentToken() == Token::kPERIOD) {
         // C.x or L.C.X.
         if (cls.IsNull()) {
           ReportError(expr_pos,
                       "Metadata expressions must refer to a const field "
                       "or constructor");
         }
         ConsumeToken();
-        const intptr_t ident_pos = TokenPos();
+        const TokenDescriptor ident_pos = TokenPos();
         String* ident = ExpectIdentifier("identifier expected");
         const Field& field = Field::Handle(Z, cls.LookupStaticField(*ident));
         if (field.IsNull()) {
           ReportError(ident_pos,
                       "Class '%s' has no field '%s'",
                       cls.ToCString(),
                       ident->ToCString());
         }
         if (!field.is_const()) {
           ReportError(ident_pos,
@@ skipping 12 matching lines @@
   }
   return Array::MakeArray(meta_values);
 }
 
 
 SequenceNode* Parser::ParseStaticInitializer() {
   ExpectIdentifier("field name expected");
   CheckToken(Token::kASSIGN, "field initialier expected");
   ConsumeToken();
   OpenFunctionBlock(parsed_function()->function());
-  intptr_t expr_pos = TokenPos();
+  TokenDescriptor expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
   ReturnNode* ret = new(Z) ReturnNode(expr_pos, expr);
   current_block_->statements->Add(ret);
   return CloseBlock();
 }
 
 
 ParsedFunction* Parser::ParseStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   Thread* thread = Thread::Current();
@@ skipping 53 matching lines @@
   TRACE_PARSER("ParseStaticFinalGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
-  intptr_t ident_pos = TokenPos();
+  TokenDescriptor ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(Z, func.Owner());
   const Field& field =
       Field::ZoneHandle(Z, field_class.LookupStaticField(field_name));
   ASSERT(!field.IsNull());
 
   // Static final fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
-  const intptr_t expr_pos = TokenPos();
+  const TokenDescriptor expr_pos = TokenPos();
   if (field.is_const()) {
     // We don't want to use ParseConstExpr() here because we don't want
     // the constant folding code to create, compile and execute a code
     // fragment to evaluate the expression. Instead, we just make sure
     // the static const field initializer is a constant expression and
     // leave the evaluation to the getter function.
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     // This getter will only be called once at compile time.
     if (expr->EvalConstExpr() == NULL) {
       ReportError(expr_pos, "initializer is not a valid compile-time constant");
@@ skipping 17 matching lines @@
 
 
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
   // func.token_pos() points to the name of the field.
-  const intptr_t ident_pos = func.token_pos();
+  const TokenDescriptor ident_pos = func.token_pos();
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
@@ skipping 18 matching lines @@
 
 
 // Create AstNodes for an implicit instance setter method:
 //   LoadLocalNode 0 ('this')
 //   LoadLocalNode 1 ('value')
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
 SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
   TRACE_PARSER("ParseInstanceSetter");
   // func.token_pos() points to the name of the field.
-  const intptr_t ident_pos = func.token_pos();
+  const TokenDescriptor ident_pos = func.token_pos();
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::ZoneHandle(Z, func.Owner());
   const Field& field =
       Field::ZoneHandle(Z, field_class.LookupInstanceField(field_name));
   const AbstractType& field_type = AbstractType::ZoneHandle(Z, field.type());
 
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   params.AddFinalParameter(ident_pos,
@@ skipping 16 matching lines @@
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(ident_pos, receiver, field, value);
   current_block_->statements->Add(store_field);
   current_block_->statements->Add(new ReturnNode(ST(ident_pos)));
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseConstructorClosure(const Function& func) {
   TRACE_PARSER("ParseConstructorClosure");
-  const intptr_t token_pos = func.token_pos();
+  const TokenDescriptor token_pos = func.token_pos();
 
   Function& constructor = Function::ZoneHandle(Z);
   TypeArguments& type_args = TypeArguments::ZoneHandle(Z);
   ParseConstructorClosurization(&constructor, &type_args);
   ASSERT(!constructor.IsNull());
 
   ParamList params;
   // The first parameter of the closure function is the
   // implicit closure argument.
   params.AddFinalParameter(token_pos,
@@ skipping 33 matching lines @@
   AstNode* new_object =
       CreateConstructorCallNode(token_pos, type_args, constructor, ctor_args);
   ReturnNode* return_node = new ReturnNode(token_pos, new_object);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseImplicitClosure(const Function& func) {
   TRACE_PARSER("ParseImplicitClosure");
-  intptr_t token_pos = func.token_pos();
+  TokenDescriptor token_pos = func.token_pos();
 
   OpenFunctionBlock(func);
 
   ParamList params;
   params.AddFinalParameter(
       token_pos,
       &Symbols::ClosureParameter(),
       &Object::dynamic_type());
 
   const Function& parent = Function::ZoneHandle(func.parent_function());
   if (parent.IsImplicitSetterFunction()) {
-    const intptr_t ident_pos = func.token_pos();
+    const TokenDescriptor ident_pos = func.token_pos();
     ASSERT(IsIdentifier());
     const String& field_name = *CurrentLiteral();
     const Class& field_class = Class::ZoneHandle(Z, parent.Owner());
     const Field& field =
         Field::ZoneHandle(Z, field_class.LookupInstanceField(field_name));
     const AbstractType& field_type = AbstractType::ZoneHandle(Z, field.type());
     params.AddFinalParameter(ident_pos,
                              &Symbols::Value(),
                              &field_type);
     ASSERT(func.num_fixed_parameters() == 2);  // closure, value.
@@ skipping 33 matching lines @@
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
 
   ParamList params;
 
-  const intptr_t ident_pos = func.token_pos();
-  ASSERT(func.token_pos() == ClassifyingTokenPositions::kMethodExtractor);
+  const TokenDescriptor ident_pos = func.token_pos();
+  ASSERT(func.token_pos() == TokenDescriptor::kMethodExtractor);
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
 
   ClosureNode* closure = new ClosureNode(
       ident_pos,
       Function::ZoneHandle(Z, func.extracted_method_closure()),
       load_receiver,
       NULL);
 
   ReturnNode* return_node = new ReturnNode(ident_pos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc) {
   ParamList params;
   // Receiver first.
-  intptr_t token_pos = func.token_pos();
+  TokenDescriptor token_pos = func.token_pos();
   params.AddReceiver(ReceiverType(current_class()), token_pos);
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
     ParamDesc p;
     char name[64];
     OS::SNPrint(name, 64, ":p%" Pd, i);
     p.name = &String::ZoneHandle(Z, Symbols::New(name));
     p.type = &Object::dynamic_type();
     params.parameters->Add(p);
@@ skipping 19 matching lines @@
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 }
 
 
 SequenceNode* Parser::ParseNoSuchMethodDispatcher(const Function& func) {
   TRACE_PARSER("ParseNoSuchMethodDispatcher");
   ASSERT(FLAG_lazy_dispatchers);
   ASSERT(func.IsNoSuchMethodDispatcher());
-  intptr_t token_pos = func.token_pos();
-  ASSERT(func.token_pos() == 0);
+  TokenDescriptor token_pos = func.token_pos();
+  ASSERT(func.token_pos() == TokenDescriptor::kMinSource);
   ASSERT(current_class().raw() == func.Owner());
 
   ArgumentsDescriptor desc(Array::Handle(Z, func.saved_args_desc()));
   ASSERT(desc.Count() > 0);
 
   // Set up scope for this function.
   BuildDispatcherScope(func, desc);
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
@@ skipping 33 matching lines @@
 
   ReturnNode* return_node = new ReturnNode(token_pos, call);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseInvokeFieldDispatcher(const Function& func) {
   TRACE_PARSER("ParseInvokeFieldDispatcher");
   ASSERT(func.IsInvokeFieldDispatcher());
-  intptr_t token_pos = func.token_pos();
-  ASSERT(func.token_pos() == 0);
+  TokenDescriptor token_pos = func.token_pos();
+  ASSERT(func.token_pos() == TokenDescriptor::kMinSource);
   ASSERT(current_class().raw() == func.Owner());
 
   const Array& args_desc = Array::Handle(Z, func.saved_args_desc());
   ArgumentsDescriptor desc(args_desc);
   ASSERT(desc.Count() > 0);
 
   // Set up scope for this function.
   BuildDispatcherScope(func, desc);
 
   // Receiver is local 0.
@@ skipping 40 matching lines @@
   } else {
     result = BuildClosureCall(token_pos, function_object, args);
   }
 
   ReturnNode* return_node = new ReturnNode(token_pos, result);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
-AstNode* Parser::BuildClosureCall(intptr_t token_pos,
+AstNode* Parser::BuildClosureCall(TokenDescriptor token_pos,
                                   AstNode* closure,
                                   ArgumentListNode* arguments) {
   return new InstanceCallNode(token_pos,
                               closure,
                               Symbols::Call(),
                               arguments);
 }
 
 
 void Parser::SkipToMatching() {
   Token::Kind opening_token = CurrentToken();
   ASSERT((opening_token == Token::kLBRACE) ||
          (opening_token == Token::kLPAREN));
   GrowableArray<Token::Kind> token_stack(8);
-  GrowableArray<intptr_t> token_pos_stack(8);
+  GrowableArray<TokenDescriptor> token_pos_stack(8);
   // Adding the first opening brace here, because it will be consumed
   // in the loop right away.
   token_stack.Add(opening_token);
-  const intptr_t start_pos =  TokenPos();
-  intptr_t opening_pos = start_pos;
+  const TokenDescriptor start_pos =  TokenPos();
+  TokenDescriptor opening_pos = start_pos;
   token_pos_stack.Add(start_pos);
   bool is_match = true;
   bool unexpected_token_found = false;
   Token::Kind token = opening_token;
-  intptr_t token_pos;
+  TokenDescriptor token_pos;
   do {
     ConsumeToken();
     token = CurrentToken();
     token_pos = TokenPos();
     switch (token) {
       case Token::kLBRACE:
       case Token::kLPAREN:
       case Token::kLBRACK:
         token_stack.Add(token);
         token_pos_stack.Add(token_pos);
@@ skipping 170 matching lines @@
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, false, &func_params);
 
       // In top-level and mixin functions, the source may be in a different
       // script than the script of the current class. However, we never reparse
       // signature functions (except typedef signature functions), therefore
       // we do not need to keep the correct script via a patch class. Use the
       // actual current class as owner of the signature function.
       const Function& signature_function = Function::Handle(Z,
           Function::NewSignatureFunction(current_class(),
-                                         Token::kNoSourcePos));
+                                         TokenDescriptor::kNoSource));
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
       FunctionType& signature_type =
           FunctionType::ZoneHandle(Z, signature_function.SignatureType());
       if (!is_top_level_) {
         signature_type ^= ClassFinalizer::FinalizeType(
             current_class(), signature_type, ClassFinalizer::kCanonicalize);
         signature_function.SetSignatureType(signature_type);
       }
       ASSERT(is_top_level_ || signature_type.IsFinalized());
@@ skipping 120 matching lines @@
   String& native_name = *CurrentLiteral();
   ConsumeToken();
   return native_name;
 }
 
 
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, and resolve_getter is true, try to resolve a getter of
 // the same name. If it is still not found, return noSuchMethod and
 // set is_no_such_method to true..
-RawFunction* Parser::GetSuperFunction(intptr_t token_pos,
+RawFunction* Parser::GetSuperFunction(TokenDescriptor token_pos,
                                       const String& name,
                                       ArgumentListNode* arguments,
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(Z, current_class().SuperClass());
   if (super_class.IsNull()) {
     ReportError(token_pos, "class '%s' does not have a superclass",
                 String::Handle(Z, current_class().Name()).ToCString());
   }
   Function& super_func = Function::Handle(Z,
@@ skipping 15 matching lines @@
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   return super_func.raw();
 }
 
 
 StaticCallNode* Parser::BuildInvocationMirrorAllocation(
-    intptr_t call_pos,
+    TokenDescriptor call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
-  const intptr_t args_pos = function_args.token_pos();
+  const TokenDescriptor args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original function name.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The second argument is the arguments descriptor of the original function.
   const Array& args_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(function_args.length(),
                                                  function_args.names()));
   arguments->Add(new LiteralNode(args_pos, args_descriptor));
@@ skipping 23 matching lines @@
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
       mirror_class.LookupStaticFunction(
           Library::PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
   ASSERT(!allocation_function.IsNull());
   return new StaticCallNode(call_pos, allocation_function, arguments);
 }
 
 
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
-    intptr_t call_pos,
+    TokenDescriptor call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
-  const intptr_t args_pos = function_args.token_pos();
+  const TokenDescriptor args_pos = function_args.token_pos();
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
   // The second argument is the invocation mirror.
   arguments->Add(BuildInvocationMirrorAllocation(call_pos,
                                                  function_name,
                                                  function_args,
                                                  temp_for_last_arg,
                                                  is_super_invocation));
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
-  const intptr_t supercall_pos = TokenPos();
+  const TokenDescriptor supercall_pos = TokenPos();
 
   // 'this' parameter is the first argument to super call.
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   AstNode* receiver = LoadReceiver(supercall_pos);
   arguments->Add(receiver);
   ParseActualParameters(arguments, kAllowConst);
 
   const bool kResolveGetter = true;
   bool is_no_such_method = false;
   const Function& super_function = Function::ZoneHandle(Z,
@@ skipping 27 matching lines @@
 
 // Simple test if a node is side effect free.
 static bool IsSimpleLocalOrLiteralNode(AstNode* node) {
   return node->IsLiteralNode() || node->IsLoadLocalNode();
 }
 
 
 AstNode* Parser::BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super) {
   ASSERT(super->IsSuper());
   AstNode* super_op = NULL;
-  const intptr_t super_pos = super->token_pos();
+  const TokenDescriptor super_pos = super->token_pos();
   if ((op == Token::kNEGATE) ||
       (op == Token::kBIT_NOT)) {
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
         String::ZoneHandle(Z, Symbols::New(Token::Str(op)));
     ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
     AstNode* receiver = LoadReceiver(super_pos);
     op_arguments->Add(receiver);
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
@@ skipping 11 matching lines @@
   } else {
     ReportError(super_pos, "illegal super operator call");
   }
   return super_op;
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
-  const intptr_t operator_pos = TokenPos();
+  const TokenDescriptor operator_pos = TokenPos();
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
     AstNode* index_expr = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectToken(Token::kRBRACK);
     AstNode* receiver = LoadReceiver(operator_pos);
     const Class& super_class =
         Class::ZoneHandle(Z, current_class().SuperClass());
     ASSERT(!super_class.IsNull());
     super_op =
@@ skipping 36 matching lines @@
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
 }
 
 
 ClosureNode* Parser::CreateImplicitClosureNode(const Function& func,
-                                               intptr_t token_pos,
+                                               TokenDescriptor token_pos,
                                                AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(Z, func.ImplicitClosureFunction());
   if (receiver != NULL) {
     // If we create an implicit instance closure from inside a closure of a
     // parameterized class, make sure that the receiver is captured as
     // instantiator.
     if (current_block_->scope->function_level() > 0) {
       const FunctionType& signature_type = FunctionType::Handle(Z,
           implicit_closure_function.SignatureType());
       const Class& scope_class = Class::Handle(Z, signature_type.type_class());
       if (scope_class.IsGeneric()) {
         CaptureInstantiator();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name,
-                                       intptr_t field_pos) {
+                                       TokenDescriptor field_pos) {
   TRACE_PARSER("ParseSuperFieldAccess");
   const Class& super_class = Class::ZoneHandle(Z, current_class().SuperClass());
   if (super_class.IsNull()) {
     ReportError("class '%s' does not have a superclass",
                 String::Handle(Z, current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
       String::ZoneHandle(Z, Field::LookupGetterSymbol(field_name));
@@ skipping 26 matching lines @@
       // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
     }
   }
   return new(Z) StaticGetterNode(
       field_pos, implicit_argument, super_class, field_name);
 }
 
 
 StaticCallNode* Parser::GenerateSuperConstructorCall(
       const Class& cls,
-      intptr_t supercall_pos,
+      TokenDescriptor supercall_pos,
       LocalVariable* receiver,
       ArgumentListNode* forwarding_args) {
   const Class& super_class = Class::Handle(Z, cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() ||
       (super_class.num_native_fields() > 0 &&
        Class::Handle(Z, super_class.SuperClass()).IsObjectClass())) {
     return NULL;
@@ skipping 46 matching lines @@
                 error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 StaticCallNode* Parser::ParseSuperInitializer(const Class& cls,
                                               LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
-  const intptr_t supercall_pos = TokenPos();
+  const TokenDescriptor supercall_pos = TokenPos();
   ConsumeToken();
   const Class& super_class = Class::Handle(Z, cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(Z, super_class.Name());
   ctor_name = Symbols::FromConcat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = Symbols::FromConcat(
         ctor_name, *ExpectIdentifier("constructor name expected"));
   }
@@ skipping 30 matching lines @@
                 error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 AstNode* Parser::ParseInitializer(const Class& cls,
                                   LocalVariable* receiver,
                                   GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializer");
-  const intptr_t field_pos = TokenPos();
+  const TokenDescriptor field_pos = TokenPos();
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
   }
   const String& field_name = *ExpectIdentifier("field name expected");
   ExpectToken(Token::kASSIGN);
 
   const bool saved_mode = SetAllowFunctionLiterals(false);
   // "this" must not be accessible in initializer expressions.
   receiver->set_invisible(true);
@@ skipping 55 matching lines @@
 
 
 AstNode* Parser::ParseExternalInitializedField(const Field& field) {
   // Only use this function if the initialized field originates
   // from a different class. We need to save and restore current
   // class, library, and token stream (script).
   ASSERT(current_class().raw() != field.origin());
   const Class& saved_class = Class::Handle(Z, current_class().raw());
   const Library& saved_library = Library::Handle(Z, library().raw());
   const Script& saved_script = Script::Handle(Z, script().raw());
-  const intptr_t saved_token_pos = TokenPos();
+  const TokenDescriptor saved_token_pos = TokenPos();
 
   set_current_class(Class::Handle(Z, field.origin()));
   set_library(Library::Handle(Z, current_class().library()));
   SetScript(Script::Handle(Z, current_class().script()), field.token_pos());
 
   ASSERT(IsIdentifier());
   ConsumeToken();
   ExpectToken(Token::kASSIGN);
   AstNode* init_expr = NULL;
-  intptr_t expr_pos = TokenPos();
+  TokenDescriptor expr_pos = TokenPos();
   if (field.is_const()) {
     init_expr = ParseConstExpr();
   } else {
     init_expr = ParseExpr(kAllowConst, kConsumeCascades);
     if (init_expr->EvalConstExpr() != NULL) {
       Instance& expr_value = Instance::ZoneHandle(Z);
       if (!GetCachedConstant(expr_pos, &expr_value)) {
         expr_value = EvaluateConstExpr(expr_pos, init_expr).raw();
         CacheConstantValue(expr_pos, expr_value);
       }
       init_expr = new(Z) LiteralNode(field.token_pos(), expr_value);
     }
   }
   set_current_class(saved_class);
   set_library(saved_library);
   SetScript(saved_script, saved_token_pos);
   return init_expr;
 }
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  LocalVariable* receiver,
                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(Z, cls.fields());
   Field& f = Field::Handle(Z);
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle(Z);
       field ^= fields.At(i);
       if (field.is_final()) {
         // Final fields with initializer expression may not be initialized
         // again by constructors. Remember that this field is already
         // initialized.
         initialized_fields->Add(&field);
       }
       AstNode* init_expr = NULL;
       if (current_class().raw() != field.origin()) {
         init_expr = ParseExternalInitializedField(field);
       } else {
-        SetPosition(field.token_pos());
+        SetPosition(field.token_pos().value());
         ASSERT(IsIdentifier());
         ConsumeToken();
         ExpectToken(Token::kASSIGN);
         if (current_class().is_const()) {
           // If the class has a const contructor, the initializer
           // expression must be a compile-time constant.
           init_expr = ParseConstExpr();
         } else {
-          intptr_t expr_pos = TokenPos();
+          TokenDescriptor expr_pos = TokenPos();
           init_expr = ParseExpr(kAllowConst, kConsumeCascades);
           if (init_expr->EvalConstExpr() != NULL) {
             Instance& expr_value = Instance::ZoneHandle(Z);
             if (!GetCachedConstant(expr_pos, &expr_value)) {
               expr_value = EvaluateConstExpr(expr_pos, init_expr).raw();
               CacheConstantValue(expr_pos, expr_value);
             }
             init_expr = new(Z) LiteralNode(field.token_pos(), expr_value);
           }
         }
       }
       ASSERT(init_expr != NULL);
       AstNode* instance = new LoadLocalNode(field.token_pos(), receiver);
       EnsureExpressionTemp();
       AstNode* field_init =
           new StoreInstanceFieldNode(field.token_pos(),
                                      instance,
                                      field,
                                      init_expr);
       current_block_->statements->Add(field_init);
     }
   }
   initialized_fields->Add(NULL);  // End of inline initializers.
   SetPosition(saved_pos);
 }
 
 
 AstNode* Parser::CheckDuplicateFieldInit(
-    intptr_t init_pos,
+    TokenDescriptor init_pos,
     GrowableArray<Field*>* initialized_fields,
     AstNode* instance,
     Field* field,
     AstNode* init_value) {
   ASSERT(!field->is_static());
   AstNode* result = NULL;
 
   // The initializer_list is divided into two sections. The sections
   // are separated by a NULL entry: [f0, ... fn, NULL, fn+1, ...]
   // The first fields f0 .. fn are final fields of the class that
@@ skipping 152 matching lines @@
   }
   CheckFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ExpectToken(Token::kCOLON);
   ASSERT(CurrentToken() == Token::kTHIS);
-  const intptr_t call_pos = TokenPos();
+  const TokenDescriptor call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(Z, cls.Name());
   GrowableHandlePtrArray<const String> pieces(Z, 3);
   pieces.Add(ctor_name);
   pieces.Add(Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     pieces.Add(*ExpectIdentifier("constructor name expected"));
   }
   ctor_name = Symbols::FromConcatAll(pieces);
@@ skipping 23 matching lines @@
                 error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsGenerativeConstructor());
   ASSERT(func.Owner() == current_class().raw());
-  const intptr_t ctor_pos = TokenPos();
+  const TokenDescriptor ctor_pos = TokenPos();
   OpenFunctionBlock(func);
 
   LocalVariable* receiver = new LocalVariable(
-      Token::kNoSourcePos, Symbols::This(), *ReceiverType(current_class()));
+      TokenDescriptor::kNoSource,
+      Symbols::This(),
+      *ReceiverType(current_class()));
   current_block_->scope->InsertParameterAt(0, receiver);
 
   // Parse expressions of instance fields that have an explicit
   // initializer expression.
   // The receiver must not be visible to field initializer expressions.
   receiver->set_invisible(true);
   GrowableArray<Field*> initialized_fields;
   ParseInitializedInstanceFields(
       current_class(), receiver, &initialized_fields);
   receiver->set_invisible(false);
@@ skipping 25 matching lines @@
                   "optional parameters and invoke it via super from a "
                   "constructor of the class extending the mixin application",
                   String::Handle(Z, super_class.Name()).ToCString());
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
     // The first user-defined argument is at position 1.
     forwarding_args = new ArgumentListNode(ST(ctor_pos));
     for (int i = 1; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
-          Token::kNoSourcePos,
+          TokenDescriptor::kNoSource,
           String::ZoneHandle(Z, func.ParameterNameAt(i)),
           Object::dynamic_type());
       current_block_->scope->InsertParameterAt(i, param);
       forwarding_args->Add(new LoadLocalNode(ST(ctor_pos), param));
     }
   }
 
   AstNode* super_call = GenerateSuperConstructorCall(
       current_class(),
       ctor_pos,
@@ skipping 336 matching lines @@
       if (IsInstantiatorRequired()) {
         // Make sure that the receiver of the enclosing instance function
         // (or implicit first parameter of an enclosing factory) is marked as
         // captured if type checks are enabled, because they may access it to
         // instantiate types.
         CaptureInstantiator();
       }
     }
   }
 
-  const intptr_t modifier_pos = TokenPos();
+  const TokenDescriptor modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
   if (!func.is_generated_body()) {
     // Don't add a modifier to the closure representing the body of
     // the asynchronous function or generator.
     func.set_modifier(func_modifier);
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& generated_body_closure = Function::ZoneHandle(Z);
@@ skipping 18 matching lines @@
     func.set_is_debuggable(false);
     generated_body_closure = OpenAsyncGeneratorFunction(func.token_pos());
   } else if (func.IsAsyncGenClosure()) {
     // The closure containing the body of an async* function is debuggable.
     ASSERT(func.is_debuggable());
     OpenAsyncGeneratorClosure();
   }
 
   BoolScope allow_await(&this->await_is_keyword_,
                         func.IsAsyncOrGenerator() || func.is_generated_body());
-  intptr_t end_token_pos = Token::kNoSourcePos;
+  TokenDescriptor end_token_pos = TokenDescriptor::kNoSource;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(Z, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseStatementSequence();
     end_token_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     if (func.IsGenerator()) {
       ReportError(modifier_pos,
                   "=> style function may not be sync* or async* generator");
     }
     ConsumeToken();
     if (String::Handle(Z, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
-    const intptr_t expr_pos = TokenPos();
+    const TokenDescriptor expr_pos = TokenPos();
     AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
     end_token_pos = TokenPos();
     if (check_semicolon) {
       ExpectSemicolon();
     }
   } else if (IsSymbol(Symbols::Native())) {
     if (String::Handle(Z, func.name()).Equals(
         Symbols::EqualOperator())) {
@@ skipping 47 matching lines @@
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   async_temp_scope_ = saved_async_temp_scope;
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
   AstNode* argument =
-      new LoadLocalNode(Token::kNoSourcePos,
+      new LoadLocalNode(TokenDescriptor::kNoSource,
                         current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
-      new LiteralNode(Token::kNoSourcePos, Instance::ZoneHandle(Z));
+      new LiteralNode(TokenDescriptor::kNoSource, Instance::ZoneHandle(Z));
   ComparisonNode* check_arg =
-      new ComparisonNode(Token::kNoSourcePos,
+      new ComparisonNode(TokenDescriptor::kNoSource,
                          Token::kEQ_STRICT,
                          argument,
                          null_operand);
   ComparisonNode* result =
-      new ComparisonNode(Token::kNoSourcePos,
+      new ComparisonNode(TokenDescriptor::kNoSource,
                          Token::kEQ_STRICT,
-                         LoadReceiver(Token::kNoSourcePos),
+                         LoadReceiver(TokenDescriptor::kNoSource),
                          null_operand);
-  SequenceNode* arg_is_null = new SequenceNode(Token::kNoSourcePos,
+  SequenceNode* arg_is_null = new SequenceNode(TokenDescriptor::kNoSource,
                                                current_block_->scope);
-  arg_is_null->Add(new ReturnNode(Token::kNoSourcePos, result));
-  IfNode* if_arg_null = new IfNode(Token::kNoSourcePos,
+  arg_is_null->Add(new ReturnNode(TokenDescriptor::kNoSource, result));
+  IfNode* if_arg_null = new IfNode(TokenDescriptor::kNoSource,
                                    check_arg,
                                    arg_is_null,
                                    NULL);
   current_block_->statements->Add(if_arg_null);
 }
 
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
@@ skipping 91 matching lines @@
   if (method->has_abstract && method->IsFactoryOrConstructor()) {
     ReportError(method->name_pos, "constructor cannot be abstract");
   }
   if (method->has_const && method->IsConstructor()) {
     current_class().set_is_const();
   }
 
   // Parse the formal parameters.
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
-  const intptr_t formal_param_pos = TokenPos();
+  const TokenDescriptor formal_param_pos = TokenPos();
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the TypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
     method->params.AddReceiver(ReceiverType(current_class()), formal_param_pos);
   } else if (method->IsFactory()) {
     method->params.AddFinalParameter(
         formal_param_pos,
         &Symbols::TypeArgumentsParameter(),
@@ skipping 53 matching lines @@
       ReportError("redirecting factory '%s' may not specify default values "
                   "for optional parameters",
                   method->name->ToCString());
     }
     if (method->has_external) {
       ReportError(TokenPos(),
                   "external factory constructor '%s' may not have redirection",
                   method->name->ToCString());
     }
     ConsumeToken();
-    const intptr_t type_pos = TokenPos();
+    const TokenDescriptor type_pos = TokenPos();
     is_redirecting = true;
     const bool consume_unresolved_prefix =
         (LookaheadToken(3) == Token::kLT) ||
         (LookaheadToken(3) == Token::kPERIOD);
     const AbstractType& type = AbstractType::Handle(Z,
         ParseType(ClassFinalizer::kResolveTypeParameters,
                   true,
                   consume_unresolved_prefix));
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
@@ skipping 58 matching lines @@
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
   if (method->IsConstructor() &&
       method->has_external &&
       method->params.has_field_initializer) {
     ReportError(method->name_pos,
                 "external constructor '%s' may not have field initializers",
                 method->name->ToCString());
   }
 
-  const intptr_t modifier_pos = TokenPos();
+  const TokenDescriptor modifier_pos = TokenPos();
   RawFunction::AsyncModifier async_modifier = ParseFunctionModifier();
   if ((method->IsFactoryOrConstructor() || method->IsSetter()) &&
       (async_modifier != RawFunction::kNoModifier)) {
     ReportError(modifier_pos,
                 "%s '%s' may not be async, async* or sync*",
                 (method->IsSetter()) ? "setter" : "constructor",
                 method->name->ToCString());
   }
 
-  intptr_t method_end_pos = TokenPos();
+  TokenDescriptor method_end_pos = TokenPos();
   String* native_name = NULL;
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
       ReportError(TokenPos(),
                   "abstract method '%s' may not have a function body",
                   method->name->ToCString());
     } else if (method->has_external) {
       ReportError(TokenPos(),
                   "external %s '%s' may not have a function body",
@@ skipping 111 matching lines @@
                     method->has_native,
                     current_class(),
                     method->decl_begin_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
   func.set_is_redirecting(is_redirecting);
   func.set_modifier(async_modifier);
   if (library_.is_dart_scheme() && library_.IsPrivate(*method->name)) {
     func.set_is_reflectable(false);
   }
-  if (FLAG_enable_mirrors && (method->metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && (method->metadata_pos.IsReal())) {
     library_.AddFunctionMetadata(func, method->metadata_pos);
   }
   if (method->has_native) {
     func.set_native_name(*native_name);
   }
 
   // If this method is a redirecting factory, set the redirection information.
   if (!redirection_type.IsNull()) {
     ASSERT(func.IsFactory());
     func.SetRedirectionType(redirection_type);
@@ skipping 10 matching lines @@
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA ||
          CurrentToken() == Token::kASSIGN);
   ASSERT(field->type != NULL);
-  ASSERT(field->name_pos >= 0);
+  ASSERT(field->name_pos.IsReal());
   ASSERT(current_member_ == field);
   // All const fields are also final.
   ASSERT(!field->has_const || field->has_final);
 
   if (field->has_abstract) {
     ReportError("keyword 'abstract' not allowed in field declaration");
   }
   if (field->has_external) {
     ReportError("keyword 'external' not allowed in field declaration");
   }
@@ skipping 48 matching lines @@
                              field->has_static,
                              field->has_final,
                              field->has_const,
                              is_reflectable,
                              current_class(),
                              *field->type,
                              field->name_pos);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
     field->field_ = &class_field;
-    if (FLAG_enable_mirrors && (field->metadata_pos >= 0)) {
+    if (FLAG_enable_mirrors && (field->metadata_pos.IsReal())) {
       library_.AddFieldMetadata(class_field, field->metadata_pos);
     }
 
     // Start tracking types for fields with simple initializers in their
     // definition. This avoids some of the overhead to track this at runtime
     // and rules out many fields from being unnecessary unboxing candidates.
     if (!field->has_static && has_initializer && has_simple_literal) {
       class_field.RecordStore(init_value);
       if (!init_value.IsNull() && init_value.IsDouble()) {
         class_field.set_is_double_initialized(true);
@@ skipping 126 matching lines @@
                   "%s '%s' conflicts with previously declared %s",
                   member->ToCString(),
                   name.ToCString(),
                   existing_member->ToCString());
     }
   }
 }
 
 
 void Parser::ParseClassMemberDefinition(ClassDesc* members,
-                                        intptr_t metadata_pos) {
+                                        TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
   member.metadata_pos = metadata_pos;
   member.decl_begin_pos = TokenPos();
   if ((CurrentToken() == Token::kEXTERNAL) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_external = true;
   }
@@ skipping 190 matching lines @@
     UnexpectedToken();
   }
   current_member_ = NULL;
   CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
 
 
 void Parser::ParseEnumDeclaration(const GrowableObjectArray& pending_classes,
                                   const Object& tl_owner,
-                                  intptr_t metadata_pos) {
+                                  TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseEnumDeclaration");
-  const intptr_t declaration_pos = (metadata_pos >= 0) ? metadata_pos
-                                                       : TokenPos();
+  const TokenDescriptor declaration_pos =
+      (metadata_pos.IsReal()) ? metadata_pos : TokenPos();
   ConsumeToken();
-  const intptr_t name_pos = TokenPos();
+  const TokenDescriptor name_pos = TokenPos();
   String* enum_name =
       ExpectUserDefinedTypeIdentifier("enum type name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing enum '%s'\n", enum_name->ToCString());
   }
   ExpectToken(Token::kLBRACE);
   if (!IsIdentifier()) {
     ReportError("Enumeration must have at least one name");
   }
   while (IsIdentifier()) {
@@ skipping 14 matching lines @@
   Object& obj = Object::Handle(Z, library_.LookupLocalObject(*enum_name));
   if (!obj.IsNull()) {
     ReportError(name_pos, "'%s' is already defined", enum_name->ToCString());
   }
   Class& cls = Class::Handle(Z);
   cls = Class::New(*enum_name, script_, declaration_pos);
   cls.set_library(library_);
   library_.AddClass(cls);
   cls.set_is_synthesized_class();
   cls.set_is_enum_class();
-  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && (metadata_pos.IsReal())) {
     library_.AddClassMetadata(cls, tl_owner, metadata_pos);
   }
   cls.set_super_type(Type::Handle(Z, Type::ObjectType()));
   pending_classes.Add(cls, Heap::kOld);
 }
 
 
 void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                                    const Object& tl_owner,
-                                   intptr_t metadata_pos) {
+                                   TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseClassDeclaration");
   bool is_patch = false;
   bool is_abstract = false;
-  intptr_t declaration_pos = (metadata_pos >= 0) ? metadata_pos : TokenPos();
+  TokenDescriptor declaration_pos =
+      metadata_pos.IsReal() ? metadata_pos : TokenPos();
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kABSTRACT) {
     is_abstract = true;
     ConsumeToken();
   }
   ExpectToken(Token::kCLASS);
-  const intptr_t classname_pos = TokenPos();
+  const TokenDescriptor classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::Handle(Z);
   TypeArguments& orig_type_parameters = TypeArguments::Handle(Z);
   Object& obj = Object::Handle(Z, library_.LookupLocalObject(class_name));
   if (obj.IsNull()) {
     if (is_patch) {
       ReportError(classname_pos, "missing class '%s' cannot be patched",
@@ skipping 73 matching lines @@
                     class_name.ToCString(),
                     String::Handle(orig_bound.UserVisibleName()).ToCString());
       }
     }
     cls.set_type_parameters(orig_type_parameters);
   }
 
   if (is_abstract) {
     cls.set_is_abstract();
   }
-  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddClassMetadata(cls, tl_owner, metadata_pos);
   }
 
   const bool is_mixin_declaration = (CurrentToken() == Token::kASSIGN);
   if (is_mixin_declaration && is_patch) {
     ReportError(classname_pos,
                 "mixin application '%s' may not be a patch class",
                 class_name.ToCString());
   }
 
   AbstractType& super_type = Type::Handle(Z);
   if ((CurrentToken() == Token::kEXTENDS) || is_mixin_declaration) {
     ConsumeToken();  // extends or =
-    const intptr_t type_pos = TokenPos();
+    const TokenDescriptor type_pos = TokenPos();
     super_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (super_type.IsMalformedOrMalbounded()) {
       ReportError(Error::Handle(Z, super_type.error()));
     }
     if (super_type.IsDynamicType()) {
       // Unlikely here, since super type is not resolved yet.
       ReportError(type_pos,
                   "class '%s' may not extend 'dynamic'",
                   class_name.ToCString());
     }
@@ skipping 56 matching lines @@
   String& class_name = String::Handle(Z, cls.Name());
   SkipMetadata();
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
   } else if (CurrentToken() == Token::kABSTRACT) {
     ConsumeToken();
   }
   ExpectToken(Token::kCLASS);
-  const intptr_t class_pos = TokenPos();
+  const TokenDescriptor class_pos = TokenPos();
   ClassDesc members(Z, cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kLBRACE) {
     ConsumeToken();
   }
   ExpectToken(Token::kLBRACE);
   while (CurrentToken() != Token::kRBRACE) {
-    intptr_t metadata_pos = SkipMetadata();
+    TokenDescriptor metadata_pos = SkipMetadata();
     ParseClassMemberDefinition(&members, metadata_pos);
   }
   ExpectToken(Token::kRBRACE);
 
   CheckConstructors(&members);
 
   // Need to compute this here since MakeArray() will clear the
   // functions array in members.
   const bool need_implicit_constructor =
       !members.has_constructor() && !cls.is_patch();
@@ skipping 258 matching lines @@
       ctors.Add(member);
       member = class_desc->LookupMember(*member->redirect_name);
     }
   }
 }
 
 
 void Parser::ParseMixinAppAlias(
     const GrowableObjectArray& pending_classes,
     const Object& tl_owner,
-    intptr_t metadata_pos) {
+    TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseMixinAppAlias");
-  const intptr_t classname_pos = TokenPos();
+  const TokenDescriptor classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("toplevel parsing mixin application alias class '%s'\n",
               class_name.ToCString());
   }
   const Object& obj = Object::Handle(Z, library_.LookupLocalObject(class_name));
   if (!obj.IsNull()) {
     ReportError(classname_pos, "'%s' is already defined",
                 class_name.ToCString());
   }
   const Class& mixin_application =
       Class::Handle(Z, Class::New(class_name, script_, classname_pos));
   mixin_application.set_is_mixin_app_alias();
   library_.AddClass(mixin_application);
   set_current_class(mixin_application);
   ParseTypeParameters(mixin_application);
 
   ExpectToken(Token::kASSIGN);
 
   if (CurrentToken() == Token::kABSTRACT) {
     mixin_application.set_is_abstract();
     ConsumeToken();
   }
 
-  const intptr_t type_pos = TokenPos();
+  const TokenDescriptor type_pos = TokenPos();
   AbstractType& type =
       AbstractType::Handle(Z,
                            ParseType(ClassFinalizer::kResolveTypeParameters));
   if (type.IsTypeParameter()) {
     ReportError(type_pos,
                 "class '%s' may not extend type parameter '%s'",
                 class_name.ToCString(),
                 String::Handle(Z, type.UserVisibleName()).ToCString());
   }
 
   CheckToken(Token::kWITH, "mixin application 'with Type' expected");
   type = ParseMixins(type);
 
   mixin_application.set_super_type(type);
   mixin_application.set_is_synthesized_class();
 
   // This mixin application alias needs an implicit constructor, but it is
   // too early to call 'AddImplicitConstructor(mixin_application)' here,
   // because this class should be lazily compiled.
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(mixin_application);
   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
-  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddClassMetadata(mixin_application, tl_owner, metadata_pos);
   }
 }
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
 // We need this lookahead to distinguish between the optional return type
 // and the alias name of a function type alias.
 // Token position remains unchanged.
 bool Parser::IsFunctionTypeAliasName() {
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
     return true;
   }
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   bool is_alias_name = false;
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLT)) {
     ConsumeToken();
     if (TryParseTypeParameters() && (CurrentToken() == Token::kLPAREN)) {
       is_alias_name = true;
     }
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "=".
 // Token position remains unchanged.
 bool Parser::IsMixinAppAlias() {
   if (IsIdentifier() && (LookaheadToken(1) == Token::kASSIGN)) {
     return true;
   }
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   bool is_mixin_def = false;
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLT)) {
     ConsumeToken();
     if (TryParseTypeParameters() && (CurrentToken() == Token::kASSIGN)) {
       is_mixin_def = true;
     }
   }
   SetPosition(saved_pos);
   return is_mixin_def;
 }
 
 
 void Parser::ParseTypedef(const GrowableObjectArray& pending_classes,
                           const Object& tl_owner,
-                          intptr_t metadata_pos) {
+                          TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseTypedef");
-  intptr_t declaration_pos = (metadata_pos >= 0) ? metadata_pos : TokenPos();
+  TokenDescriptor declaration_pos =
+      metadata_pos.IsReal() ? metadata_pos : TokenPos();
   ExpectToken(Token::kTYPEDEF);
 
   if (IsMixinAppAlias()) {
     if (FLAG_warn_mixin_typedef) {
       ReportWarning(TokenPos(), "deprecated mixin application typedef");
     }
     ParseMixinAppAlias(pending_classes, tl_owner, metadata_pos);
     return;
   }
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in production mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(ClassFinalizer::kDoNotResolve);
   }
 
-  const intptr_t alias_name_pos = TokenPos();
+  const TokenDescriptor alias_name_pos = TokenPos();
   const String* alias_name =
       ExpectUserDefinedTypeIdentifier("function alias name expected");
 
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
   const Object& obj =
       Object::Handle(Z, library_.LookupLocalObject(*alias_name));
   if (!obj.IsNull()) {
     ReportError(alias_name_pos,
                 "'%s' is already defined", alias_name->ToCString());
@@ skipping 42 matching lines @@
   function_type_alias.set_signature_function(signature_function);
 
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               String::Handle(Z, signature_function.Signature()).ToCString());
   }
   // The alias should not be marked as finalized yet, since it needs to be
   // checked in the class finalizer for illegal self references.
   ASSERT(!function_type_alias.is_finalized());
   pending_classes.Add(function_type_alias, Heap::kOld);
-  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddClassMetadata(function_type_alias,
                               tl_owner,
                               metadata_pos);
   }
 }
 
 
 // Consumes exactly one right angle bracket. If the current token is a single
 // bracket token, it is consumed normally. However, if it is a double or triple
 // bracket, it is replaced by a single or double bracket token without
 // incrementing the token index.
 void Parser::ConsumeRightAngleBracket() {
   if (token_kind_ == Token::kGT) {
     ConsumeToken();
   } else if (token_kind_ == Token::kSHR) {
     token_kind_ = Token::kGT;
   } else {
     UNREACHABLE();
   }
 }
 
 
-intptr_t Parser::SkipMetadata() {
+TokenDescriptor Parser::SkipMetadata() {
   if (CurrentToken() != Token::kAT) {
-    return Token::kNoSourcePos;
+    return TokenDescriptor::kNoSource;
   }
-  intptr_t metadata_pos = TokenPos();
+  TokenDescriptor metadata_pos = TokenPos();
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     ExpectIdentifier("identifier expected");
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         ExpectIdentifier("identifier expected");
       }
@@ skipping 43 matching lines @@
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> type_parameters_array(Z, 2);
     intptr_t index = 0;
     TypeParameter& type_parameter = TypeParameter::Handle(Z);
     TypeParameter& existing_type_parameter = TypeParameter::Handle(Z);
     String& existing_type_parameter_name = String::Handle(Z);
     AbstractType& type_parameter_bound = Type::Handle(Z);
     do {
       ConsumeToken();
-      const intptr_t metadata_pos = SkipMetadata();
-      const intptr_t type_parameter_pos = TokenPos();
-      const intptr_t declaration_pos = (metadata_pos >= 0) ? metadata_pos
-                                                           : type_parameter_pos;
+      const TokenDescriptor metadata_pos = SkipMetadata();
+      const TokenDescriptor type_parameter_pos = TokenPos();
+      const TokenDescriptor declaration_pos =
+          metadata_pos.IsReal() ? metadata_pos : type_parameter_pos;
       String& type_parameter_name =
           *ExpectUserDefinedTypeIdentifier("type parameter expected");
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i)->raw();
         existing_type_parameter_name = existing_type_parameter.name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
           ReportError(type_parameter_pos, "duplicate type parameter '%s'",
                       type_parameter_name.ToCString());
         }
       }
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or interface currently being parsed.
         // Postpone resolution in order to avoid resolving the class and its
         // type parameters, as they are not fully parsed yet.
         type_parameter_bound = ParseType(ClassFinalizer::kDoNotResolve);
       } else {
         type_parameter_bound = I->object_store()->object_type();
       }
       type_parameter = TypeParameter::New(cls,
                                           index,
                                           type_parameter_name,
                                           type_parameter_bound,
                                           declaration_pos);
       type_parameters_array.Add(
           &AbstractType::ZoneHandle(Z, type_parameter.raw()));
-      if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+      if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
         library_.AddTypeParameterMetadata(type_parameter, metadata_pos);
       }
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ReportError("right angle bracket expected");
     }
@@ skipping 54 matching lines @@
   AbstractType& interface = AbstractType::Handle(Z);
   // First get all the interfaces already implemented by class.
   Array& cls_interfaces = Array::Handle(Z, cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(interface);
   }
   // Now parse and add the new interfaces.
   do {
     ConsumeToken();
-    intptr_t interface_pos = TokenPos();
+    TokenDescriptor interface_pos = TokenPos();
     interface = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (interface.IsTypeParameter()) {
       ReportError(interface_pos,
                   "type parameter '%s' may not be used in interface list",
                   String::Handle(Z, interface.UserVisibleName()).ToCString());
     }
     all_interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
@@ skipping 21 matching lines @@
     }
     mixin_types.Add(mixin_type);
   } while (CurrentToken() == Token::kCOMMA);
   return MixinAppType::New(super_type,
       Array::Handle(Z, Array::MakeArray(mixin_types)));
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    const Object& owner,
-                                   intptr_t metadata_pos) {
+                                   TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(Z,
       ParseConstFinalVarOrType(ClassFinalizer::kResolveTypeParameters));
   Field& field = Field::Handle(Z);
   Function& getter = Function::Handle(Z);
   while (true) {
-    const intptr_t name_pos = TokenPos();
+    const TokenDescriptor name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupLocalObject(var_name) != Object::null()) {
       ReportError(name_pos, "'%s' is already defined", var_name.ToCString());
     }
 
     // Check whether a getter or setter for this name exists. A const
     // or final field implies a setter which throws a NoSuchMethodError,
     // thus we need to check for conflicts with existing setters and
     // getters.
@@ skipping 10 matching lines @@
 
     const bool is_reflectable =
         !(library_.is_dart_scheme() && library_.IsPrivate(var_name));
 
     field = Field::NewTopLevel(var_name, is_final, is_const, owner, name_pos);
     field.SetFieldType(type);
     field.set_is_reflectable(is_reflectable);
     field.SetStaticValue(Object::null_instance(), true);
     top_level->AddField(field);
     library_.AddObject(field, var_name);
-    if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+    if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
       library_.AddFieldMetadata(field, metadata_pos);
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Z, Object::sentinel().raw());
       bool has_simple_literal = false;
       if (LookaheadToken(1) == Token::kSEMICOLON) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
       SkipExpr();
@@ skipping 55 matching lines @@
     ConsumeToken();
     ConsumeToken();
     return RawFunction::kSyncGen;
   }
   return RawFunction::kNoModifier;
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level,
                                    const Object& owner,
-                                   intptr_t metadata_pos) {
+                                   TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
-  const intptr_t decl_begin_pos = TokenPos();
+  const TokenDescriptor decl_begin_pos = TokenPos();
   AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch") &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
     is_external = true;
   }
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     }
   }
-  const intptr_t name_pos = TokenPos();
+  const TokenDescriptor name_pos = TokenPos();
   const String& func_name = *ExpectIdentifier("function name expected");
 
   bool found = library_.LookupLocalObject(func_name) != Object::null();
   if (found && !is_patch) {
     ReportError(name_pos, "'%s' is already defined", func_name.ToCString());
   } else if (!found && is_patch) {
     ReportError(name_pos, "missing '%s' cannot be patched",
                 func_name.ToCString());
   }
   String& accessor_name = String::Handle(Z, Field::GetterName(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ReportError(name_pos, "'%s' is already defined as getter",
                 func_name.ToCString());
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
   CheckToken(Token::kLPAREN);
-  const intptr_t function_pos = TokenPos();
+  const TokenDescriptor function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
-  const intptr_t modifier_pos = TokenPos();
+  const TokenDescriptor modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
 
-  intptr_t function_end_pos = function_pos;
+  TokenDescriptor function_end_pos = function_pos;
   bool is_native = false;
   String* native_name = NULL;
   if (is_external) {
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     function_end_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
@@ skipping 40 matching lines @@
     library_.AddObject(func, func_name);
   } else {
     // Need to remove the previously added function that is being patched.
     const Class& toplevel_cls = Class::Handle(Z, library_.toplevel_class());
     const Function& replaced_func =
         Function::Handle(Z, toplevel_cls.LookupStaticFunction(func_name));
     ASSERT(!replaced_func.IsNull());
     toplevel_cls.RemoveFunction(replaced_func);
     library_.ReplaceObject(func, func_name);
   }
-  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level,
                                    const Object& owner,
-                                   intptr_t metadata_pos) {
+                                   TokenDescriptor metadata_pos) {
   TRACE_PARSER("ParseTopLevelAccessor");
-  const intptr_t decl_begin_pos = TokenPos();
+  const TokenDescriptor decl_begin_pos = TokenPos();
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   AbstractType& result_type = AbstractType::Handle(Z);
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kEXTERNAL) {
@@ skipping 12 matching lines @@
     } else {
       result_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     }
     is_getter = (CurrentToken() == Token::kGET);
     if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
       ConsumeToken();
     } else {
       UnexpectedToken();
     }
   }
-  const intptr_t name_pos = TokenPos();
+  const TokenDescriptor name_pos = TokenPos();
   const String* field_name = ExpectIdentifier("accessor name expected");
 
-  const intptr_t accessor_pos = TokenPos();
+  const TokenDescriptor accessor_pos = TokenPos();
   ParamList params;
 
   if (!is_getter) {
     const bool allow_explicit_default_values = true;
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
   String& accessor_name = String::ZoneHandle(Z);
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
@@ skipping 26 matching lines @@
   if (found && !is_patch) {
     ReportError(name_pos, "%s for '%s' is already defined",
                 is_getter ? "getter" : "setter",
                 field_name->ToCString());
   } else if (!found && is_patch) {
     ReportError(name_pos, "missing %s for '%s' cannot be patched",
                 is_getter ? "getter" : "setter",
                 field_name->ToCString());
   }
 
-  const intptr_t modifier_pos = TokenPos();
+  const TokenDescriptor modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
   if (!is_getter && (func_modifier != RawFunction::kNoModifier)) {
     ReportError(modifier_pos,
                 "setter function cannot be async, async* or sync*");
   }
 
-  intptr_t accessor_end_pos = accessor_pos;
+  TokenDescriptor accessor_end_pos = accessor_pos;
   bool is_native = false;
   String* native_name = NULL;
   if (is_external) {
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     accessor_end_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
@@ skipping 44 matching lines @@
     // Need to remove the previously added accessor that is being patched.
     const Class& toplevel_cls = Class::Handle(Z,
         owner.IsClass() ? Class::Cast(owner).raw()
                         : PatchClass::Cast(owner).patched_class());
     const Function& replaced_func =
         Function::Handle(Z, toplevel_cls.LookupFunction(accessor_name));
     ASSERT(!replaced_func.IsNull());
     toplevel_cls.RemoveFunction(replaced_func);
     library_.ReplaceObject(func, accessor_name);
   }
-  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
 
 RawObject* Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
-                                         intptr_t token_pos,
+                                         TokenDescriptor token_pos,
                                          const String& url) {
   Dart_LibraryTagHandler handler = I->library_tag_handler();
   if (handler == NULL) {
     if (url.StartsWith(Symbols::DartScheme())) {
       if (tag == Dart_kCanonicalizeUrl) {
         return url.raw();
       }
       return Object::null();
     }
     ReportError(token_pos, "no library handler registered");
@@ skipping 50 matching lines @@
     ConsumeToken();  // Identifier.
     if (CurrentToken() != Token::kCOMMA) {
       return;
     }
     ConsumeToken();  // Comma.
   }
 }
 
 
 void Parser::ParseLibraryImportExport(const Object& tl_owner,
-                                      intptr_t metadata_pos) {
+                                      TokenDescriptor metadata_pos) {
   bool is_import = (CurrentToken() == Token::kIMPORT);
   bool is_export = (CurrentToken() == Token::kEXPORT);
   ASSERT(is_import || is_export);
-  const intptr_t import_pos = TokenPos();
+  const TokenDescriptor import_pos = TokenPos();
   ConsumeToken();
   CheckToken(Token::kSTRING, "library url expected");
   AstNode* url_literal = ParseStringLiteral(false);
   if (FLAG_conditional_directives) {
     bool condition_triggered = false;
     while (CurrentToken() == Token::kIF) {
       // Conditional import: if (env == val) uri.
       ConsumeToken();
       ExpectToken(Token::kLPAREN);
       // Parse dotted name.
@@ skipping 43 matching lines @@
   if (url.Length() == 0) {
     ReportError("library url expected");
   }
   bool is_deferred_import = false;
   if (is_import && (IsSymbol(Symbols::Deferred()))) {
     is_deferred_import = true;
     ConsumeToken();
     CheckToken(Token::kAS, "'as' expected");
   }
   String& prefix = String::Handle(Z);
-  intptr_t prefix_pos = Token::kNoSourcePos;
+  TokenDescriptor prefix_pos = TokenDescriptor::kNoSource;
   if (is_import && (CurrentToken() == Token::kAS)) {
     ConsumeToken();
     prefix_pos = TokenPos();
     prefix = ExpectIdentifier("prefix identifier expected")->raw();
   }
 
   Array& show_names = Array::Handle(Z);
   Array& hide_names = Array::Handle(Z);
   if (is_deferred_import ||
       IsSymbol(Symbols::Show()) ||
@@ skipping 42 matching lines @@
   // library import, call the library tag handler to request loading
   // the library.
   if (library.LoadNotStarted() &&
       (!is_deferred_import || FLAG_load_deferred_eagerly)) {
     library.SetLoadRequested();
     CallLibraryTagHandler(Dart_kImportTag, import_pos, canon_url);
   }
 
   Namespace& ns = Namespace::Handle(Z,
       Namespace::New(library, show_names, hide_names));
-  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     ns.AddMetadata(tl_owner, metadata_pos);
   }
 
   // Ensure that private dart:_ libraries are only imported into dart:
   // libraries, including indirectly through exports.
   const String& lib_url = String::Handle(Z, library_.url());
   if (canon_url.StartsWith(Symbols::DartSchemePrivate()) &&
       !lib_url.StartsWith(Symbols::DartScheme())) {
     ReportError(import_pos, "private library is not accessible");
   }
@@ skipping 29 matching lines @@
       }
     }
   } else {
     ASSERT(is_export);
     library_.AddExport(ns);
   }
 }
 
 
 void Parser::ParseLibraryPart() {
-  const intptr_t source_pos = TokenPos();
+  const TokenDescriptor source_pos = TokenPos();
   ConsumeToken();  // Consume "part".
   CheckToken(Token::kSTRING, "url expected");
   AstNode* url_literal = ParseStringLiteral(false);
   ASSERT(url_literal->IsLiteralNode());
   ASSERT(url_literal->AsLiteralNode()->literal().IsString());
   const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   ExpectSemicolon();
   const String& canon_url = String::CheckedHandle(
       CallLibraryTagHandler(Dart_kCanonicalizeUrl, source_pos, url));
   CallLibraryTagHandler(Dart_kSourceTag, source_pos, canon_url);
 }
 
 
 void Parser::ParseLibraryDefinition(const Object& tl_owner) {
   TRACE_PARSER("ParseLibraryDefinition");
 
   // Handle the script tag.
   if (CurrentToken() == Token::kSCRIPTTAG) {
     // Nothing to do for script tags except to skip them.
     ConsumeToken();
   }
 
   ASSERT(script_.kind() != RawScript::kSourceTag);
 
   // We may read metadata tokens that are part of the toplevel
   // declaration that follows the library definitions. Therefore, we
   // need to remember the position of the last token that was
   // successfully consumed.
-  intptr_t rewind_pos = TokenPos();
-  intptr_t metadata_pos = SkipMetadata();
+  TokenDescriptor rewind_pos = TokenPos();
+  TokenDescriptor metadata_pos = SkipMetadata();
   if (CurrentToken() == Token::kLIBRARY) {
     if (is_patch_source()) {
       ReportError("patch cannot override library name");
     }
     ParseLibraryName();
-    if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+    if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
       library_.AddLibraryMetadata(tl_owner, metadata_pos);
     }
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
   }
   while ((CurrentToken() == Token::kIMPORT) ||
       (CurrentToken() == Token::kEXPORT)) {
     ParseLibraryImportExport(tl_owner, metadata_pos);
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
@@ skipping 61 matching lines @@
   if (is_library_source() || is_patch_source()) {
     set_current_class(toplevel_class);
     ParseLibraryDefinition(tl_owner);
   } else if (is_part_source()) {
     ParsePartHeader();
   }
 
   const Class& cls = Class::Handle(Z);
   while (true) {
     set_current_class(cls);  // No current class.
-    intptr_t metadata_pos = SkipMetadata();
+    TokenDescriptor metadata_pos = SkipMetadata();
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDeclaration(pending_classes, tl_owner, metadata_pos);
     } else if (CurrentToken() == Token::kENUM) {
       ParseEnumDeclaration(pending_classes, tl_owner, metadata_pos);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       set_current_class(toplevel_class);
       ParseTypedef(pending_classes, tl_owner, metadata_pos);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
@@ skipping 104 matching lines @@
 
 SequenceNode* Parser::CloseAsyncGeneratorTryBlock(SequenceNode *body) {
   TRACE_PARSER("CloseAsyncGeneratorTryBlock");
   // The generated try-catch-finally that wraps the async generator function
   // body is the outermost try statement.
   ASSERT(try_stack_ != NULL);
   ASSERT(try_stack_->outer_try() == NULL);
   // We only get here when parsing an async generator body.
   ASSERT(innermost_function().IsAsyncGenClosure());
 
-  const intptr_t try_end_pos = innermost_function().end_token_pos();
+  const TokenDescriptor try_end_pos = innermost_function().end_token_pos();
 
   // The try-block (closure body code) has been parsed. We are now
   // generating the code for the catch block.
   LocalScope* try_scope = current_block_->scope;
   try_stack_->enter_catch();
   OpenBlock();  // Catch handler list.
   OpenBlock();  // Catch block.
 
   // Add the exception and stack trace parameters to the scope.
   CatchParamDesc exception_param;
   CatchParamDesc stack_trace_param;
-  exception_param.token_pos = Token::kNoSourcePos;
+  exception_param.token_pos = TokenDescriptor::kNoSource;
   exception_param.type = &Object::dynamic_type();
   exception_param.name = &Symbols::ExceptionParameter();
-  stack_trace_param.token_pos = Token::kNoSourcePos;
+  stack_trace_param.token_pos = TokenDescriptor::kNoSource;
   stack_trace_param.type = &Object::dynamic_type();
   stack_trace_param.name = &Symbols::StackTraceParameter();
 
   AddCatchParamsToScope(
       &exception_param, &stack_trace_param, current_block_->scope);
 
   // Generate code to save the exception object and stack trace
   // in local variables.
   LocalVariable* context_var = try_scope->LocalLookupVariable(
       Symbols::SavedTryContextVar());
   ASSERT(context_var != NULL);
 
   LocalVariable* exception_var = try_scope->LocalLookupVariable(
       Symbols::ExceptionVar());
   ASSERT(exception_var != NULL);
   if (exception_param.var != NULL) {
     // Generate code to load the exception object (:exception_var) into
     // the exception variable specified in this block.
     current_block_->statements->Add(new(Z) StoreLocalNode(
-        Token::kNoSourcePos,
+        TokenDescriptor::kNoSource,
         exception_param.var,
-        new(Z) LoadLocalNode(Token::kNoSourcePos, exception_var)));
+        new(Z) LoadLocalNode(TokenDescriptor::kNoSource, exception_var)));
   }
 
   LocalVariable* stack_trace_var =
       try_scope->LocalLookupVariable(Symbols::StackTraceVar());
   ASSERT(stack_trace_var != NULL);
   if (stack_trace_param.var != NULL) {
     // A stack trace variable is specified in this block, so generate code
     // to load the stack trace object (:stack_trace_var) into the stack
     // trace variable specified in this block.
     current_block_->statements->Add(new(Z) StoreLocalNode(
-        Token::kNoSourcePos,
+        TokenDescriptor::kNoSource,
         stack_trace_param.var,
-        new(Z) LoadLocalNode(Token::kNoSourcePos, stack_trace_var)));
+        new(Z) LoadLocalNode(TokenDescriptor::kNoSource, stack_trace_var)));
   }
   LocalVariable* saved_exception_var = try_scope->LocalLookupVariable(
       Symbols::SavedExceptionVar());
   LocalVariable* saved_stack_trace_var = try_scope->LocalLookupVariable(
       Symbols::SavedStackTraceVar());
   SaveExceptionAndStacktrace(current_block_->statements,
                              exception_var,
                              stack_trace_var,
                              saved_exception_var,
                              saved_stack_trace_var);
 
   // Catch block: add the error to the stream.
   // :controller.AddError(:exception, :stack_trace);
   // return;  // The finally block will close the stream.
   LocalVariable* controller =
       current_block_->scope->LookupVariable(Symbols::Controller(), false);
   ASSERT(controller != NULL);
   ArgumentListNode* args =
-      new(Z) ArgumentListNode(Token::kNoSourcePos);
-  args->Add(new(Z) LoadLocalNode(Token::kNoSourcePos, exception_param.var));
-  args->Add(new(Z) LoadLocalNode(Token::kNoSourcePos, stack_trace_param.var));
+      new(Z) ArgumentListNode(TokenDescriptor::kNoSource);
+  args->Add(new(Z) LoadLocalNode(
+      TokenDescriptor::kNoSource, exception_param.var));
+  args->Add(new(Z) LoadLocalNode(
+      TokenDescriptor::kNoSource, stack_trace_param.var));
   current_block_->statements->Add(
       new(Z) InstanceCallNode(try_end_pos,
-          new(Z) LoadLocalNode(Token::kNoSourcePos, controller),
+          new(Z) LoadLocalNode(TokenDescriptor::kNoSource, controller),
           Symbols::AddError(),
           args));
-  ReturnNode* return_node = new(Z) ReturnNode(Token::kNoSourcePos);
+  ReturnNode* return_node = new(Z) ReturnNode(TokenDescriptor::kNoSource);
   AddNodeForFinallyInlining(return_node);
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
   TryStack* try_statement = PopTry();
   ASSERT(try_stack_ == NULL);  // We popped the outermost try block.
 
   // Finally block: closing the stream and returning. Instead of simply
   // returning, create an await state and suspend. There may be outstanding
   // calls to schedule the generator body. This suspension ensures that we
   // do not repeat any code of the generator body.
   // :controller.close();
   // suspend;
   // We need to inline this code in all recorded exit points.
   intptr_t node_index = 0;
   SequenceNode* finally_clause = NULL;
   if (try_stack_ != NULL) {
     try_stack_->enter_finally();
   }
   do {
     OpenBlock();
     ArgumentListNode* no_args =
-        new(Z) ArgumentListNode(Token::kNoSourcePos);
+        new(Z) ArgumentListNode(TokenDescriptor::kNoSource);
     current_block_->statements->Add(
         new(Z) InstanceCallNode(try_end_pos,
-            new(Z) LoadLocalNode(Token::kNoSourcePos, controller),
+            new(Z) LoadLocalNode(TokenDescriptor::kNoSource, controller),
             Symbols::Close(),
             no_args));
 
     // Suspend after the close.
     AwaitMarkerNode* await_marker =
         new(Z) AwaitMarkerNode(async_temp_scope_,
                                current_block_->scope,
-                               Token::kNoSourcePos);
+                               TokenDescriptor::kNoSource);
     current_block_->statements->Add(await_marker);
     ReturnNode* continuation_ret = new(Z) ReturnNode(try_end_pos);
     continuation_ret->set_return_type(ReturnNode::kContinuationTarget);
     current_block_->statements->Add(continuation_ret);
 
     finally_clause = CloseBlock();
     AstNode* node_to_inline = try_statement->GetNodeToInlineFinally(node_index);
     if (node_to_inline != NULL) {
       InlinedFinallyNode* node =
           new(Z) InlinedFinallyNode(try_end_pos,
@@ skipping 10 matching lines @@
   if (try_stack_ != NULL) {
     try_stack_->exit_finally();
   }
 
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   // Catch block handles all exceptions.
   handler_types.Add(Object::dynamic_type());
 
   CatchClauseNode* catch_clause = new(Z) CatchClauseNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       catch_handler_list,
       Array::ZoneHandle(Z, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
       saved_exception_var,
       saved_stack_trace_var,
       AllocateTryIndex(),
       true);
 
   const intptr_t try_index = try_statement->try_index();
 
   AstNode* try_catch_node =
-      new(Z) TryCatchNode(Token::kNoSourcePos,
+      new(Z) TryCatchNode(TokenDescriptor::kNoSource,
                           body,
                           context_var,
                           catch_clause,
                           finally_clause,
                           try_index,
                           finally_clause);
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::CloseAsyncTryBlock(SequenceNode* try_block) {
   // This is the outermost try-catch of the function.
   ASSERT(try_stack_ != NULL);
   ASSERT(try_stack_->outer_try() == NULL);
   ASSERT(innermost_function().IsAsyncClosure());
   LocalScope* try_scope = current_block_->scope;
 
   try_stack_->enter_catch();
 
   OpenBlock();  // Catch handler list.
   OpenBlock();  // Catch block.
   CatchParamDesc exception_param;
   CatchParamDesc stack_trace_param;
-  exception_param.token_pos = Token::kNoSourcePos;
+  exception_param.token_pos = TokenDescriptor::kNoSource;
   exception_param.type = &Object::dynamic_type();
   exception_param.name = &Symbols::ExceptionParameter();
-  stack_trace_param.token_pos = Token::kNoSourcePos;
+  stack_trace_param.token_pos = TokenDescriptor::kNoSource;
   stack_trace_param.type = &Object::dynamic_type();
   stack_trace_param.name = &Symbols::StackTraceParameter();
 
   AddCatchParamsToScope(
       &exception_param, &stack_trace_param, current_block_->scope);
 
   LocalVariable* context_var = try_scope->LocalLookupVariable(
       Symbols::SavedTryContextVar());
   ASSERT(context_var != NULL);
 
   LocalVariable* exception_var = try_scope->LocalLookupVariable(
       Symbols::ExceptionVar());
   if (exception_param.var != NULL) {
     // Generate code to load the exception object (:exception_var) into
     // the exception variable specified in this block.
     ASSERT(exception_var != NULL);
     current_block_->statements->Add(new(Z) StoreLocalNode(
-        Token::kNoSourcePos,
+        TokenDescriptor::kNoSource,
         exception_param.var,
-        new(Z) LoadLocalNode(Token::kNoSourcePos, exception_var)));
+        new(Z) LoadLocalNode(TokenDescriptor::kNoSource, exception_var)));
   }
 
   LocalVariable* stack_trace_var =
       try_scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (stack_trace_param.var != NULL) {
     // A stack trace variable is specified in this block, so generate code
     // to load the stack trace object (:stack_trace_var) into the stack
     // trace variable specified in this block.
     ASSERT(stack_trace_var != NULL);
     current_block_->statements->Add(new(Z) StoreLocalNode(
-        Token::kNoSourcePos,
+        TokenDescriptor::kNoSource,
         stack_trace_param.var,
-        new(Z) LoadLocalNode(Token::kNoSourcePos, stack_trace_var)));
+        new(Z) LoadLocalNode(TokenDescriptor::kNoSource, stack_trace_var)));
   }
   LocalVariable* saved_exception_var = try_scope->LocalLookupVariable(
       Symbols::SavedExceptionVar());
   LocalVariable* saved_stack_trace_var = try_scope->LocalLookupVariable(
       Symbols::SavedStackTraceVar());
   SaveExceptionAndStacktrace(current_block_->statements,
                              exception_var,
                              stack_trace_var,
                              saved_exception_var,
                              saved_stack_trace_var);
 
   // Complete the async future with an error. This catch block executes
   // unconditionally, there is no need to generate a type check for.
   LocalVariable* async_completer = current_block_->scope->LookupVariable(
       Symbols::AsyncCompleter(), false);
   ASSERT(async_completer != NULL);
   ArgumentListNode* completer_args =
-      new (Z) ArgumentListNode(Token::kNoSourcePos);
+      new (Z) ArgumentListNode(TokenDescriptor::kNoSource);
   completer_args->Add(
-      new (Z) LoadLocalNode(Token::kNoSourcePos, exception_param.var));
+      new (Z) LoadLocalNode(TokenDescriptor::kNoSource, exception_param.var));
   completer_args->Add(
-      new (Z) LoadLocalNode(Token::kNoSourcePos, stack_trace_param.var));
+      new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
+                            stack_trace_param.var));
   current_block_->statements->Add(new (Z) InstanceCallNode(
       TokenPos(),
-      new (Z) LoadLocalNode(Token::kNoSourcePos, async_completer),
+      new (Z) LoadLocalNode(TokenDescriptor::kNoSource, async_completer),
       Symbols::CompleterCompleteError(),
       completer_args));
-  ReturnNode* return_node = new (Z) ReturnNode(Token::kNoSourcePos);
+  ReturnNode* return_node = new (Z) ReturnNode(TokenDescriptor::kNoSource);
   // Behavior like a continuation return, i.e,. don't call a completer.
   return_node->set_return_type(ReturnNode::kContinuation);
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   handler_types.SetLength(0);
   handler_types.Add(*exception_param.type);
 
   TryStack* try_statement = PopTry();
   const intptr_t try_index = try_statement->try_index();
 
   CatchClauseNode* catch_clause = new (Z) CatchClauseNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       catch_handler_list,
       Array::ZoneHandle(Z, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
       saved_exception_var,
       saved_stack_trace_var,
       CatchClauseNode::kInvalidTryIndex,
       true);
   AstNode* try_catch_node = new (Z) TryCatchNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       try_block,
       context_var,
       catch_clause,
       NULL,  // No finally clause.
       try_index,
       NULL);  // No rethrow-finally clause.
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
@@ skipping 25 matching lines @@
 }
 
 
 void Parser::AddSyncGenClosureParameters(ParamList* params) {
   // Create the parameter list for the body closure of a sync generator:
   // 1) Implicit closure parameter;
   // 2) Iterator
   // Add implicit closure parameter if not already present.
   if (params->parameters->length() == 0) {
     params->AddFinalParameter(
-        0, &Symbols::ClosureParameter(), &Object::dynamic_type());
+        TokenDescriptor::kMinSource,
+        &Symbols::ClosureParameter(),
+        &Object::dynamic_type());
   }
   ParamDesc iterator_param;
   iterator_param.name = &Symbols::IteratorParameter();
   iterator_param.type = &Object::dynamic_type();
   params->parameters->Add(iterator_param);
   params->num_fixed_parameters++;
 }
 
 
 void Parser::AddAsyncGenClosureParameters(ParamList* params) {
   // Create the parameter list for the body closure of an async generator.
   // The closure has the same parameters as an asynchronous non-generator.
   AddAsyncClosureParameters(params);
 }
 
 
-RawFunction* Parser::OpenSyncGeneratorFunction(intptr_t func_pos) {
+RawFunction* Parser::OpenSyncGeneratorFunction(TokenDescriptor func_pos) {
   Function& body = Function::Handle(Z);
   String& body_closure_name = String::Handle(Z);
   bool is_new_closure = false;
 
   AddContinuationVariables();
 
   // Check whether a function for the body of this generator
   // function has already been created by a previous
   // compilation.
   const Function& found_func = Function::Handle(
@@ skipping 46 matching lines @@
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
 
   // :await_jump_var = -1;
   LocalVariable* jump_var =
       current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
-  LiteralNode* init_value =
-      new(Z) LiteralNode(Token::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
+  LiteralNode* init_value = new(Z) LiteralNode(TokenDescriptor::kNoSource,
+                                               Smi::ZoneHandle(Smi::New(-1)));
   current_block_->statements->Add(
-      new(Z) StoreLocalNode(Token::kNoSourcePos, jump_var, init_value));
+      new(Z) StoreLocalNode(TokenDescriptor::kNoSource, jump_var, init_value));
 
   // return new SyncIterable(body_closure);
   const Class& iterable_class =
       Class::Handle(Z, Library::LookupCoreClass(Symbols::_SyncIterable()));
   ASSERT(!iterable_class.IsNull());
   const Function& iterable_constructor = Function::ZoneHandle(Z,
       iterable_class.LookupConstructorAllowPrivate(
           Symbols::_SyncIterableConstructor()));
   ASSERT(!iterable_constructor.IsNull());
 
   const String& closure_name = String::Handle(Z, closure.name());
   ASSERT(closure_name.IsSymbol());
 
-  ArgumentListNode* arguments = new(Z) ArgumentListNode(Token::kNoSourcePos);
+  ArgumentListNode* arguments =
+      new(Z) ArgumentListNode(TokenDescriptor::kNoSource);
   ClosureNode* closure_obj = new(Z) ClosureNode(
-      Token::kNoSourcePos, closure, NULL, closure_body->scope());
+      TokenDescriptor::kNoSource, closure, NULL, closure_body->scope());
   arguments->Add(closure_obj);
   ConstructorCallNode* new_iterable =
-      new(Z) ConstructorCallNode(Token::kNoSourcePos,
+      new(Z) ConstructorCallNode(TokenDescriptor::kNoSource,
           TypeArguments::ZoneHandle(Z),
           iterable_constructor,
           arguments);
   ReturnNode* return_node =
-      new (Z) ReturnNode(Token::kNoSourcePos, new_iterable);
+      new (Z) ReturnNode(TokenDescriptor::kNoSource, new_iterable);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::AddAsyncClosureParameters(ParamList* params) {
   // Async closures have three optional parameters:
   // * A continuation result.
   // * A continuation error.
   // * A continuation stack trace.
   ASSERT(params->parameters->length() <= 1);
   // Add implicit closure parameter if not yet present.
   if (params->parameters->length() == 0) {
     params->AddFinalParameter(
-        0, &Symbols::ClosureParameter(), &Object::dynamic_type());
+        TokenDescriptor::kMinSource,
+        &Symbols::ClosureParameter(),
+        &Object::dynamic_type());
   }
   ParamDesc result_param;
   result_param.name = &Symbols::AsyncOperationParam();
   result_param.default_value = &Object::null_instance();
   result_param.type = &Object::dynamic_type();
   params->parameters->Add(result_param);
   ParamDesc error_param;
   error_param.name = &Symbols::AsyncOperationErrorParam();
   error_param.default_value = &Object::null_instance();
   error_param.type = &Object::dynamic_type();
   params->parameters->Add(error_param);
   ParamDesc stack_trace_param;
   stack_trace_param.name = &Symbols::AsyncOperationStackTraceParam();
   stack_trace_param.default_value = &Object::null_instance();
   stack_trace_param.type = &Object::dynamic_type();
   params->parameters->Add(stack_trace_param);
   params->has_optional_positional_parameters = true;
   params->num_optional_parameters += 3;
 }
 
 
-RawFunction* Parser::OpenAsyncFunction(intptr_t async_func_pos) {
+RawFunction* Parser::OpenAsyncFunction(TokenDescriptor async_func_pos) {
   TRACE_PARSER("OpenAsyncFunction");
   AddContinuationVariables();
   AddAsyncClosureVariables();
   Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
   // this async function has already been created by a previous
   // compilation of this function.
   const Function& found_func = Function::Handle(
@@ skipping 36 matching lines @@
   async_temp_scope_ = current_block_->scope;
   return closure.raw();
 }
 
 
 void Parser::AddContinuationVariables() {
   // Add to current block's scope:
   //   var :await_jump_var;
   //   var :await_ctx_var;
   LocalVariable* await_jump_var = new (Z) LocalVariable(
-      Token::kNoSourcePos, Symbols::AwaitJumpVar(), Object::dynamic_type());
+      TokenDescriptor::kNoSource,
+      Symbols::AwaitJumpVar(),
+      Object::dynamic_type());
   current_block_->scope->AddVariable(await_jump_var);
   LocalVariable* await_ctx_var = new (Z) LocalVariable(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       Symbols::AwaitContextVar(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(await_ctx_var);
 }
 
 
 void Parser::AddAsyncClosureVariables() {
   // Add to current block's scope:
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   //   var :async_completer;
   LocalVariable* async_op_var = new(Z) LocalVariable(
-      Token::kNoSourcePos, Symbols::AsyncOperation(), Object::dynamic_type());
+      TokenDescriptor::kNoSource,
+      Symbols::AsyncOperation(),
+      Object::dynamic_type());
   current_block_->scope->AddVariable(async_op_var);
   LocalVariable* async_then_callback_var = new(Z) LocalVariable(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       Symbols::AsyncThenCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new(Z) LocalVariable(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       Symbols::AsyncCatchErrorCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_catch_error_callback_var);
   LocalVariable* async_completer = new(Z) LocalVariable(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       Symbols::AsyncCompleter(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_completer);
 }
 
 
 void Parser::AddAsyncGeneratorVariables() {
   // Add to current block's scope:
   //   var :controller;
   // The :controller variable is used by the async generator closure to
   // store the StreamController object to which the yielded expressions
   // are added.
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   // These variables are used to store the async generator closure containing
   // the body of the async* function. They are used by the await operator.
   LocalVariable* controller_var = new(Z) LocalVariable(
-      Token::kNoSourcePos, Symbols::Controller(), Object::dynamic_type());
+      TokenDescriptor::kNoSource,
+      Symbols::Controller(),
+      Object::dynamic_type());
   current_block_->scope->AddVariable(controller_var);
   LocalVariable* async_op_var = new(Z) LocalVariable(
-      Token::kNoSourcePos, Symbols::AsyncOperation(), Object::dynamic_type());
+      TokenDescriptor::kNoSource,
+      Symbols::AsyncOperation(),
+      Object::dynamic_type());
   current_block_->scope->AddVariable(async_op_var);
   LocalVariable* async_then_callback_var = new(Z) LocalVariable(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       Symbols::AsyncThenCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new(Z) LocalVariable(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       Symbols::AsyncCatchErrorCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_catch_error_callback_var);
 }
 
 
-RawFunction* Parser::OpenAsyncGeneratorFunction(intptr_t async_func_pos) {
+RawFunction* Parser::OpenAsyncGeneratorFunction(
+    TokenDescriptor async_func_pos) {
   TRACE_PARSER("OpenAsyncGeneratorFunction");
   AddContinuationVariables();
   AddAsyncGeneratorVariables();
 
   Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
   // this async generator has already been created by a previous
   // compilation of this function.
@@ skipping 90 matching lines @@
       async_lib.LookupClassAllowPrivate(
           Symbols::_AsyncStarStreamController()));
   ASSERT(!controller_class.IsNull());
   const Function& controller_constructor = Function::ZoneHandle(Z,
       controller_class.LookupConstructorAllowPrivate(
           Symbols::_AsyncStarStreamControllerConstructor()));
 
   // :await_jump_var = -1;
   LocalVariable* jump_var =
       current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
-  LiteralNode* init_value =
-      new(Z) LiteralNode(Token::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
+  LiteralNode* init_value = new(Z) LiteralNode(TokenDescriptor::kNoSource,
+                                               Smi::ZoneHandle(Smi::New(-1)));
   current_block_->statements->Add(
-      new(Z) StoreLocalNode(Token::kNoSourcePos, jump_var, init_value));
+      new(Z) StoreLocalNode(TokenDescriptor::kNoSource, jump_var, init_value));
 
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
   LocalVariable* async_op_var =
       current_block_->scope->LookupVariable(Symbols::AsyncOperation(), false);
   ClosureNode* closure_obj = new(Z) ClosureNode(
-      Token::kNoSourcePos, closure_func, NULL, closure_body->scope());
+      TokenDescriptor::kNoSource, closure_func, NULL, closure_body->scope());
   StoreLocalNode* store_async_op = new (Z) StoreLocalNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       async_op_var,
       closure_obj);
 
   current_block_->statements->Add(store_async_op);
 
   // :async_then_callback = _asyncThenWrapperHelper(:async_op)
   const Function& async_then_wrapper_helper = Function::ZoneHandle(
       Z, async_lib.LookupFunctionAllowPrivate(
           Symbols::AsyncThenWrapperHelper()));
   ASSERT(!async_then_wrapper_helper.IsNull());
   ArgumentListNode* async_then_wrapper_helper_args = new (Z) ArgumentListNode(
-      Token::kNoSourcePos);
+      TokenDescriptor::kNoSource);
   async_then_wrapper_helper_args->Add(
-      new (Z) LoadLocalNode(Token::kNoSourcePos, async_op_var));
+      new (Z) LoadLocalNode(TokenDescriptor::kNoSource, async_op_var));
   StaticCallNode* then_wrapper_call = new (Z) StaticCallNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       async_then_wrapper_helper,
       async_then_wrapper_helper_args);
   LocalVariable* async_then_callback_var =
       current_block_->scope->LookupVariable(
           Symbols::AsyncThenCallback(), false);
   StoreLocalNode* store_async_then_callback = new (Z) StoreLocalNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       async_then_callback_var,
       then_wrapper_call);
 
   current_block_->statements->Add(store_async_then_callback);
 
   // :async_catch_error_callback = _asyncErrorWrapperHelper(:async_op)
 
   const Function& async_error_wrapper_helper = Function::ZoneHandle(
       Z, async_lib.LookupFunctionAllowPrivate(
           Symbols::AsyncErrorWrapperHelper()));
   ASSERT(!async_error_wrapper_helper.IsNull());
   ArgumentListNode* async_error_wrapper_helper_args = new (Z) ArgumentListNode(
-      Token::kNoSourcePos);
+      TokenDescriptor::kNoSource);
   async_error_wrapper_helper_args->Add(
-      new (Z) LoadLocalNode(Token::kNoSourcePos, async_op_var));
+      new (Z) LoadLocalNode(TokenDescriptor::kNoSource, async_op_var));
   StaticCallNode* error_wrapper_call = new (Z) StaticCallNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       async_error_wrapper_helper,
       async_error_wrapper_helper_args);
   LocalVariable* async_catch_error_callback_var =
       current_block_->scope->LookupVariable(
           Symbols::AsyncCatchErrorCallback(), false);
   StoreLocalNode* store_async_catch_error_callback = new (Z) StoreLocalNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       async_catch_error_callback_var,
       error_wrapper_call);
 
   current_block_->statements->Add(store_async_catch_error_callback);
 
   // :controller = new _AsyncStarStreamController(body_closure);
-  ArgumentListNode* arguments = new(Z) ArgumentListNode(Token::kNoSourcePos);
-  arguments->Add(new (Z) LoadLocalNode(Token::kNoSourcePos, async_op_var));
+  ArgumentListNode* arguments =
+      new(Z) ArgumentListNode(TokenDescriptor::kNoSource);
+  arguments->Add(
+      new (Z) LoadLocalNode(TokenDescriptor::kNoSource, async_op_var));
   ConstructorCallNode* controller_constructor_call =
-      new(Z) ConstructorCallNode(Token::kNoSourcePos,
+      new(Z) ConstructorCallNode(TokenDescriptor::kNoSource,
                                  TypeArguments::ZoneHandle(Z),
                                  controller_constructor,
                                  arguments);
   LocalVariable* controller_var =
      current_block_->scope->LookupVariable(Symbols::Controller(), false);
   StoreLocalNode* store_controller =
-      new(Z) StoreLocalNode(Token::kNoSourcePos,
+      new(Z) StoreLocalNode(TokenDescriptor::kNoSource,
                             controller_var,
                             controller_constructor_call);
   current_block_->statements->Add(store_controller);
 
   // return :controller.stream;
-  ReturnNode* return_node = new(Z) ReturnNode(Token::kNoSourcePos,
-      new(Z) InstanceGetterNode(Token::kNoSourcePos,
-          new(Z) LoadLocalNode(Token::kNoSourcePos,
+  ReturnNode* return_node = new(Z) ReturnNode(TokenDescriptor::kNoSource,
+      new(Z) InstanceGetterNode(TokenDescriptor::kNoSource,
+          new(Z) LoadLocalNode(TokenDescriptor::kNoSource,
               controller_var),
               Symbols::Stream()));
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::OpenAsyncGeneratorClosure() {
   async_temp_scope_ = current_block_->scope;
   OpenAsyncTryBlock();
 }
 
 
 SequenceNode* Parser::CloseAsyncGeneratorClosure(SequenceNode* body) {
   // We need a temporary expression to store intermediate return values.
   parsed_function()->EnsureExpressionTemp();
 
   SequenceNode* new_body = CloseAsyncGeneratorTryBlock(body);
   ASSERT(new_body != NULL);
   ASSERT(new_body->scope() != NULL);
   return new_body;
 }
 
 
 // Add a return node to the sequence if necessary.
-void Parser::EnsureHasReturnStatement(SequenceNode* seq, intptr_t return_pos) {
+void Parser::EnsureHasReturnStatement(SequenceNode* seq,
+                                      TokenDescriptor return_pos) {
   if ((seq->length() == 0) ||
       !seq->NodeAt(seq->length() - 1)->IsReturnNode()) {
     const Function& func = innermost_function();
     // The implicit return value of synchronous generator closures is false,
     // to indicate that there are no more elements in the iterable.
     // In other cases the implicit return value is null.
     AstNode* return_value = func.IsSyncGenClosure()
         ? new LiteralNode(return_pos, Bool::False())
         : new LiteralNode(return_pos, Instance::ZoneHandle());
     seq->Add(new ReturnNode(return_pos, return_value));
@@ skipping 47 matching lines @@
   const Class& completer =
       Class::ZoneHandle(Z, I->object_store()->completer_class());
   ASSERT(!completer.IsNull());
   const Function& completer_constructor = Function::ZoneHandle(Z,
       completer.LookupFunction(Symbols::CompleterSyncConstructor()));
   ASSERT(!completer_constructor.IsNull());
 
   LocalVariable* async_completer = current_block_->scope->LookupVariable(
       Symbols::AsyncCompleter(), false);
 
-  const intptr_t token_pos = ST(closure_body->token_pos());
+  const TokenDescriptor token_pos = ST(closure_body->token_pos());
   // Add to AST:
   //   :async_completer = new Completer.sync();
   ArgumentListNode* empty_args =
       new (Z) ArgumentListNode(token_pos);
   ConstructorCallNode* completer_constructor_node = new (Z) ConstructorCallNode(
       token_pos,
       TypeArguments::ZoneHandle(Z),
       completer_constructor,
       empty_args);
   StoreLocalNode* store_completer = new (Z) StoreLocalNode(
@@ skipping 225 matching lines @@
 
 void Parser::CaptureInstantiator() {
   ASSERT(current_block_->scope->function_level() > 0);
   const String* variable_name = current_function().IsInFactoryScope() ?
       &Symbols::TypeArgumentsParameter() : &Symbols::This();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
-AstNode* Parser::LoadReceiver(intptr_t token_pos) {
+AstNode* Parser::LoadReceiver(TokenDescriptor token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ReportError(token_pos, "illegal implicit access to receiver 'this'");
   }
   return new(Z) LoadLocalNode(TokenPos(), receiver);
 }
 
 
-InstanceGetterNode* Parser::CallGetter(intptr_t token_pos,
+InstanceGetterNode* Parser::CallGetter(TokenDescriptor token_pos,
                                        AstNode* object,
                                        const String& name) {
   return new(Z) InstanceGetterNode(token_pos, object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
                                           bool is_const,
                                           SequenceNode** await_preamble) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
-  const intptr_t ident_pos = TokenPos();
+  const TokenDescriptor ident_pos = TokenPos();
   const String& ident = *CurrentLiteral();
   ConsumeToken();  // Variable identifier.
-  const intptr_t assign_pos = TokenPos();
+  const TokenDescriptor assign_pos = TokenPos();
   AstNode* initialization = NULL;
   LocalVariable* variable = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     ConsumeToken();
     AstNode* expr = ParseAwaitableExpr(
         is_const, kConsumeCascades, await_preamble);
-    const intptr_t expr_end_pos = TokenPos();
+    const TokenDescriptor expr_end_pos = TokenPos();
     variable = new(Z) LocalVariable(
         expr_end_pos, ident, type);
     initialization = new(Z) StoreLocalNode(
         assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ReportError(ident_pos,
                 "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
     variable = new(Z) LocalVariable(
         assign_pos, ident, type);
     AstNode* null_expr = new(Z) LiteralNode(ident_pos, Object::null_instance());
     initialization = new(Z) StoreLocalNode(
         ident_pos, variable, null_expr);
   }
 
   ASSERT(current_block_ != NULL);
-  const intptr_t previous_pos =
+  const TokenDescriptor previous_pos =
       current_block_->scope->PreviousReferencePos(ident);
-  if (previous_pos >= 0) {
+  if (previous_pos.IsReal()) {
     ASSERT(!script_.IsNull());
     if (previous_pos > ident_pos) {
       ReportError(ident_pos,
                   "initializer of '%s' may not refer to itself",
                   ident.ToCString());
 
     } else {
       intptr_t line_number;
       script_.GetTokenLocation(previous_pos, &line_number, NULL);
       ReportError(ident_pos,
@@ skipping 106 matching lines @@
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   AbstractType& result_type = AbstractType::Handle(Z);
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
 
-  const intptr_t function_pos = TokenPos();
-  intptr_t metadata_pos = Token::kNoSourcePos;
+  const TokenDescriptor function_pos = TokenPos();
+  TokenDescriptor metadata_pos = TokenDescriptor::kNoSource;
   if (is_literal) {
     ASSERT(CurrentToken() == Token::kLPAREN);
     function_name = &Symbols::AnonymousClosure();
   } else {
     metadata_pos = SkipMetadata();
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else if ((CurrentToken() == Token::kIDENT) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(ClassFinalizer::kCanonicalize);
     }
-    const intptr_t name_pos = TokenPos();
+    const TokenDescriptor name_pos = TokenPos();
     variable_name = ExpectIdentifier("function name expected");
     function_name = variable_name;
 
     // Check that the function name has not been referenced
     // before this declaration.
     ASSERT(current_block_ != NULL);
-    const intptr_t previous_pos =
+    const TokenDescriptor previous_pos =
         current_block_->scope->PreviousReferencePos(*function_name);
-    if (previous_pos >= 0) {
+    if (previous_pos.IsReal()) {
       ASSERT(!script_.IsNull());
       intptr_t line_number;
       script_.GetTokenLocation(previous_pos, &line_number, NULL);
       ReportError(name_pos,
                   "identifier '%s' previously used in line %" Pd "",
                   function_name->ToCString(),
                   line_number);
     }
   }
   CheckToken(Token::kLPAREN);
 
   // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
   // and register it in the current class.
   // Note that we cannot share the same closure function between the closurized
   // and non-closurized versions of the same parent function.
   Function& function = Function::ZoneHandle(Z);
   // TODO(hausner): There could be two different closures at the given
   // function_pos, one enclosed in a closurized function and one enclosed in the
   // non-closurized version of this same function.
   function = I->LookupClosureFunction(innermost_function(), function_pos);
   if (function.IsNull()) {
     // The function will be registered in the lookup table by the
     // EffectGraphVisitor::VisitClosureNode when the newly allocated closure
     // function has been properly setup.
     function = Function::NewClosureFunction(*function_name,
                                             innermost_function(),
                                             function_pos);
     function.set_result_type(result_type);
-    if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
+    if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
       library_.AddFunctionMetadata(function, metadata_pos);
     }
   }
 
   // The function type needs to be finalized at compile time, since the closure
   // may be type checked at run time when assigned to a function variable,
   // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
   FunctionType& function_type = FunctionType::ZoneHandle(Z);
@@ skipping 255 matching lines @@
 //   | const [type] ident (';' | '=' | ',')
 //   | type ident (';' | '=' | ',')
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) ||
       (CurrentToken() == Token::kFINAL)) {
     return true;
   }
   // Skip optional metadata.
   if (CurrentToken() == Token::kAT) {
-    const intptr_t saved_pos = TokenPos();
+    const TokenDescriptor saved_pos = TokenPos();
     SkipMetadata();
     const bool is_var_decl = IsVariableDeclaration();
     SetPosition(saved_pos);
     return is_var_decl;
   }
   if ((CurrentToken() != Token::kIDENT) && (CurrentToken() != Token::kCONST)) {
     // Not a legal type identifier or const keyword or metadata.
     return false;
   }
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   bool is_var_decl = false;
   bool have_type = false;
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
     have_type = true;  // Type is dynamic.
   }
   if (IsIdentifier()) {  // Type or variable name.
     Token::Kind follower = LookaheadToken(1);
     if ((follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         Token::IsIdentifier(follower)) {  // Variable name following a type.
       // We see the beginning of something that could be a type.
-      const intptr_t type_pos = TokenPos();
+      const TokenDescriptor type_pos = TokenPos();
       if (TryParseOptionalType()) {
         have_type = true;
       } else {
         SetPosition(type_pos);
       }
     }
     if (have_type && IsIdentifier()) {
       ConsumeToken();
       if ((CurrentToken() == Token::kSEMICOLON) ||
           (CurrentToken() == Token::kCOMMA) ||
           (CurrentToken() == Token::kASSIGN)) {
         is_var_decl = true;
       }
     }
   }
   SetPosition(saved_pos);
   return is_var_decl;
 }
 
 
 // Look ahead to detect whether the next tokens should be parsed as
 // a function declaration. Token position remains unchanged.
 bool Parser::IsFunctionDeclaration() {
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   bool is_external = false;
   SkipMetadata();
   if (is_top_level_) {
     if (is_patch_source() &&
         (CurrentToken() == Token::kIDENT) &&
         CurrentLiteral()->Equals("patch") &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       // Skip over 'patch' for top-level function declarations in patch sources.
       ConsumeToken();
     } else if (CurrentToken() == Token::kEXTERNAL) {
@@ skipping 27 matching lines @@
       SetPosition(saved_pos);
       return true;
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsTopLevelAccessor() {
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   if (is_patch_source() && IsSymbol(Symbols::Patch())) {
     ConsumeToken();
   } else if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
   }
   if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
     SetPosition(saved_pos);
     return true;
   }
   if (TryParseReturnType()) {
     if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
       if (Token::IsIdentifier(LookaheadToken(1))) {  // Accessor name.
         SetPosition(saved_pos);
         return true;
       }
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsFunctionLiteral() {
   if (CurrentToken() != Token::kLPAREN || !allow_function_literals_) {
     return false;
   }
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   bool is_function_literal = false;
   SkipToMatchingParenthesis();
   ParseFunctionModifier();
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     is_function_literal = true;
   }
   SetPosition(saved_pos);
   return is_function_literal;
 }
 
 
 // Current token position is the token after the opening ( of the for
 // statement. Returns true if we recognize a for ( .. in expr)
 // statement.
 bool Parser::IsForInStatement() {
-  const intptr_t saved_pos = TokenPos();
+  const TokenDescriptor saved_pos = TokenPos();
   bool result = false;
   // Allow const modifier as well when recognizing a for-in statement
   // pattern. We will get an error later if the loop variable is
   // declared with const.
   if (CurrentToken() == Token::kVAR ||
       CurrentToken() == Token::kFINAL ||
       CurrentToken() == Token::kCONST) {
     ConsumeToken();
   }
   if (IsIdentifier()) {
@@ skipping 31 matching lines @@
   return false;
 }
 
 
 void Parser::ParseStatementSequence() {
   TRACE_PARSER("ParseStatementSequence");
   const bool dead_code_allowed = true;
   bool abrupt_completing_seen = false;
   RecursionChecker rc(this);
   while (CurrentToken() != Token::kRBRACE) {
-    const intptr_t statement_pos = TokenPos();
+    const TokenDescriptor statement_pos = TokenPos();
     AstNode* statement = ParseStatement();
     // Do not add statements with no effect (e.g., LoadLocalNode).
     if ((statement != NULL) && statement->IsLoadLocalNode()) {
       // Skip load local.
       continue;
     }
     if (statement != NULL) {
       if (!dead_code_allowed && abrupt_completing_seen) {
         ReportError(statement_pos,
                     "dead code after abrupt completing statement");
@@ skipping 31 matching lines @@
     }
   }
   SequenceNode* sequence = CloseBlock();
   return sequence;
 }
 
 
 AstNode* Parser::ParseIfStatement(String* label_name) {
   TRACE_PARSER("ParseIfStatement");
   ASSERT(CurrentToken() == Token::kIF);
-  const intptr_t if_pos = TokenPos();
+  const TokenDescriptor if_pos = TokenPos();
   SourceLabel* label = NULL;
   if (label_name != NULL) {
     label = SourceLabel::New(if_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(label);
   }
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
@@ skipping 34 matching lines @@
 // of a LiteralNode.
 RawClass* Parser::CheckCaseExpressions(
     const GrowableArray<LiteralNode*>& values) {
   const intptr_t num_expressions = values.length();
   if (num_expressions == 0) {
     return Object::dynamic_class();
   }
   const Instance& first_value = values[0]->literal();
   for (intptr_t i = 0; i < num_expressions; i++) {
     const Instance& val = values[i]->literal();
-    const intptr_t val_pos = values[i]->token_pos();
+    const TokenDescriptor val_pos = values[i]->token_pos();
     if (first_value.IsInteger()) {
       if (!val.IsInteger()) {
         ReportError(val_pos, "expected case expression of type int");
       }
       continue;
     }
     if (first_value.IsString()) {
       if (!val.IsString()) {
         ReportError(val_pos, "expected case expression of type String");
       }
@@ skipping 27 matching lines @@
   }
   return first_value.clazz();
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   GrowableArray<LiteralNode*>* case_expr_values,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseClause");
   bool default_seen = false;
-  const intptr_t case_pos = TokenPos();
+  const TokenDescriptor case_pos = TokenPos();
   // The case expressions node sequence does not own the enclosing scope.
   SequenceNode* case_expressions = new(Z) SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
         ReportError("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
-      const intptr_t expr_pos = TokenPos();
+      const TokenDescriptor expr_pos = TokenPos();
       AstNode* expr = ParseExpr(kRequireConst, kConsumeCascades);
       ASSERT(expr->IsLiteralNode());
       case_expr_values->Add(expr->AsLiteralNode());
 
       AstNode* switch_expr_load = new(Z) LoadLocalNode(
           case_pos, switch_expr_value);
       AstNode* case_comparison = new(Z) ComparisonNode(
           expr_pos, Token::kEQ, expr, switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
@@ skipping 22 matching lines @@
     if (next_token == Token::kRBRACE) {
       // End of switch statement.
       break;
     }
     if ((next_token == Token::kCASE) || (next_token == Token::kDEFAULT)) {
       // End of this case clause. If there is a possible fall-through to
       // the next case clause, throw an implicit FallThroughError.
       if (!abrupt_completing_seen) {
         ArgumentListNode* arguments = new(Z) ArgumentListNode(TokenPos());
         arguments->Add(new(Z) LiteralNode(
-            TokenPos(), Integer::ZoneHandle(Z, Integer::New(TokenPos()))));
+            TokenPos(),
+            Integer::ZoneHandle(Z, Integer::New(TokenPos().value()))));
         current_block_->statements->Add(
             MakeStaticCall(Symbols::FallThroughError(),
                            Library::PrivateCoreLibName(Symbols::ThrowNew()),
                            arguments));
       }
       break;
     }
     // The next statement still belongs to this case.
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
   SequenceNode* statements = CloseBlock();
   return new(Z) CaseNode(case_pos, case_label,
       case_expressions, default_seen, switch_expr_value, statements);
 }
 
 
 AstNode* Parser::ParseSwitchStatement(String* label_name) {
   TRACE_PARSER("ParseSwitchStatement");
   ASSERT(CurrentToken() == Token::kSWITCH);
-  const intptr_t switch_pos = TokenPos();
+  const TokenDescriptor switch_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
-  const intptr_t expr_pos = TokenPos();
+  const TokenDescriptor expr_pos = TokenPos();
   AstNode* switch_expr = ParseAwaitableExpr(
       kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable. The type of the
   // variable is set to dynamic. It will later be patched to match the
   // type of the case clause expressions. Therefore, we have to allocate
@@ skipping 13 matching lines @@
 
   // Parse case clauses
   bool default_seen = false;
   GrowableArray<LiteralNode*> case_expr_values;
   while (true) {
     // Check for statement label
     SourceLabel* case_label = NULL;
     if (IsIdentifier() && LookaheadToken(1) == Token::kCOLON) {
       // Case statements start with a label.
       String* label_name = CurrentLiteral();
-      const intptr_t label_pos = TokenPos();
+      const TokenDescriptor label_pos = TokenPos();
       ConsumeToken();  // Consume label identifier.
       ConsumeToken();  // Consume colon.
       case_label = current_block_->scope->LocalLookupLabel(*label_name);
       if (case_label == NULL) {
         // Label does not exist yet. Add it to scope of switch statement.
         case_label = new(Z) SourceLabel(
             label_pos, *label_name, SourceLabel::kCase);
         current_block_->scope->AddLabel(case_label);
       } else if (case_label->kind() == SourceLabel::kForward) {
         // We have seen a 'continue' with this label name. Resolve
@@ skipping 39 matching lines @@
   }
 
   SequenceNode* switch_body = CloseBlock();
   ExpectToken(Token::kRBRACE);
   return new(Z) SwitchNode(switch_pos, label, switch_body);
 }
 
 
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
-  const intptr_t while_pos = TokenPos();
+  const TokenDescriptor while_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   SequenceNode* await_preamble = NULL;
   AstNode* cond_expr = ParseAwaitableExpr(
       kAllowConst, kConsumeCascades, &await_preamble);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
   WhileNode* while_node = new (Z) WhileNode(while_pos,
                                             label,
                                             cond_expr,
                                             await_preamble,
                                             while_body);
   return while_node;
 }
 
 
 AstNode* Parser::ParseDoWhileStatement(String* label_name) {
   TRACE_PARSER("ParseDoWhileStatement");
-  const intptr_t do_pos = TokenPos();
+  const TokenDescriptor do_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
   ConsumeToken();
   const bool parsing_loop_body =  true;
   SequenceNode* dowhile_body = ParseNestedStatement(parsing_loop_body, label);
   ExpectToken(Token::kWHILE);
   ExpectToken(Token::kLPAREN);
   SequenceNode* await_preamble = NULL;
-  intptr_t expr_pos = TokenPos();
+  TokenDescriptor expr_pos = TokenPos();
   AstNode* cond_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, &await_preamble);
   if (await_preamble != NULL) {
     // Prepend the preamble to the condition.
     LetNode* await_cond = new(Z) LetNode(expr_pos);
     await_cond->AddNode(await_preamble);
     await_cond->AddNode(cond_expr);
     cond_expr = await_cond;
   }
   ExpectToken(Token::kRPAREN);
@@ skipping 80 matching lines @@
 }
 
 
 // Build an AST node for static call to Dart function print(str).
 // Used during debugging to insert print in generated dart code.
 AstNode* Parser::DartPrint(const char* str) {
   const Library& lib = Library::Handle(Library::CoreLibrary());
   const Function& print_fn = Function::ZoneHandle(
       Z, lib.LookupFunctionAllowPrivate(Symbols::print()));
   ASSERT(!print_fn.IsNull());
-  ArgumentListNode* one_arg = new(Z) ArgumentListNode(Token::kNoSourcePos);
+  ArgumentListNode* one_arg =
+      new(Z) ArgumentListNode(TokenDescriptor::kNoSource);
   String& msg = String::ZoneHandle(Symbols::NewFormatted("%s", str));
-  one_arg->Add(new(Z) LiteralNode(Token::kNoSourcePos, msg));
+  one_arg->Add(new(Z) LiteralNode(TokenDescriptor::kNoSource, msg));
   AstNode* print_call =
-      new(Z) StaticCallNode(Token::kNoSourcePos, print_fn, one_arg);
+      new(Z) StaticCallNode(TokenDescriptor::kNoSource, print_fn, one_arg);
   return print_call;
 }
 
 
 AstNode* Parser::ParseAwaitForStatement(String* label_name) {
   TRACE_PARSER("ParseAwaitForStatement");
   ASSERT(IsAwaitKeyword());
-  const intptr_t await_for_pos = TokenPos();
+  const TokenDescriptor await_for_pos = TokenPos();
   ConsumeToken();  // await.
   ASSERT(CurrentToken() == Token::kFOR);
   ConsumeToken();  // for.
   ExpectToken(Token::kLPAREN);
 
   if (!innermost_function().IsAsyncFunction() &&
       !innermost_function().IsAsyncClosure() &&
       !innermost_function().IsAsyncGenerator() &&
       !innermost_function().IsAsyncGenClosure()) {
     ReportError(await_for_pos,
                 "await for loop is only allowed in an asynchronous function");
   }
 
   // Parse loop variable.
   bool loop_var_is_final = (CurrentToken() == Token::kFINAL);
   if (CurrentToken() == Token::kCONST) {
     ReportError("Loop variable cannot be 'const'");
   }
   bool new_loop_var = false;
   AbstractType& loop_var_type =  AbstractType::ZoneHandle(Z);
   if (LookaheadToken(1) != Token::kIN) {
     // Declaration of a new loop variable.
     // Delay creation of the local variable until we know its actual
     // position, which is inside the loop body.
     new_loop_var = true;
     loop_var_type = ParseConstFinalVarOrType(
        I->flags().type_checks() ? ClassFinalizer::kCanonicalize :
                                   ClassFinalizer::kIgnore);
   }
-  intptr_t loop_var_pos = TokenPos();
+  TokenDescriptor loop_var_pos = TokenPos();
   const String* loop_var_name = ExpectIdentifier("variable name expected");
 
   // Parse stream expression.
   ExpectToken(Token::kIN);
-  const intptr_t stream_expr_pos = TokenPos();
+  const TokenDescriptor stream_expr_pos = TokenPos();
   AstNode* stream_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
 
   // Open a block for the iterator variable and the try-finally
   // statement that contains the loop.
   OpenBlock();
   const Block* loop_block = current_block_;
 
   // Build creation of implicit StreamIterator.
@@ skipping 76 matching lines @@
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
   // loop body.
   OpenLoopBlock();
 
   SourceLabel* label =
       SourceLabel::New(await_for_pos, label_name, SourceLabel::kFor);
   current_block_->scope->AddLabel(label);
-  const intptr_t loop_var_assignment_pos = TokenPos();
+  const TokenDescriptor loop_var_assignment_pos = TokenPos();
 
   AstNode* iterator_current = new(Z) InstanceGetterNode(
       loop_var_assignment_pos,
       new(Z) LoadLocalNode(loop_var_assignment_pos, iterator_var),
       Symbols::Current());
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (new_loop_var) {
     // The for loop variable is new for each iteration.
@@ skipping 44 matching lines @@
   current_block_->statements->Add(while_node);
   SequenceNode* try_block = CloseBlock();
 
   // Create an empty "catch all" block that rethrows the current
   // exception and stacktrace.
   try_stack_->enter_catch();
   SequenceNode* catch_block = new(Z) SequenceNode(await_for_pos, NULL);
 
   if (outer_saved_try_ctx != NULL) {
     catch_block->Add(new (Z) StoreLocalNode(
-        Token::kNoSourcePos,
+        TokenDescriptor::kNoSource,
         outer_saved_try_ctx,
-        new (Z) LoadLocalNode(Token::kNoSourcePos,
+        new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
                               outer_async_saved_try_ctx)));
   }
 
   // We don't need to copy the current exception and stack trace variables
   // into :saved_exception_var and :saved_stack_trace_var here because there
   // is no code in the catch clause that could suspend the function.
 
   // Rethrow the exception.
   catch_block->Add(new(Z) ThrowNode(
       await_for_pos,
@@ skipping 11 matching lines @@
 
   // Inline the finally block to the exit points in the try block.
   intptr_t node_index = 0;
   SequenceNode* finally_clause = NULL;
   if (try_stack_ != NULL) {
     try_stack_->enter_finally();
   }
   do {
     OpenBlock();
     ArgumentListNode* no_args =
-        new(Z) ArgumentListNode(Token::kNoSourcePos);
+        new(Z) ArgumentListNode(TokenDescriptor::kNoSource);
     current_block_->statements->Add(
-        new(Z) InstanceCallNode(Token::kNoSourcePos,
-            new(Z) LoadLocalNode(Token::kNoSourcePos, iterator_var),
+        new(Z) InstanceCallNode(TokenDescriptor::kNoSource,
+            new(Z) LoadLocalNode(TokenDescriptor::kNoSource, iterator_var),
             Symbols::Cancel(),
             no_args));
     finally_clause = CloseBlock();
     AstNode* node_to_inline = try_statement->GetNodeToInlineFinally(node_index);
     if (node_to_inline != NULL) {
       InlinedFinallyNode* node =
-          new(Z) InlinedFinallyNode(Token::kNoSourcePos,
+          new(Z) InlinedFinallyNode(TokenDescriptor::kNoSource,
                                     finally_clause,
                                     context_var,
                                     outer_try_index);
       finally_clause = NULL;
       AddFinallyClauseToNode(true, node_to_inline, node);
       node_index++;
     }
   } while (finally_clause == NULL);
 
   if (try_stack_ != NULL) {
@@ skipping 27 matching lines @@
                          try_index,
                          finally_clause);
 
   ASSERT(current_block_ == loop_block);
   loop_block->statements->Add(try_catch_node);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
 
-AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
+AstNode* Parser::ParseForInStatement(TokenDescriptor forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool loop_var_is_final = (CurrentToken() == Token::kFINAL);
   if (CurrentToken() == Token::kCONST) {
     ReportError("Loop variable cannot be 'const'");
   }
   const String* loop_var_name = NULL;
-  intptr_t loop_var_pos = Token::kNoSourcePos;
+  TokenDescriptor loop_var_pos = TokenDescriptor::kNoSource;
   bool new_loop_var = false;
   AbstractType& loop_var_type =  AbstractType::ZoneHandle(Z);
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     // Delay creation of the local variable until we know its actual
     // position, which is inside the loop body.
     new_loop_var = true;
     loop_var_type = ParseConstFinalVarOrType(
         I->flags().type_checks() ? ClassFinalizer::kCanonicalize :
                                    ClassFinalizer::kIgnore);
     loop_var_name = ExpectIdentifier("variable name expected");
   }
   ExpectToken(Token::kIN);
-  const intptr_t collection_pos = TokenPos();
+  const TokenDescriptor collection_pos = TokenPos();
   AstNode* collection_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
@@ skipping 18 matching lines @@
       new(Z) LoadLocalNode(collection_pos, iterator_var),
       Symbols::MoveNext(),
       no_args);
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
   // loop body.
   OpenLoopBlock();
   current_block_->scope->AddLabel(label);
-  const intptr_t loop_var_assignment_pos = TokenPos();
+  const TokenDescriptor loop_var_assignment_pos = TokenPos();
 
   AstNode* iterator_current = new(Z) InstanceGetterNode(
       loop_var_assignment_pos,
       new(Z) LoadLocalNode(loop_var_assignment_pos, iterator_var),
       Symbols::Current());
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (new_loop_var) {
     // The for loop variable is new for each iteration.
@@ skipping 37 matching lines @@
   AstNode* while_statement = new(Z) WhileNode(
       forin_pos, label, iterator_moveNext, NULL, for_loop_statement);
   current_block_->statements->Add(while_statement);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
 
 AstNode* Parser::ParseForStatement(String* label_name) {
   TRACE_PARSER("ParseForStatement");
-  const intptr_t for_pos = TokenPos();
+  const TokenDescriptor for_pos = TokenPos();
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   SourceLabel* label = SourceLabel::New(for_pos, label_name, SourceLabel::kFor);
   if (IsForInStatement()) {
     return ParseForInStatement(for_pos, label);
   }
   // Open a block that contains the loop variable. Make it a loop block so
   // that we allocate a new context if the loop variable is captured.
   OpenLoopBlock();
   AstNode* initializer = NULL;
-  const intptr_t init_pos = TokenPos();
+  const TokenDescriptor init_pos = TokenPos();
   LocalScope* init_scope = current_block_->scope;
   if (CurrentToken() != Token::kSEMICOLON) {
     if (IsVariableDeclaration()) {
       initializer = ParseVariableDeclarationList();
     } else {
       initializer = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     }
   }
   ExpectSemicolon();
   AstNode* condition = NULL;
   SequenceNode* condition_preamble = NULL;
   if (CurrentToken() != Token::kSEMICOLON) {
     condition = ParseAwaitableExpr(
         kAllowConst, kConsumeCascades, &condition_preamble);
   }
   ExpectSemicolon();
   AstNode* increment = NULL;
-  const intptr_t incr_pos = TokenPos();
+  const TokenDescriptor incr_pos = TokenPos();
   if (CurrentToken() != Token::kRPAREN) {
     increment = ParseAwaitableExprList();
   }
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* body = ParseNestedStatement(parsing_loop_body, label);
 
   // Check whether any of the variables in the initializer part of
   // the for statement are captured by a closure. If so, we insert a
   // node that creates a new Context for the loop variable before
@@ skipping 32 matching lines @@
   const Function& func = Function::ZoneHandle(Z,
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names()));
   ASSERT(!func.IsNull());
   return new(Z) StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
-AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
+AstNode* Parser::MakeAssertCall(TokenDescriptor begin, TokenDescriptor end) {
   ArgumentListNode* arguments = new(Z) ArgumentListNode(begin);
   arguments->Add(new(Z) LiteralNode(begin,
-      Integer::ZoneHandle(Z, Integer::New(begin))));
+      Integer::ZoneHandle(Z, Integer::New(begin.value()))));
   arguments->Add(new(Z) LiteralNode(end,
-      Integer::ZoneHandle(Z, Integer::New(end))));
+      Integer::ZoneHandle(Z, Integer::New(end.value()))));
   return MakeStaticCall(Symbols::AssertionError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::InsertClosureCallNodes(AstNode* condition) {
   if (condition->IsClosureNode() ||
       (condition->IsStoreLocalNode() &&
        condition->AsStoreLocalNode()->value()->IsClosureNode())) {
     // Function literal in assert implies a call.
-    const intptr_t pos = condition->token_pos();
+    const TokenDescriptor pos = condition->token_pos();
     condition = BuildClosureCall(pos,
                                  condition,
                                  new(Z) ArgumentListNode(pos));
   } else if (condition->IsConditionalExprNode()) {
     ConditionalExprNode* cond_expr = condition->AsConditionalExprNode();
     cond_expr->set_true_expr(InsertClosureCallNodes(cond_expr->true_expr()));
     cond_expr->set_false_expr(InsertClosureCallNodes(cond_expr->false_expr()));
   }
   return condition;
 }
 
 
 AstNode* Parser::ParseAssertStatement() {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
-  const intptr_t condition_pos = TokenPos();
+  const TokenDescriptor condition_pos = TokenPos();
   if (!I->flags().asserts()) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
-  const intptr_t condition_end = TokenPos();
+  const TokenDescriptor condition_end = TokenPos();
   ExpectToken(Token::kRPAREN);
   condition = InsertClosureCallNodes(condition);
   condition = new(Z) UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new(Z) IfNode(
       condition_pos,
       condition,
       NodeAsSequenceNode(condition_pos, assert_throw, NULL),
       NULL);
 }
@@ skipping 43 matching lines @@
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator() ||
          innermost_function().IsAsyncGenClosure() ||
          innermost_function().IsAsyncGenerator());
 
   ASSERT(saved_exception_var != NULL);
   ASSERT(exception_var != NULL);
   statements->Add(new(Z) StoreLocalNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       saved_exception_var,
-      new(Z) LoadLocalNode(Token::kNoSourcePos, exception_var)));
+      new(Z) LoadLocalNode(TokenDescriptor::kNoSource, exception_var)));
 
   ASSERT(saved_stack_trace_var != NULL);
   ASSERT(stack_trace_var != NULL);
   statements->Add(new(Z) StoreLocalNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       saved_stack_trace_var,
-      new(Z) LoadLocalNode(Token::kNoSourcePos, stack_trace_var)));
+      new(Z) LoadLocalNode(TokenDescriptor::kNoSource, stack_trace_var)));
 }
 
 
 SequenceNode* Parser::EnsureFinallyClause(
     bool parse,
     bool is_async,
     LocalVariable* exception_var,
     LocalVariable* stack_trace_var,
     LocalVariable* rethrow_exception_var,
     LocalVariable* rethrow_stack_trace_var) {
@@ skipping 14 matching lines @@
     if (try_stack_ != NULL) {
       LocalScope* scope = try_stack_->try_block()->scope;
       if (scope->function_level() == current_block_->scope->function_level()) {
         LocalVariable* saved_try_ctx =
             LookupSavedTryContextVar(scope->parent());
         LocalVariable* async_saved_try_ctx =
             LookupAsyncSavedTryContextVar(async_temp_scope_,
                                           try_stack_->try_index());
         current_block_->statements->Add(
             new (Z) StoreLocalNode(
-                Token::kNoSourcePos,
+                TokenDescriptor::kNoSource,
                 saved_try_ctx,
-                new (Z) LoadLocalNode(Token::kNoSourcePos,
+                new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
                                       async_saved_try_ctx)));
       }
     }
     // We need to save the exception variables as in catch clauses, whether
     // there is an outer try or not. Note that this is only necessary if the
     // finally clause contains an await or yield.
     // TODO(hausner): Optimize.
     SaveExceptionAndStacktrace(current_block_->statements,
                                exception_var,
                                stack_trace_var,
@@ skipping 63 matching lines @@
     return_node->AddInlinedFinallyNode(finally_clause);
     return;
   }
   JumpNode* jump_node = node->AsJumpNode();
   ASSERT(jump_node != NULL);
   jump_node->AddInlinedFinallyNode(finally_clause);
 }
 
 
 SequenceNode* Parser::ParseCatchClauses(
-    intptr_t handler_pos,
+    TokenDescriptor handler_pos,
     bool is_async,
     LocalVariable* exception_var,
     LocalVariable* stack_trace_var,
     LocalVariable* rethrow_exception_var,
     LocalVariable* rethrow_stack_trace_var,
     const GrowableObjectArray& handler_types,
     bool* needs_stack_trace) {
   // All catch blocks are merged into an if-then-else sequence of the
   // different types specified using the 'is' operator.  While parsing
   // record the type tests (either a ComparisonNode or else the LiteralNode
   // true for a generic catch) and the catch bodies in a pair of parallel
   // lists.  Afterward, construct the nested if-then-else.
   bool generic_catch_seen = false;
   GrowableArray<AstNode*> type_tests;
   GrowableArray<SequenceNode*> catch_blocks;
   while ((CurrentToken() == Token::kCATCH) || IsSymbol(Symbols::On())) {
     // Open a block that contains the if or an unconditional body.  It's
     // closed in the loop that builds the if-then-else nest.
     OpenBlock();
-    const intptr_t catch_pos = TokenPos();
+    const TokenDescriptor catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     if (IsSymbol(Symbols::On())) {
       ConsumeToken();
       exception_param.type = &AbstractType::ZoneHandle(Z,
           ParseType(ClassFinalizer::kCanonicalize));
     } else {
       exception_param.type = &Object::dynamic_type();
     }
     if (CurrentToken() == Token::kCATCH) {
@@ skipping 146 matching lines @@
     if (try_block != NULL) {
       LocalScope* scope = try_block->try_block()->scope;
       if (scope->function_level() == current_block_->scope->function_level()) {
         LocalVariable* saved_try_ctx =
             LookupSavedTryContextVar(scope->parent());
         LocalVariable* async_saved_try_ctx =
             LookupAsyncSavedTryContextVar(async_temp_scope_,
                                           try_block->try_index());
         async_code->Add(
             new (Z) StoreLocalNode(
-                Token::kNoSourcePos,
+                TokenDescriptor::kNoSource,
                 saved_try_ctx,
-                new (Z) LoadLocalNode(Token::kNoSourcePos,
+                new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
                                       async_saved_try_ctx)));
       }
     }
     SaveExceptionAndStacktrace(async_code,
                                exception_var,
                                stack_trace_var,
                                rethrow_exception_var,
                                rethrow_stack_trace_var);
     // The async_code node sequence contains code to restore the context (if
     // an outer try block is present) and code to save the exception and
     // stack trace variables.
     // This async code is inserted before the current node sequence containing
     // the chain of if/then/else handling all catch clauses.
     async_code->Add(current);
     current = async_code;
   }
   return current;
 }
 
 
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name = String::ZoneHandle(Z,
       Symbols::NewFormatted("%s%d",
                            Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
                            last_used_try_index_ - 1));
   LocalVariable* async_saved_try_ctx = new (Z) LocalVariable(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       async_saved_try_ctx_name,
       Object::dynamic_type());
   ASSERT(async_temp_scope_ != NULL);
   async_temp_scope_->AddVariable(async_saved_try_ctx);
   ASSERT(saved_try_context != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
-      Token::kNoSourcePos,
+      TokenDescriptor::kNoSource,
       async_saved_try_ctx,
-      new(Z) LoadLocalNode(Token::kNoSourcePos, saved_try_context)));
+      new(Z) LoadLocalNode(TokenDescriptor::kNoSource, saved_try_context)));
 }
 
 
 // We create three variables for exceptions:
 // ':saved_try_context_var' - Used to save the context before the start of
 //                            the try block. The context register is
 //                            restored from this variable before
 //                            processing the catch block handler.
 // ':exception_var' - Used to save the current exception object that was
 //                    thrown.
@@ skipping 58 matching lines @@
           Object::dynamic_type());
       try_scope->AddVariable(*saved_stack_trace_var);
     }
   }
 }
 
 
 AstNode* Parser::ParseTryStatement(String* label_name) {
   TRACE_PARSER("ParseTryStatement");
 
-  const intptr_t try_pos = TokenPos();
+  const TokenDescriptor try_pos = TokenPos();
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   const bool is_async = innermost_function().IsAsyncClosure() ||
                         innermost_function().IsAsyncFunction() ||
                         innermost_function().IsSyncGenClosure() ||
@@ skipping 28 matching lines @@
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   if ((CurrentToken() != Token::kCATCH) && !IsSymbol(Symbols::On()) &&
       (CurrentToken() != Token::kFINALLY)) {
     ReportError("catch or finally clause expected");
   }
 
   // Now parse the 'catch' blocks if any.
   try_stack_->enter_catch();
-  const intptr_t handler_pos = TokenPos();
+  const TokenDescriptor handler_pos = TokenPos();
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   bool needs_stack_trace = false;
   SequenceNode* catch_handler_list =
       ParseCatchClauses(handler_pos,
                         is_async,
                         exception_var,
                         stack_trace_var,
                         is_async ? saved_exception_var : exception_var,
                         is_async ? saved_stack_trace_var : stack_trace_var,
@@ skipping 10 matching lines @@
   // A finally clause is required in async code to restore the saved try context
   // of an existing outer try. Generate a finally clause to this purpose if it
   // is not declared.
   SequenceNode* finally_clause = NULL;
   SequenceNode* rethrow_clause = NULL;
   const bool parse = CurrentToken() == Token::kFINALLY;
   if (parse || (is_async && (try_stack_ != NULL))) {
     if (parse) {
       ConsumeToken();  // Consume the 'finally'.
     }
-    const intptr_t finally_pos = TokenPos();
+    const TokenDescriptor finally_pos = TokenPos();
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline = try_statement->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_clause = EnsureFinallyClause(
           parse,
           is_async,
           exception_var,
           stack_trace_var,
           is_async ? saved_exception_var : exception_var,
@@ skipping 59 matching lines @@
   }
 
   return try_catch_node;
 }
 
 
 AstNode* Parser::ParseJump(String* label_name) {
   TRACE_PARSER("ParseJump");
   ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
   Token::Kind jump_kind = CurrentToken();
-  const intptr_t jump_pos = TokenPos();
+  const TokenDescriptor jump_pos = TokenPos();
   SourceLabel* target = NULL;
   ConsumeToken();
   if (IsIdentifier()) {
     // Explicit label after break/continue.
     const String& target_name = *CurrentLiteral();
     ConsumeToken();
     // Handle pathological cases first.
     if (label_name != NULL && target_name.Equals(*label_name)) {
       if (jump_kind == Token::kCONTINUE) {
         ReportError(jump_pos, "'continue' jump to label '%s' is illegal",
@@ skipping 44 matching lines @@
   if (target->FunctionLevel() != current_block_->scope->function_level()) {
     ReportError(jump_pos, "'%s' target must be in same function context",
                 Token::Str(jump_kind));
   }
   return new(Z) JumpNode(jump_pos, jump_kind, target);
 }
 
 
 AstNode* Parser::ParseYieldStatement() {
   bool is_yield_each = false;
-  const intptr_t yield_pos = TokenPos();
+  const TokenDescriptor yield_pos = TokenPos();
   ConsumeToken();  // yield reserved word.
   if (CurrentToken() == Token::kMUL) {
     is_yield_each = true;
     ConsumeToken();
   }
   if (!innermost_function().IsGenerator() &&
       !innermost_function().IsGeneratorClosure()) {
     ReportError(yield_pos,
                 "yield%s statement only allowed in generator functions",
                 is_yield_each ? "*" : "");
   }
 
   AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
 
   LetNode* yield = new(Z) LetNode(yield_pos);
   if (innermost_function().IsSyncGenerator() ||
       innermost_function().IsSyncGenClosure()) {
     // Yield statement in sync* function.
 
     LocalVariable* iterator_param =
         LookupLocalScope(Symbols::IteratorParameter());
     ASSERT(iterator_param != NULL);
     // Generate :iterator.current = expr;
     AstNode* iterator =
-        new(Z) LoadLocalNode(Token::kNoSourcePos, iterator_param);
+        new(Z) LoadLocalNode(TokenDescriptor::kNoSource, iterator_param);
     AstNode* store_current =
-        new(Z) InstanceSetterNode(Token::kNoSourcePos,
+        new(Z) InstanceSetterNode(TokenDescriptor::kNoSource,
                                   iterator,
                                   String::ZoneHandle(Symbols::Current().raw()),
                                   expr);
     yield->AddNode(store_current);
     if (is_yield_each) {
       // Generate :iterator.isYieldEach = true;
       AstNode* set_is_yield_each =
-          new(Z) InstanceSetterNode(Token::kNoSourcePos,
+          new(Z) InstanceSetterNode(TokenDescriptor::kNoSource,
               iterator,
               String::ZoneHandle(Symbols::IsYieldEach().raw()),
               new(Z) LiteralNode(TokenPos(), Bool::True()));
       yield->AddNode(set_is_yield_each);
     }
     AwaitMarkerNode* await_marker =
         new(Z) AwaitMarkerNode(async_temp_scope_,
                                current_block_->scope,
-                               Token::kNoSourcePos);
+                               TokenDescriptor::kNoSource);
     yield->AddNode(await_marker);
     // Return true to indicate that a value has been generated.
     ReturnNode* return_true = new(Z) ReturnNode(yield_pos,
         new(Z) LiteralNode(TokenPos(), Bool::True()));
     return_true->set_return_type(ReturnNode::kContinuationTarget);
     yield->AddNode(return_true);
 
     // If this expression is part of a try block, also append the code for
     // restoring the saved try context that lives on the stack and possibly the
     // saved try context of the outer try block.
     LocalVariable* saved_try_ctx;
     LocalVariable* async_saved_try_ctx;
     LocalVariable* outer_saved_try_ctx;
     LocalVariable* outer_async_saved_try_ctx;
     CheckAsyncOpInTryBlock(&saved_try_ctx,
                            &async_saved_try_ctx,
                            &outer_saved_try_ctx,
                            &outer_async_saved_try_ctx);
     if (saved_try_ctx != NULL) {
       yield->AddNode(new (Z) StoreLocalNode(
-          Token::kNoSourcePos,
+          TokenDescriptor::kNoSource,
           saved_try_ctx,
-          new (Z) LoadLocalNode(Token::kNoSourcePos,
+          new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
                                 async_saved_try_ctx)));
       if (outer_saved_try_ctx != NULL) {
         yield->AddNode(new (Z) StoreLocalNode(
-            Token::kNoSourcePos,
+            TokenDescriptor::kNoSource,
             outer_saved_try_ctx,
-            new (Z) LoadLocalNode(Token::kNoSourcePos,
+            new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
                                   outer_async_saved_try_ctx)));
       }
     } else {
       ASSERT(outer_saved_try_ctx == NULL);
     }
   } else {
     // yield statement in async* function.
     ASSERT(innermost_function().IsAsyncGenerator() ||
            innermost_function().IsAsyncGenClosure());
 
     LocalVariable* controller_var = LookupLocalScope(Symbols::Controller());
     ASSERT(controller_var != NULL);
     // :controller.add[Stream](expr);
     ArgumentListNode* add_args = new(Z) ArgumentListNode(yield_pos);
     add_args->Add(expr);
     AstNode* add_call =
         new(Z) InstanceCallNode(yield_pos,
-            new(Z) LoadLocalNode(Token::kNoSourcePos, controller_var),
+            new(Z) LoadLocalNode(TokenDescriptor::kNoSource, controller_var),
             is_yield_each ? Symbols::AddStream() : Symbols::add(),
             add_args);
 
     // if (:controller.add[Stream](expr)) {
     //   return;
     // }
     // await_marker;
     // continuation_return;
     // restore saved_try_context
 
     SequenceNode* true_branch =
-        new(Z) SequenceNode(Token::kNoSourcePos, NULL);
+        new(Z) SequenceNode(TokenDescriptor::kNoSource, NULL);
     AstNode* return_from_generator = new(Z) ReturnNode(yield_pos);
     true_branch->Add(return_from_generator);
     AddNodeForFinallyInlining(return_from_generator);
     AstNode* if_is_cancelled =
-       new(Z) IfNode(Token::kNoSourcePos, add_call, true_branch, NULL);
+       new(Z) IfNode(TokenDescriptor::kNoSource, add_call, true_branch, NULL);
     yield->AddNode(if_is_cancelled);
 
     AwaitMarkerNode* await_marker =
         new(Z) AwaitMarkerNode(async_temp_scope_,
                                current_block_->scope,
-                               Token::kNoSourcePos);
+                               TokenDescriptor::kNoSource);
     yield->AddNode(await_marker);
     ReturnNode* continuation_return = new(Z) ReturnNode(yield_pos);
     continuation_return->set_return_type(ReturnNode::kContinuationTarget);
     yield->AddNode(continuation_return);
 
     // If this expression is part of a try block, also append the code for
     // restoring the saved try context that lives on the stack and possibly the
     // saved try context of the outer try block.
     LocalVariable* saved_try_ctx;
     LocalVariable* async_saved_try_ctx;
     LocalVariable* outer_saved_try_ctx;
     LocalVariable* outer_async_saved_try_ctx;
     CheckAsyncOpInTryBlock(&saved_try_ctx,
                            &async_saved_try_ctx,
                            &outer_saved_try_ctx,
                            &outer_async_saved_try_ctx);
     if (saved_try_ctx != NULL) {
       yield->AddNode(new (Z) StoreLocalNode(
-          Token::kNoSourcePos,
+          TokenDescriptor::kNoSource,
           saved_try_ctx,
-          new (Z) LoadLocalNode(Token::kNoSourcePos,
+          new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
                                 async_saved_try_ctx)));
       if (outer_saved_try_ctx != NULL) {
         yield->AddNode(new (Z) StoreLocalNode(
-            Token::kNoSourcePos,
+            TokenDescriptor::kNoSource,
             outer_saved_try_ctx,
-            new (Z) LoadLocalNode(Token::kNoSourcePos,
+            new (Z) LoadLocalNode(TokenDescriptor::kNoSource,
                                   outer_async_saved_try_ctx)));
       }
     } else {
       ASSERT(outer_saved_try_ctx == NULL);
     }
   }
   return yield;
 }
 
 
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
   AstNode* statement = NULL;
-  intptr_t label_pos = Token::kNoSourcePos;
+  TokenDescriptor label_pos = TokenDescriptor::kNoSource;
   String* label_name = NULL;
   if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kCOLON) {
       // Statement starts with a label.
       label_name = CurrentLiteral();
       label_pos = TokenPos();
-      ASSERT(label_pos >= 0);
+      ASSERT(label_pos.IsReal());
       ConsumeToken();  // Consume identifier.
       ConsumeToken();  // Consume colon.
     }
   }
-  const intptr_t statement_pos = TokenPos();
+  const TokenDescriptor statement_pos = TokenPos();
   const Token::Kind token = CurrentToken();
 
   if (token == Token::kWHILE) {
     statement = ParseWhileStatement(label_name);
   } else if (token == Token::kFOR) {
     statement = ParseForStatement(label_name);
   } else if (IsAwaitKeyword() && (LookaheadToken(1) == Token::kFOR)) {
     statement = ParseAwaitForStatement(label_name);
   } else if (token == Token::kDO) {
     statement = ParseDoWhileStatement(label_name);
   } else if (token == Token::kSWITCH) {
     statement = ParseSwitchStatement(label_name);
   } else if (token == Token::kTRY) {
     statement = ParseTryStatement(label_name);
   } else if (token == Token::kRETURN) {
-    const intptr_t return_pos = TokenPos();
+    const TokenDescriptor return_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
-      const intptr_t expr_pos = TokenPos();
+      const TokenDescriptor expr_pos = TokenPos();
       if (current_function().IsGenerativeConstructor() &&
           (current_block_->scope->function_level() == 0)) {
         ReportError(expr_pos,
                     "return of a value is not allowed in constructors");
       } else if (current_function().IsGeneratorClosure() &&
           (current_block_->scope->function_level() == 0)) {
         ReportError(expr_pos, "generator functions may not return a value");
       }
       AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
       statement = new(Z) ReturnNode(statement_pos, expr);
@@ skipping 95 matching lines @@
 }
 
 
 void Parser::ReportError(const Error& error) {
   Report::LongJump(error);
   UNREACHABLE();
 }
 
 
 void Parser::ReportErrors(const Error& prev_error,
-                          const Script& script, intptr_t token_pos,
+                          const Script& script, TokenDescriptor token_pos,
                           const char* format, ...) {
   va_list args;
   va_start(args, format);
   Report::LongJumpV(prev_error, script, token_pos, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
 
-void Parser::ReportError(intptr_t token_pos, const char* format, ...) const {
+void Parser::ReportError(TokenDescriptor token_pos,
+                         const char* format, ...) const {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kError,
                    script_, token_pos, Report::AtLocation, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
 
 void Parser::ReportErrorBefore(const char* format, ...) {
@@ skipping 10 matching lines @@
 void Parser::ReportError(const char* format, ...) const {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kError,
                    script_, TokenPos(), Report::AtLocation, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
 
-void Parser::ReportWarning(intptr_t token_pos, const char* format, ...) const {
+void Parser::ReportWarning(TokenDescriptor token_pos,
+                           const char* format, ...) const {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kWarning,
                    script_, token_pos, Report::AtLocation, format, args);
   va_end(args);
 }
 
 
 void Parser::ReportWarning(const char* format, ...) const {
   va_list args;
@@ skipping 79 matching lines @@
 }
 
 
 static bool IsPrefixOperator(Token::Kind token) {
   return (token == Token::kSUB) ||
          (token == Token::kNOT) ||
          (token == Token::kBIT_NOT);
 }
 
 
-SequenceNode* Parser::NodeAsSequenceNode(intptr_t sequence_pos,
+SequenceNode* Parser::NodeAsSequenceNode(TokenDescriptor sequence_pos,
                                          AstNode* node,
                                          LocalScope* scope) {
   if ((node == NULL) || !node->IsSequenceNode()) {
     SequenceNode* sequence = new SequenceNode(sequence_pos, scope);
     if (node != NULL) {
       sequence->Add(node);
     }
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
 
 // Call _throwNewIfNotLoaded if prefix is not NULL, otherwise call _throwNew.
-AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type,
+AstNode* Parser::ThrowTypeError(TokenDescriptor type_pos,
+                                const AbstractType& type,
                                 LibraryPrefix* prefix) {
   ArgumentListNode* arguments = new(Z) ArgumentListNode(type_pos);
 
   String& method_name = String::Handle(Z);
   if (prefix == NULL) {
     method_name = Library::PrivateCoreLibName(Symbols::ThrowNew()).raw();
   } else {
     arguments->Add(new(Z) LiteralNode(type_pos, *prefix));
     method_name = Library::PrivateCoreLibName(
         Symbols::ThrowNewIfNotLoaded()).raw();
   }
   // Location argument.
   arguments->Add(new(Z) LiteralNode(
-      type_pos, Integer::ZoneHandle(Z, Integer::New(type_pos))));
+      type_pos, Integer::ZoneHandle(Z, Integer::New(type_pos.value()))));
   // Src value argument.
   arguments->Add(new(Z) LiteralNode(type_pos, Object::null_instance()));
   // Dst type name argument.
   arguments->Add(new(Z) LiteralNode(type_pos, Symbols::Malformed()));
   // Dst name argument.
   arguments->Add(new(Z) LiteralNode(type_pos, Symbols::Empty()));
   // Malformed type error or malbounded type error.
   const Error& error = Error::Handle(Z, type.error());
   ASSERT(!error.IsNull());
   arguments->Add(new(Z) LiteralNode(type_pos, String::ZoneHandle(Z,
       Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(Symbols::TypeError(), method_name, arguments);
 }
 
 
 // Call _throwNewIfNotLoaded if prefix is not NULL, otherwise call _throwNew.
-AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
+AstNode* Parser::ThrowNoSuchMethodError(TokenDescriptor call_pos,
                                         const Class& cls,
                                         const String& function_name,
                                         ArgumentListNode* function_arguments,
                                         InvocationMirror::Call im_call,
                                         InvocationMirror::Type im_type,
                                         const Function* func,
                                         const LibraryPrefix* prefix) {
   ArgumentListNode* arguments = new(Z) ArgumentListNode(call_pos);
 
   String& method_name = String::Handle(Z);
@@ skipping 85 matching lines @@
   ASSERT(min_preced >= Token::Precedence(Token::kIFNULL));
   AstNode* left_operand = ParseUnaryExpr();
   if (left_operand->IsPrimaryNode() &&
       (left_operand->AsPrimaryNode()->IsSuper())) {
     ReportError(left_operand->token_pos(), "illegal use of 'super'");
   }
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
-      const intptr_t op_pos = TokenPos();
+      const TokenDescriptor op_pos = TokenPos();
       ConsumeToken();
       AstNode* right_operand = NULL;
       if ((op_kind != Token::kIS) && (op_kind != Token::kAS)) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' and 'as' we expect the right operand to be a type.
         if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
-        const intptr_t type_pos = TokenPos();
+        const TokenDescriptor type_pos = TokenPos();
         const AbstractType& type = AbstractType::ZoneHandle(Z,
             ParseType(ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
         right_operand = new(Z) TypeNode(type_pos, type);
         // In production mode, the type may be malformed.
         // In checked mode, the type may be malformed or malbounded.
@@ skipping 57 matching lines @@
   return expressions;
 }
 
 
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
   parsed_function()->EnsureExpressionTemp();
 }
 
 
-LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
+LocalVariable* Parser::CreateTempConstVariable(TokenDescriptor token_pos,
                                                const char* s) {
   char name[64];
-  OS::SNPrint(name, 64, ":%s%" Pd, s, token_pos);
+  OS::SNPrint(name, 64, ":%s%" Pd "", s, token_pos.value());
   LocalVariable* temp = new(Z) LocalVariable(
       token_pos,
       String::ZoneHandle(Z, Symbols::New(name)),
       Object::dynamic_type());
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 // TODO(srdjan): Implement other optimizations.
-AstNode* Parser::OptimizeBinaryOpNode(intptr_t op_pos,
+AstNode* Parser::OptimizeBinaryOpNode(TokenDescriptor op_pos,
                                       Token::Kind binary_op,
                                       AstNode* lhs,
                                       AstNode* rhs) {
   LiteralNode* lhs_literal = lhs->AsLiteralNode();
   LiteralNode* rhs_literal = rhs->AsLiteralNode();
   if ((lhs_literal != NULL) && (rhs_literal != NULL)) {
     if (lhs_literal->literal().IsDouble() &&
         rhs_literal->literal().IsDouble()) {
       double left_double = Double::Cast(lhs_literal->literal()).value();
       double right_double = Double::Cast(rhs_literal->literal()).value();
@@ skipping 37 matching lines @@
           expr_value = EvaluateConstExpr(rhs->token_pos(), rhs).raw();
         }
         CacheConstantValue(op_pos, expr_value);
       }
       return new(Z) LiteralNode(op_pos, expr_value);
     }
 
     LetNode* result = new(Z) LetNode(op_pos);
     LocalVariable* left_temp = result->AddInitializer(lhs);
     left_temp->set_is_final();
-    const intptr_t no_pos = Token::kNoSourcePos;
+    const TokenDescriptor no_pos = TokenDescriptor::kNoSource;
     LiteralNode* null_operand =
         new(Z) LiteralNode(no_pos, Object::null_instance());
     LoadLocalNode* load_left_temp = new(Z) LoadLocalNode(no_pos, left_temp);
     ComparisonNode* null_compare =
         new(Z) ComparisonNode(no_pos,
                               Token::kNE_STRICT,
                               load_left_temp,
                               null_operand);
     result->AddNode(new(Z) ConditionalExprNode(op_pos,
                                                null_compare,
                                                load_left_temp,
                                                rhs));
     return result;
   }
   return new(Z) BinaryOpNode(op_pos, binary_op, lhs, rhs);
 }
 
 
-AstNode* Parser::ExpandAssignableOp(intptr_t op_pos,
+AstNode* Parser::ExpandAssignableOp(TokenDescriptor op_pos,
                                     Token::Kind assignment_op,
                                     AstNode* lhs,
                                     AstNode* rhs) {
   TRACE_PARSER("ExpandAssignableOp");
   switch (assignment_op) {
     case Token::kASSIGN:
       return rhs;
     case Token::kASSIGN_ADD:
       return new(Z) BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
     case Token::kASSIGN_SUB:
@@ skipping 23 matching lines @@
                   "internal error: ExpandAssignableOp '%s' unimplemented",
                   Token::Name(assignment_op));
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
 
 // Evaluates the value of the compile time constant expression
 // and returns a literal node for the value.
-LiteralNode* Parser::FoldConstExpr(intptr_t expr_pos, AstNode* expr) {
+LiteralNode* Parser::FoldConstExpr(TokenDescriptor expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr->AsLiteralNode();
   }
   if (expr->EvalConstExpr() == NULL) {
     ReportError(expr_pos, "expression is not a valid compile-time constant");
   }
   return new(Z) LiteralNode(
       expr_pos, EvaluateConstExpr(expr_pos, expr));
 }
 
 
 LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
-  intptr_t token_pos = node->token_pos();
+  TokenDescriptor token_pos = node->token_pos();
   LetNode* result = new(Z) LetNode(token_pos);
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
     AstNode* array = load_indexed->array();
     AstNode* index = load_indexed->index_expr();
     if (!IsSimpleLocalOrLiteralNode(load_indexed->array())) {
       LocalVariable* t0 = result->AddInitializer(load_indexed->array());
       array = new(Z) LoadLocalNode(token_pos, t0);
     }
     if (!IsSimpleLocalOrLiteralNode(load_indexed->index_expr())) {
@@ skipping 23 matching lines @@
 
 
 // Check whether the syntax of expression expr is a grammatically legal
 // assignable expression. This check is used to detect situations where
 // the expression itself is assignable, but the source is grammatically
 // wrong. The AST representation of an expression cannot distinguish
 // between x = 0 and (x) = 0. The latter is illegal.
 // A syntactically legal assignable expression always ends with an
 // identifier token or a ] token. We rewind the token iterator and
 // check whether the token before end_pos is an identifier or ].
-bool Parser::IsLegalAssignableSyntax(AstNode* expr, intptr_t end_pos) {
-  ASSERT(expr->token_pos() >= 0);
+bool Parser::IsLegalAssignableSyntax(AstNode* expr, TokenDescriptor end_pos) {
+  ASSERT(expr->token_pos().IsReal());
   ASSERT(expr->token_pos() < end_pos);
   SetPosition(expr->token_pos());
   Token::Kind token = Token::kILLEGAL;
   while (TokenPos() < end_pos) {
     token = CurrentToken();
     ConsumeToken();
   }
   ASSERT(TokenPos() == end_pos);
   return Token::IsIdentifier(token) || (token == Token::kRBRACK);
 }
 
 
 AstNode* Parser::CreateAssignmentNode(AstNode* original,
                                       AstNode* rhs,
                                       const String* left_ident,
-                                      intptr_t left_pos,
+                                      TokenDescriptor left_pos,
                                       bool is_compound /* = false */) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if (result == NULL) {
     String& name = String::ZoneHandle(Z);
     const Class* target_cls = &current_class();
     if (original->IsTypeNode()) {
       name = Symbols::New(original->AsTypeNode()->TypeName());
     } else if (original->IsLoadStaticFieldNode()) {
       name = original->AsLoadStaticFieldNode()->field().name();
       target_cls = &Class::Handle(Z,
@@ skipping 37 matching lines @@
     result = OptimizeBinaryOpNode(ifnull->token_pos(),
                                   ifnull->kind(),
                                   ifnull->left(),
                                   modified_assign);
   }
   return result;
 }
 
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
-  intptr_t cascade_pos = TokenPos();
+  TokenDescriptor cascade_pos = TokenPos();
   LetNode* cascade = new(Z) LetNode(cascade_pos);
   LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
         new(Z) LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
     } else if (LookaheadToken(1) == Token::kLBRACK) {
       ConsumeToken();
     } else {
       ReportError("identifier or [ expected after ..");
     }
     String* expr_ident =
         Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
-    const intptr_t expr_pos = TokenPos();
+    const TokenDescriptor expr_pos = TokenPos();
     expr = ParseSelectors(load_cascade_receiver, true);
 
     // Assignments after a cascade are part of the cascade. The
     // assigned expression must not contain cascades.
     if (Token::IsAssignmentOperator(CurrentToken())) {
       Token::Kind assignment_op = CurrentToken();
-      const intptr_t assignment_pos = TokenPos();
+      const TokenDescriptor assignment_pos = TokenPos();
       ConsumeToken();
       AstNode* right_expr = ParseExpr(kAllowConst, kNoCascades);
       if (assignment_op != Token::kASSIGN) {
         // Compound assignment: store inputs with side effects into
         // temporary locals.
         LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
         right_expr =
             ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
         AstNode* assign_expr =
             CreateAssignmentNode(expr, right_expr, expr_ident, expr_pos, true);
@@ skipping 59 matching lines @@
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
-  const intptr_t expr_pos = TokenPos();
+  const TokenDescriptor expr_pos = TokenPos();
 
   RecursionChecker rc(this);
 
   if (CurrentToken() == Token::kTHROW) {
     if (require_compiletime_const) {
       ReportError("'throw expr' is not a valid compile-time constant");
     }
     ConsumeToken();
     if (CurrentToken() == Token::kSEMICOLON) {
       ReportError("expression expected after throw");
@@ skipping 25 matching lines @@
     } else {
       expr = LiteralIfStaticConst(Z, expr);
     }
     return expr;
   }
   // Assignment expressions.
   if (!IsLegalAssignableSyntax(expr, TokenPos())) {
     ReportError(expr_pos, "expression is not assignable");
   }
   const Token::Kind assignment_op = CurrentToken();
-  const intptr_t assignment_pos = TokenPos();
+  const TokenDescriptor assignment_pos = TokenPos();
   ConsumeToken();
-  const intptr_t right_expr_pos = TokenPos();
+  const TokenDescriptor right_expr_pos = TokenPos();
   if (require_compiletime_const && (assignment_op != Token::kASSIGN)) {
     ReportError(right_expr_pos,
                 "expression is not a valid compile-time constant");
   }
   AstNode* right_expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (assignment_op != Token::kASSIGN) {
     // Compound assignment: store inputs with side effects into temp. locals.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos, true);
     ASSERT(assign_expr != NULL);
     let_expr->AddNode(assign_expr);
     return let_expr;
   } else {
     AstNode* assigned_value = LiteralIfStaticConst(Z, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     return assign_expr;
   }
 }
 
 
 LiteralNode* Parser::ParseConstExpr() {
   TRACE_PARSER("ParseConstExpr");
-  intptr_t expr_pos = TokenPos();
+  TokenDescriptor expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kRequireConst, kNoCascades);
   if (!expr->IsLiteralNode()) {
     ReportError(expr_pos, "expression must be a compile-time constant");
   }
   return expr->AsLiteralNode();
 }
 
 
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
-  const intptr_t expr_pos = TokenPos();
+  const TokenDescriptor expr_pos = TokenPos();
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kIFNULL));
   if (CurrentToken() == Token::kCONDITIONAL) {
     EnsureExpressionTemp();
     ConsumeToken();
     AstNode* expr1 = ParseExpr(kAllowConst, kNoCascades);
     ExpectToken(Token::kCOLON);
     AstNode* expr2 = ParseExpr(kAllowConst, kNoCascades);
     expr = new(Z) ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
-  const intptr_t op_pos = TokenPos();
+  const TokenDescriptor op_pos = TokenPos();
   if (IsAwaitKeyword()) {
     TRACE_PARSER("ParseAwaitExpr");
     if (!innermost_function().IsAsyncFunction() &&
         !innermost_function().IsAsyncClosure() &&
         !innermost_function().IsAsyncGenerator() &&
         !innermost_function().IsAsyncGenClosure()) {
       ReportError("await operator is only allowed in an asynchronous function");
     }
     ConsumeToken();
     parsed_function()->record_await();
@@ skipping 23 matching lines @@
     if (expr->IsPrimaryNode() && (expr->AsPrimaryNode()->IsSuper())) {
       expr = BuildUnarySuperOperator(unary_op, expr->AsPrimaryNode());
     } else {
       expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
     }
   } else if (IsIncrementOperator(CurrentToken())) {
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     String* expr_ident =
         Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
-    const intptr_t expr_pos = TokenPos();
+    const TokenDescriptor expr_pos = TokenPos();
     expr = ParseUnaryExpr();
     if (!IsLegalAssignableSyntax(expr, TokenPos())) {
       ReportError(expr_pos, "expression is not assignable");
     }
     // Is prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new(Z) BinaryOpNode(
         op_pos,
@@ skipping 60 matching lines @@
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
     arguments->set_names(Array::Handle(Z, Array::MakeArray(names)));
   }
   return arguments;
 }
 
 
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
-                                 intptr_t ident_pos) {
+                                 TokenDescriptor ident_pos) {
   TRACE_PARSER("ParseStaticCall");
-  const intptr_t call_pos = TokenPos();
+  const TokenDescriptor call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   const int num_arguments = arguments->length();
   const Function& func = Function::ZoneHandle(Z,
       Resolver::ResolveStatic(cls,
                               func_name,
                               num_arguments,
                               arguments->names()));
   if (func.IsNull()) {
     // Check if there is a static field of the same name, it could be a closure
@@ skipping 65 matching lines @@
                                    arguments->NodeAt(0),
                                    arguments->NodeAt(1));
     }
   }
   return new(Z) StaticCallNode(ident_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver,
                                    const String& func_name,
-                                   intptr_t ident_pos,
+                                   TokenDescriptor ident_pos,
                                    bool is_conditional) {
   TRACE_PARSER("ParseInstanceCall");
   CheckToken(Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new(Z) InstanceCallNode(ident_pos,
                                  receiver,
                                  func_name,
                                  arguments,
                                  is_conditional);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   TRACE_PARSER("ParseClosureCall");
-  const intptr_t call_pos = TokenPos();
+  const TokenDescriptor call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return BuildClosureCall(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::GenerateStaticFieldLookup(const Field& field,
-                                           intptr_t ident_pos) {
+                                           TokenDescriptor ident_pos) {
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field, ident_pos);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
     // time. The getter will initialize the field.
     return initializing_getter;
   }
   // The field is initialized.
   ASSERT(field.is_static());
@@ skipping 13 matching lines @@
                                    NULL,  // Receiver.
                                    field_owner,
                                    field_name);
   }
 }
 
 
 // Reference to 'field_name' with explicit class as primary.
 AstNode* Parser::GenerateStaticFieldAccess(const Class& cls,
                                            const String& field_name,
-                                           intptr_t ident_pos) {
+                                           TokenDescriptor ident_pos) {
   AstNode* access = NULL;
   const Field& field = Field::ZoneHandle(Z, cls.LookupStaticField(field_name));
   Function& func = Function::ZoneHandle(Z);
   if (field.IsNull()) {
     // No field, check if we have an explicit getter function.
     func = cls.LookupGetterFunction(field_name);
     if (func.IsNull() || func.IsDynamicFunction()) {
       // We might be referring to an implicit closure, check to see if
       // there is a function of the same name.
       func = cls.LookupStaticFunction(field_name);
@@ skipping 86 matching lines @@
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if ((CurrentToken() == Token::kPERIOD) ||
         (CurrentToken() == Token::kQM_PERIOD)) {
       // Unconditional or conditional property extraction or method call.
       bool is_conditional = CurrentToken() == Token::kQM_PERIOD;
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
-        const intptr_t primary_pos = primary_node->token_pos();
+        const TokenDescriptor primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (ParsingStaticMember()) {
             const String& name = String::Handle(Z,
                 TypeParameter::Cast(primary_node->primary()).name());
             ReportError(primary_pos,
                         "cannot access type parameter '%s' "
                         "from static function",
                         name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
           left = new(Z) TypeNode(primary->token_pos(), type_parameter);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
           ASSERT(!primary_node->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
-      const intptr_t ident_pos = TokenPos();
+      const TokenDescriptor ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         // Identifier followed by a opening paren: method call.
         if (left->IsPrimaryNode() &&
             left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
           const Class& cls = Class::Cast(left->AsPrimaryNode()->primary());
           selector = ParseStaticCall(cls, *ident, ident_pos);
         } else {
           selector = ParseInstanceCall(left, *ident, ident_pos, is_conditional);
@@ skipping 25 matching lines @@
             selector->AsLoadStaticFieldNode()->set_is_deferred(is_deferred);
           } else if (selector->IsStaticGetterNode()) {
             selector->AsStaticGetterNode()->set_is_deferred(is_deferred);
           }
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
       // Super index operator handled in ParseSuperOperator().
       ASSERT(!left->IsPrimaryNode() || !left->AsPrimaryNode()->IsSuper());
 
-      const intptr_t bracket_pos = TokenPos();
+      const TokenDescriptor bracket_pos = TokenPos();
       ConsumeToken();
       left = LoadFieldIfUnresolved(left);
       const bool saved_mode = SetAllowFunctionLiterals(true);
       AstNode* index = ParseExpr(kAllowConst, kConsumeCascades);
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
-        const intptr_t primary_pos = primary_node->token_pos();
+        const TokenDescriptor primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           array = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(Z,
               Type::New(type_class, TypeArguments::Handle(Z),
                         primary_pos, Heap::kOld));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
@@ skipping 21 matching lines @@
           array = new(Z) TypeNode(primary_pos, type_parameter);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       selector =  new(Z) LoadIndexedNode(
           bracket_pos, array, index, Class::ZoneHandle(Z));
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
-        const intptr_t primary_pos = primary_node->token_pos();
+        const TokenDescriptor primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           const Function& func = Function::Cast(primary_node->primary());
           const String& func_name = String::ZoneHandle(Z, func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(Z, func.Owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
@@ skipping 55 matching lines @@
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
         selector = ParseClosureCall(closure);
       }
     } else {
       // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
-        const intptr_t primary_pos = primary->token_pos();
+        const TokenDescriptor primary_pos = primary->token_pos();
         if (primary_node->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(Z, Type::New(
               type_class, TypeArguments::Handle(Z), primary_pos));
           type = ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
@@ skipping 32 matching lines @@
     }
     ASSERT(selector != NULL);
     left = selector;
   }
 }
 
 
 // Closurization e#m of getter, setter, method or operator.
 AstNode* Parser::ParseClosurization(AstNode* primary) {
   ExpectToken(Token::kHASH);
-  intptr_t property_pos = TokenPos();
+  TokenDescriptor property_pos = TokenPos();
   bool is_setter_name = false;
 
   String& extractor_name = String::ZoneHandle(Z);
   if (IsIdentifier()) {
     extractor_name = CurrentLiteral()->raw();
     ConsumeToken();
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       is_setter_name = true;
     }
@@ skipping 120 matching lines @@
   pieces.Add(extractor_name);
   extractor_name = Symbols::FromConcatAll(pieces);
   return new(Z) InstanceGetterNode(property_pos, primary, extractor_name);
 }
 
 
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
-  const intptr_t expr_pos = TokenPos();
+  const TokenDescriptor expr_pos = TokenPos();
   AstNode* expr = ParsePrimary();
   if (CurrentToken() == Token::kHASH) {
     expr = LoadFieldIfUnresolved(expr);
     expr = ParseClosurization(expr);
   } else {
     expr = ParseSelectors(expr, false);
   }
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     if (!IsLegalAssignableSyntax(expr, TokenPos())) {
       ReportError(expr_pos, "expression is not assignable");
     }
     Token::Kind incr_op = CurrentToken();
-    const intptr_t op_pos = TokenPos();
+    const TokenDescriptor op_pos = TokenPos();
     ConsumeToken();
     // Not prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     LocalVariable* temp = let_expr->AddInitializer(expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new(Z) BinaryOpNode(
         op_pos,
         binary_op,
         new(Z) LoadLocalNode(op_pos, temp),
@@ skipping 112 matching lines @@
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
   }
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
 }
 
 
-void Parser::CheckInstanceFieldAccess(intptr_t field_pos,
+void Parser::CheckInstanceFieldAccess(TokenDescriptor field_pos,
                                       const String& field_name) {
   // Fields are not accessible from a static function, except from a
   // constructor, which is considered as non-static by the compiler.
   if (current_function().is_static()) {
     ReportError(field_pos,
                 "cannot access instance field '%s' from a static function",
                 field_name.ToCString());
   }
 }
 
@@ skipping 42 matching lines @@
 // We cache computed compile-time constants in a map so we can look them
 // up when the same code gets compiled again. The map key is a pair
 // (script url, token position) which is encoded in an array with 2
 // elements:
 // - key[0] contains the canonicalized url of the script.
 // - key[1] contains the token position of the constant in the script.
 
 // ConstantPosKey allows us to look up a constant in the map without
 // allocating a key pair (array).
 struct ConstantPosKey : ValueObject {
-  ConstantPosKey(const String& url, intptr_t pos)
+  ConstantPosKey(const String& url, TokenDescriptor pos)
       : script_url(url), token_pos(pos) { }
   const String& script_url;
-  intptr_t token_pos;
+  TokenDescriptor token_pos;
 };
 
 
 class ConstMapKeyEqualsTraits {
  public:
   static bool IsMatch(const Object& a, const Object& b) {
     const Array& key1 = Array::Cast(a);
     const Array& key2 = Array::Cast(b);
     // Compare raw strings of script url symbol and raw smi of token positon.
     return (key1.At(0) == key2.At(0)) && (key1.At(1) == key2.At(1));
   }
   static bool IsMatch(const ConstantPosKey& key1, const Object& b) {
     const Array& key2 = Array::Cast(b);
     // Compare raw strings of script url symbol and token positon.
     return (key1.script_url.raw() == key2.At(0))
-        && (key1.token_pos == Smi::Value(Smi::RawCast(key2.At(1))));
+        && (key1.token_pos.value() == Smi::Value(Smi::RawCast(key2.At(1))));
   }
   static uword Hash(const Object& obj) {
     const Array& key = Array::Cast(obj);
     intptr_t url_hash = String::HashRawSymbol(String::RawCast(key.At(0)));
     intptr_t pos = Smi::Value(Smi::RawCast(key.At(1)));
     return HashValue(url_hash, pos);
   }
   static uword Hash(const ConstantPosKey& key) {
     return HashValue(String::HashRawSymbol(key.script_url.raw()),
-                     key.token_pos);
+                     key.token_pos.value());
   }
   // Used by CachConstantValue if a new constant is added to the map.
   static RawObject* NewKey(const ConstantPosKey& key) {
     const Array& key_obj = Array::Handle(Array::New(2));
     key_obj.SetAt(0, key.script_url);
-    key_obj.SetAt(1, Smi::Handle(Smi::New(key.token_pos)));
+    key_obj.SetAt(1, Smi::Handle(Smi::New(key.token_pos.value())));
     return key_obj.raw();;
   }
 
  private:
   static uword HashValue(intptr_t url_hash, intptr_t pos) {
     return url_hash * pos % (Smi::kMaxValue - 13);
   }
 };
 typedef UnorderedHashMap<ConstMapKeyEqualsTraits> ConstantsMap;
 
 
-void Parser::CacheConstantValue(intptr_t token_pos, const Instance& value) {
+void Parser::CacheConstantValue(TokenDescriptor token_pos,
+                                const Instance& value) {
   ConstantPosKey key(String::Handle(Z, script_.url()), token_pos);
   if (isolate()->object_store()->compile_time_constants() == Array::null()) {
     const intptr_t kInitialConstMapSize = 16;
     isolate()->object_store()->set_compile_time_constants(
         Array::Handle(Z, HashTables::New<ConstantsMap>(kInitialConstMapSize,
                                                        Heap::kNew)));
   }
   ConstantsMap constants(isolate()->object_store()->compile_time_constants());
   constants.InsertNewOrGetValue(key, value);
   if (FLAG_compiler_stats) {
     isolate_->compiler_stats()->num_cached_consts = constants.NumOccupied();
   }
   isolate()->object_store()->set_compile_time_constants(constants.Release());
 }
 
 
-bool Parser::GetCachedConstant(intptr_t token_pos, Instance* value) {
+bool Parser::GetCachedConstant(TokenDescriptor token_pos, Instance* value) {
   if (isolate()->object_store()->compile_time_constants() == Array::null()) {
     return false;
   }
   ConstantPosKey key(String::Handle(Z, script_.url()), token_pos);
   ConstantsMap constants(isolate()->object_store()->compile_time_constants());
   bool is_present = false;
   *value ^= constants.GetOrNull(key, &is_present);
   // Mutator compiler thread may add constants while background compiler
   // is running , and thus change the value of 'compile_time_constants';
   // do not assert that 'compile_time_constants' has not changed.
   constants.Release();
   if (FLAG_compiler_stats && is_present) {
     isolate_->compiler_stats()->num_const_cache_hits++;
   }
   return is_present;
 }
 
 
 RawInstance* Parser::TryCanonicalize(const Instance& instance,
-                                     intptr_t token_pos) {
+                                     TokenDescriptor token_pos) {
   if (instance.IsNull()) {
     return instance.raw();
   }
   const char* error_str = NULL;
   Instance& result =
       Instance::Handle(Z, instance.CheckAndCanonicalize(&error_str));
   if (result.IsNull()) {
     ReportError(token_pos, "Invalid const object %s", error_str);
   }
   return result.raw();
 }
 
 
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
-StaticGetterNode* Parser::RunStaticFieldInitializer(const Field& field,
-                                                    intptr_t field_ref_pos) {
+StaticGetterNode* Parser::RunStaticFieldInitializer(
+    const Field& field, TokenDescriptor field_ref_pos) {
   ASSERT(field.is_static());
   const Class& field_owner = Class::ZoneHandle(Z, field.owner());
   const String& field_name = String::ZoneHandle(Z, field.name());
   const String& getter_name =
       String::Handle(Z, Field::GetterSymbol(field_name));
   const Function& getter = Function::Handle(Z,
       field_owner.LookupStaticFunction(getter_name));
   const Instance& value = Instance::Handle(Z, field.StaticValue());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
@@ skipping 116 matching lines @@
       instance ^= result.raw();
     }
     return TryCanonicalize(instance, TokenPos());
   }
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
-bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
+bool Parser::ResolveIdentInLocalScope(TokenDescriptor ident_pos,
                                       const String &ident,
                                       AstNode** node) {
   TRACE_PARSER("ResolveIdentInLocalScope");
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
   if (current_block_ != NULL) {
     current_block_->scope->AddReferencedName(ident_pos, ident);
   }
   if (local != NULL) {
     if (node != NULL) {
@@ skipping 84 matching lines @@
   if (node != NULL) {
     *node = NULL;
   }
   return false;
 }
 
 
 // Resolve an identifier by checking the global scope of the current
 // library. If not found in the current library, then look in the scopes
 // of all libraries that are imported without a library prefix.
-AstNode* Parser::ResolveIdentInCurrentLibraryScope(intptr_t ident_pos,
+AstNode* Parser::ResolveIdentInCurrentLibraryScope(TokenDescriptor ident_pos,
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   HANDLESCOPE(thread());
   const Object& obj = Object::Handle(Z, library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     return new(Z) PrimaryNode(ident_pos, Class::ZoneHandle(Z, cls.raw()));
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
@@ skipping 25 matching lines @@
     ASSERT(obj.IsNull());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new(Z) PrimaryNode(ident_pos, ident);
 }
 
 
 // Do a lookup for the identifier in the scope of the specified
 // library prefix. This means trying to resolve it locally in all of the
 // libraries present in the library prefix.
-AstNode* Parser::ResolveIdentInPrefixScope(intptr_t ident_pos,
+AstNode* Parser::ResolveIdentInPrefixScope(TokenDescriptor ident_pos,
                                            const LibraryPrefix& prefix,
                                            const String& ident) {
   TRACE_PARSER("ResolveIdentInPrefixScope");
   HANDLESCOPE(thread());
   if (ident.CharAt(0) == Library::kPrivateIdentifierStart) {
     // Private names are not exported by libraries. The name mangling
     // of private names with a library-specific suffix usually ensures
     // that _x in library A is not found when looked up from library B.
     // In the pathological case where a library imports itself with
     // a prefix, the name mangling would not help in hiding the private
@@ skipping 58 matching lines @@
   UNREACHABLE();
   return NULL;
 }
 
 
 // Resolve identifier. Issue an error message if
 // the ident refers to a method and allow_closure_names is false.
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or generate
 // throw NoSuchMethodError if we're compiling a static method.
-AstNode* Parser::ResolveIdent(intptr_t ident_pos,
+AstNode* Parser::ResolveIdent(TokenDescriptor ident_pos,
                               const String& ident,
                               bool allow_closure_names) {
   TRACE_PARSER("ResolveIdent");
   // First try to find the variable in the local scope (block scope or
   // class scope).
   AstNode* resolved = NULL;
   ResolveIdentInLocalScope(ident_pos, ident, &resolved);
   if (resolved == NULL) {
     // Check whether the identifier is a type parameter.
     if (!current_class().IsNull()) {
@@ skipping 10 matching lines @@
         return new(Z) TypeNode(ident_pos, type_parameter);
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it without a library prefix).
     resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
   }
   if (resolved->IsPrimaryNode()) {
     PrimaryNode* primary = resolved->AsPrimaryNode();
-    const intptr_t primary_pos = primary->token_pos();
+    const TokenDescriptor primary_pos = primary->token_pos();
     if (primary->primary().IsString()) {
       // We got an unresolved name. If we are compiling a static
       // method, evaluation of an unresolved identifier causes a
       // NoSuchMethodError to be thrown. In an instance method, we convert
       // the unresolved name to an instance field access, since a
       // subclass might define a field with this name.
       if (current_function().is_static()) {
         resolved = ThrowNoSuchMethodError(ident_pos,
                                           current_class(),
                                           ident,
@@ skipping 38 matching lines @@
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode. Returns prefix.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization,
     bool allow_deferred_type,
     bool consume_unresolved_prefix,
     LibraryPrefix* prefix) {
   TRACE_PARSER("ParseType");
   CheckToken(Token::kIDENT, "type name expected");
-  intptr_t ident_pos = TokenPos();
+  TokenDescriptor ident_pos = TokenPos();
   String& type_name = String::Handle(Z);
 
   if (finalization == ClassFinalizer::kIgnore) {
     if (!is_top_level_ && (current_block_ != NULL)) {
       // Add the library prefix or type class name to the list of referenced
       // names of this scope, even if the type is ignored.
       current_block_->scope->AddReferencedName(TokenPos(), *CurrentLiteral());
     }
     SkipQualIdent();
   } else {
@@ skipping 92 matching lines @@
     ResolveTypeFromClass(current_class(), finalization, &type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
-    intptr_t pos, const Function& constructor,
+    TokenDescriptor pos, const Function& constructor,
     const TypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
     const Class& constructor_class = Class::Handle(Z, constructor.Owner());
     ASSERT(!constructor_class.IsNull());
     ASSERT(constructor_class.is_finalized());
     ASSERT(type_arguments.IsCanonical());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != constructor_class.NumTypeArguments()) {
       ReportError(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the list literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
-AstNode* Parser::ParseListLiteral(intptr_t type_pos,
+AstNode* Parser::ParseListLiteral(TokenDescriptor type_pos,
                                   bool is_const,
                                   const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseListLiteral");
-  ASSERT(type_pos >= 0);
+  ASSERT(type_pos.IsReal());
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
-  const intptr_t literal_pos = TokenPos();
+  const TokenDescriptor literal_pos = TokenPos();
 
   if (is_const) {
     Instance& existing_const = Instance::ZoneHandle(Z);
     if (GetCachedConstant(literal_pos, &existing_const)) {
       SkipListLiteral();
       return new(Z) LiteralNode(literal_pos, existing_const);
     }
   }
 
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
@@ skipping 33 matching lines @@
   Type& type = Type::ZoneHandle(Z,
       Type::New(array_class, list_type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   GrowableArray<AstNode*> element_list;
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     while (CurrentToken() != Token::kRBRACK) {
-      const intptr_t element_pos = TokenPos();
+      const TokenDescriptor element_pos = TokenPos();
       AstNode* element = ParseExpr(is_const, kConsumeCascades);
       if (I->flags().type_checks() &&
           !is_const &&
           !element_type.IsDynamicType()) {
         element = new(Z) AssignableNode(element_pos,
                                         element,
                                         element_type,
                                         Symbols::ListLiteralElement());
       }
       element_list.Add(element);
@@ skipping 85 matching lines @@
     }
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
                                      factory_method,
                                      factory_param);
   }
 }
 
 
 ConstructorCallNode* Parser::CreateConstructorCallNode(
-    intptr_t token_pos,
+    TokenDescriptor token_pos,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
     EnsureExpressionTemp();
   }
   return new(Z) ConstructorCallNode(
       token_pos, type_arguments, constructor, arguments);
 }
 
@@ skipping 16 matching lines @@
         (*pairs)[i + 1] = value;
         return;
       }
     }
   }
   pairs->Add(key);
   pairs->Add(value);
 }
 
 
-AstNode* Parser::ParseMapLiteral(intptr_t type_pos,
+AstNode* Parser::ParseMapLiteral(TokenDescriptor type_pos,
                                  bool is_const,
                                  const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
-  ASSERT(type_pos >= 0);
+  ASSERT(type_pos.IsReal());
   ASSERT(CurrentToken() == Token::kLBRACE);
-  const intptr_t literal_pos = TokenPos();
+  const TokenDescriptor literal_pos = TokenPos();
 
   if (is_const) {
     Instance& existing_const = Instance::ZoneHandle(Z);
     if (GetCachedConstant(literal_pos, &existing_const)) {
       SkipMapLiteral();
       return new(Z) LiteralNode(literal_pos, existing_const);
     }
   }
 
   ConsumeToken();  // Opening brace.
@@ skipping 32 matching lines @@
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   GrowableArray<AstNode*> kv_pairs_list;
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   while (CurrentToken() != Token::kRBRACE) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
-    const intptr_t key_pos = TokenPos();
+    const TokenDescriptor key_pos = TokenPos();
     AstNode* key = ParseExpr(is_const, kConsumeCascades);
     if (I->flags().type_checks() &&
         !is_const &&
         !key_type.IsDynamicType()) {
       key = new(Z) AssignableNode(
           key_pos, key, key_type, Symbols::ListLiteralElement());
     }
     if (is_const) {
       ASSERT(key->IsLiteralNode());
       const Instance& key_value = key->AsLiteralNode()->literal();
       if (key_value.IsDouble()) {
         ReportError(key_pos, "key value must not be of type double");
       }
       if (!key_value.IsInteger() &&
           !key_value.IsString() &&
           (key_value.clazz() != I->object_store()->symbol_class()) &&
           ImplementsEqualOperator(key_value)) {
         ReportError(key_pos, "key value must not implement operator ==");
       }
     }
     ExpectToken(Token::kCOLON);
-    const intptr_t value_pos = TokenPos();
+    const TokenDescriptor value_pos = TokenPos();
     AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     if (I->flags().type_checks() &&
         !is_const &&
         !value_type.IsDynamicType()) {
       value = new(Z) AssignableNode(
           value_pos, value, value_type, Symbols::ListLiteralElement());
     }
     AddKeyValuePair(&kv_pairs_list, is_const, key, value);
 
@@ skipping 129 matching lines @@
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
-  const intptr_t type_pos = TokenPos();
+  const TokenDescriptor type_pos = TokenPos();
   TypeArguments& type_arguments = TypeArguments::Handle(Z,
       ParseTypeArguments(ClassFinalizer::kCanonicalize));
   // Malformed type arguments are mapped to dynamic, so we will not encounter
   // them here.
   // Map and List interfaces do not declare bounds on their type parameters, so
   // we will not see malbounded type arguments here.
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
 AstNode* Parser::ParseSymbolLiteral() {
   ASSERT(CurrentToken() == Token::kHASH);
   ConsumeToken();
-  intptr_t symbol_pos = TokenPos();
+  TokenDescriptor symbol_pos = TokenPos();
   String& symbol = String::ZoneHandle(Z);
   if (IsIdentifier()) {
     symbol = CurrentLiteral()->raw();
     ConsumeToken();
     GrowableHandlePtrArray<const String> pieces(Z, 3);
     pieces.Add(symbol);
     while (CurrentToken() == Token::kPERIOD) {
       pieces.Add(Symbols::Dot());
       ConsumeToken();
       pieces.Add(*ExpectIdentifier("identifier expected"));
@@ skipping 29 matching lines @@
     ReportErrors(Error::Cast(result),
                  script_, symbol_pos,
                  "error executing const Symbol constructor");
   }
   symbol_instance ^= result.raw();
   CacheConstantValue(symbol_pos, symbol_instance);
   return new(Z) LiteralNode(symbol_pos, symbol_instance);
 }
 
 
-RawFunction* Parser::BuildConstructorClosureFunction(const Function& ctr,
-                                                     intptr_t token_pos) {
+RawFunction* Parser::BuildConstructorClosureFunction(
+    const Function& ctr, TokenDescriptor token_pos) {
   ASSERT(ctr.kind() == RawFunction::kConstructor);
   Function& closure = Function::Handle(Z);
   closure = I->LookupClosureFunction(innermost_function(), token_pos);
   if (!closure.IsNull()) {
     ASSERT(closure.IsConstructorClosureFunction());
     return closure.raw();
   }
 
   String& closure_name = String::Handle(Z, ctr.name());
   closure_name = Symbols::FromConcat(Symbols::ConstructorClosurePrefix(),
@@ skipping 96 matching lines @@
       }
       *type_arguments = type.arguments();
       *constructor = constructor->RedirectionTarget();
     }
   }
 }
 
 
 AstNode* Parser::ParseNewOperator(Token::Kind op_kind) {
   TRACE_PARSER("ParseNewOperator");
-  const intptr_t new_pos = TokenPos();
+  const TokenDescriptor new_pos = TokenPos();
   ASSERT((op_kind == Token::kNEW) || (op_kind == Token::kCONST));
   bool is_const = (op_kind == Token::kCONST);
   if (!IsIdentifier()) {
     ReportError("type name expected");
   }
-  intptr_t type_pos = TokenPos();
+  TokenDescriptor type_pos = TokenPos();
   // Can't allocate const objects of a deferred type.
   const bool allow_deferred_type = !is_const;
   const Token::Kind la3 = LookaheadToken(3);
   const bool consume_unresolved_prefix =
       (la3 == Token::kLT) || (la3 == Token::kPERIOD) || (la3 == Token::kHASH);
 
   LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(Z);
   AbstractType& type = AbstractType::Handle(Z,
       ParseType(ClassFinalizer::kCanonicalizeWellFormed,
                 allow_deferred_type,
@@ skipping 50 matching lines @@
     ConsumeToken();
     if (IsIdentifier()) {
       named_constructor = ExpectIdentifier("name of constructor expected");
     }
   } else if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
-  intptr_t call_pos = TokenPos();
+  TokenDescriptor call_pos = TokenPos();
   ArgumentListNode* arguments = NULL;
   if (!is_tearoff_expression) {
     CheckToken(Token::kLPAREN);
     call_pos = TokenPos();
     arguments = ParseActualParameters(NULL, is_const);
   } else {
     // Allocate dummy node with no arguments so we don't have to deal
     // with the NULL corner case below.
     arguments = new(Z) ArgumentListNode(TokenPos());
   }
@@ skipping 119 matching lines @@
   // It is ok to call a factory method of an abstract class, but it is
   // a dynamic error to instantiate an abstract class.
   if (type_class.is_abstract() && !constructor.IsFactory()) {
     // Evaluate arguments before throwing.
     LetNode* result = new(Z) LetNode(call_pos);
     for (intptr_t i = 0; i < arguments->length(); ++i) {
       result->AddNode(arguments->NodeAt(i));
     }
     ArgumentListNode* error_arguments = new(Z) ArgumentListNode(type_pos);
     error_arguments->Add(new(Z) LiteralNode(
-        TokenPos(), Integer::ZoneHandle(Z, Integer::New(type_pos))));
+        TokenPos(), Integer::ZoneHandle(Z, Integer::New(type_pos.value()))));
     error_arguments->Add(new(Z) LiteralNode(
         TokenPos(), String::ZoneHandle(Z, type_class_name.raw())));
     result->AddNode(
         MakeStaticCall(Symbols::AbstractClassInstantiationError(),
                        Library::PrivateCoreLibName(Symbols::ThrowNew()),
                        error_arguments));
     return result;
   }
 
   type_arguments ^= type_arguments.Canonicalize();
@@ skipping 157 matching lines @@
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token.
 AstNode* Parser::ParseStringLiteral(bool allow_interpolation) {
   TRACE_PARSER("ParseStringLiteral");
   AstNode* primary = NULL;
-  const intptr_t literal_start = TokenPos();
+  const TokenDescriptor literal_start = TokenPos();
   ASSERT(CurrentToken() == Token::kSTRING);
   Token::Kind l1_token = LookaheadToken(1);
   if ((l1_token != Token::kSTRING) &&
       (l1_token != Token::kINTERPOL_VAR) &&
       (l1_token != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new(Z) LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
@@ skipping 18 matching lines @@
       values_list.Add(new(Z) LiteralNode(TokenPos(), *CurrentLiteral()));
     }
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       if (!allow_interpolation) {
         ReportError("string interpolation not allowed in this context");
       }
       has_interpolation = true;
       AstNode* expr = NULL;
-      const intptr_t expr_pos = TokenPos();
+      const TokenDescriptor expr_pos = TokenPos();
       if (CurrentToken() == Token::kINTERPOL_VAR) {
         expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
         ConsumeToken();
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_START);
         ConsumeToken();
         const bool saved_mode = SetAllowFunctionLiterals(true);
         expr = ParseExpr(kAllowConst, kConsumeCascades);
         SetAllowFunctionLiterals(saved_mode);
         ExpectToken(Token::kINTERPOL_END);
@@ skipping 52 matching lines @@
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   const Token::Kind token = CurrentToken();
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
   } else if (IsIdentifier()) {
-    intptr_t qual_ident_pos = TokenPos();
+    TokenDescriptor qual_ident_pos = TokenPos();
     const LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(Z, ParsePrefix());
     if (!prefix.IsNull()) {
       if (CurrentToken() == Token::kHASH) {
         // Closurization of top-level entity in prefix scope.
         return new(Z) LiteralNode(qual_ident_pos, prefix);
       } else {
         ExpectToken(Token::kPERIOD);
       }
     }
     String& ident = *CurrentLiteral();
@@ skipping 138 matching lines @@
   } else if (token == Token::kHASH) {
     primary = ParseSymbolLiteral();
   } else if (token == Token::kSUPER) {
     if (current_function().is_static()) {
       ReportError("cannot access superclass from static method");
     }
     if (current_class().SuperClass() == Class::null()) {
       ReportError("class '%s' does not have a superclass",
                   String::Handle(Z, current_class().Name()).ToCString());
     }
-    const intptr_t super_pos = TokenPos();
+    const TokenDescriptor super_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
-      const intptr_t ident_pos = TokenPos();
+      const TokenDescriptor ident_pos = TokenPos();
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident, ident_pos);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
         Token::CanBeOverloaded(CurrentToken()) ||
         (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
     } else if (CurrentToken() == Token::kQM_PERIOD) {
       ReportError("super call or super getter may not use ?.");
     } else {
       primary = new(Z) PrimaryNode(super_pos, Symbols::Super());
     }
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
 // Evaluate expression in expr and return the value. The expression must
 // be a compile time constant.
-const Instance& Parser::EvaluateConstExpr(intptr_t expr_pos, AstNode* expr) {
+const Instance& Parser::EvaluateConstExpr(TokenDescriptor expr_pos,
+                                          AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr->AsLiteralNode()->literal();
   } else if (expr->IsLoadLocalNode() &&
       expr->AsLoadLocalNode()->local().IsConst()) {
     return *expr->AsLoadLocalNode()->local().ConstValue();
   } else if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     // We already checked that this field is const and has been
     // initialized.
     ASSERT(field.is_const());
@@ skipping 451 matching lines @@
 }
 
 
 ParsedFunction* Parser::ParseStaticFieldInitializer(const Field& field) {
   UNREACHABLE();
   return NULL;
 }
 
 
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
-    intptr_t call_pos,
+    TokenDescriptor call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME