Replace intptr_t with TokenDescriptor

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 215 matching lines @@
     kParameterEntrySize,
   };
   static RawObject* ParseFunctionParameters(const Function& func);
 
  private:
   friend class EffectGraphVisitor;  // For BuildNoSuchMethodArguments.
 
   struct Block;
   class TryStack;
 
-  Parser(const Script& script, const Library& library, intptr_t token_pos);
-  Parser(const Script& script, ParsedFunction* function, intptr_t token_pos);
+  Parser(const Script& script,
+         const Library& library,
+         TokenDescriptor token_pos);
+  Parser(const Script& script,
+         ParsedFunction* function,
+         TokenDescriptor token_pos);
   ~Parser();
 
   // The function for which we will generate code.
   const Function& current_function() const;
 
   // The innermost function being parsed.
   const Function& innermost_function() const;
 
   // Note that a local function may be parsed multiple times. It is first parsed
   // when its outermost enclosing function is being parsed. It is then parsed
@@ skipping 19 matching lines @@
   // The class being parsed.
   const Class& current_class() const;
   void set_current_class(const Class& value);
 
   // ParsedFunction accessor.
   ParsedFunction* parsed_function() const {
     return parsed_function_;
   }
 
   const Script& script() const { return script_; }
-  void SetScript(const Script& script, intptr_t token_pos);
+  void SetScript(const Script& script, TokenDescriptor token_pos);
 
   const Library& library() const { return library_; }
   void set_library(const Library& value) const { library_ = value.raw(); }
 
   // Parsing a library or a regular source script.
   bool is_library_source() const {
     return (script_.kind() == RawScript::kScriptTag) ||
         (script_.kind() == RawScript::kLibraryTag);
   }
 
   bool is_part_source() const {
     return script_.kind() == RawScript::kSourceTag;
   }
 
   // Parsing library patch script.
   bool is_patch_source() const {
     return script_.kind() == RawScript::kPatchTag;
   }
 
-  intptr_t TokenPos() const { return tokens_iterator_.CurrentPosition(); }
-  intptr_t PrevTokenPos() const { return prev_token_pos_; }
+  TokenDescriptor TokenPos() const {
+    return TokenDescriptor(tokens_iterator_.CurrentPosition());
+  }
+  TokenDescriptor PrevTokenPos() const { return prev_token_pos_; }
 
   Token::Kind CurrentToken() {
     if (token_kind_ == Token::kILLEGAL) {
       ComputeCurrentToken();
     }
     return token_kind_;
   }
 
   void ComputeCurrentToken();
 
   RawLibraryPrefix* ParsePrefix();
 
   Token::Kind LookaheadToken(int num_tokens);
   String* CurrentLiteral() const;
   RawDouble* CurrentDoubleLiteral() const;
   RawInteger* CurrentIntegerLiteral() const;
 
   // Sets parser to given token position in the stream.
   void SetPosition(intptr_t position);
+  void SetPosition(TokenDescriptor position);
 
   void ConsumeToken() {
     // Reset cache and advance the token.
-    prev_token_pos_ = tokens_iterator_.CurrentPosition();
+    prev_token_pos_ = TokenDescriptor(tokens_iterator_.CurrentPosition());
     token_kind_ = Token::kILLEGAL;
     tokens_iterator_.Advance();
     INC_STAT(thread(), num_tokens_consumed, 1);
   }
   void ConsumeRightAngleBracket();
   void CheckToken(Token::Kind token_expected, const char* msg = NULL);
   void ExpectToken(Token::Kind token_expected);
   void ExpectSemicolon();
   void UnexpectedToken();
   String* ExpectUserDefinedTypeIdentifier(const char* msg);
   String* ExpectIdentifier(const char* msg);
   bool IsAwaitKeyword();
   bool IsYieldKeyword();
 
   void SkipIf(Token::Kind);
   void SkipToMatching();
   void SkipToMatchingParenthesis();
   void SkipBlock();
-  intptr_t SkipMetadata();
+  TokenDescriptor SkipMetadata();
   void SkipTypeArguments();
   void SkipType(bool allow_void);
   void SkipInitializers();
   void SkipExpr();
   void SkipNestedExpr();
   void SkipConditionalExpr();
   void SkipBinaryExpr();
   void SkipUnaryExpr();
   void SkipPostfixExpr();
   void SkipSelectors();
   void SkipPrimary();
   void SkipCompoundLiteral();
   void SkipSymbolLiteral();
   void SkipNewOperator();
   void SkipActualParameters();
   void SkipMapLiteral();
   void SkipListLiteral();
   void SkipFunctionLiteral();
   void SkipStringLiteral();
   void SkipQualIdent();
   void SkipFunctionPreamble();
 
   AstNode* DartPrint(const char* str);
 
-  void CheckConstructorCallTypeArguments(intptr_t pos,
+  void CheckConstructorCallTypeArguments(TokenDescriptor pos,
                                          const Function& constructor,
                                          const TypeArguments& type_arguments);
 
   // Report error if parsed code is too deeply nested; avoid stack overflow.
   void CheckStack();
 
   // Report already formatted error.
   static void ReportError(const Error& error);
 
   // Concatenate and report an already formatted error and a new error message.
   static void ReportErrors(const Error& prev_error,
-                           const Script& script, intptr_t token_pos,
+                           const Script& script, TokenDescriptor token_pos,
                            const char* format, ...) PRINTF_ATTRIBUTE(4, 5);
 
   // Report error message at location of current token in current script.
   void ReportError(const char* msg, ...) const PRINTF_ATTRIBUTE(2, 3);
 
   void ReportErrorBefore(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
 
   // Report error message at given location in current script.
-  void ReportError(intptr_t token_pos,
+  void ReportError(TokenDescriptor token_pos,
                    const char* msg, ...) const PRINTF_ATTRIBUTE(3, 4);
 
   // Report warning message at location of current token in current script.
   void ReportWarning(const char* msg, ...) const PRINTF_ATTRIBUTE(2, 3);
 
   // Report warning message at given location in current script.
-  void ReportWarning(intptr_t token_pos,
+  void ReportWarning(TokenDescriptor token_pos,
                      const char* msg, ...) const PRINTF_ATTRIBUTE(3, 4);
 
   void CheckRecursiveInvocation();
 
-  const Instance& EvaluateConstExpr(intptr_t expr_pos, AstNode* expr);
+  const Instance& EvaluateConstExpr(TokenDescriptor expr_pos, AstNode* expr);
   StaticGetterNode* RunStaticFieldInitializer(const Field& field,
-                                              intptr_t field_ref_pos);
+                                              TokenDescriptor field_ref_pos);
   RawObject* EvaluateConstConstructorCall(const Class& type_class,
                                           const TypeArguments& type_arguments,
                                           const Function& constructor,
                                           ArgumentListNode* arguments);
-  LiteralNode* FoldConstExpr(intptr_t expr_pos, AstNode* expr);
+  LiteralNode* FoldConstExpr(TokenDescriptor expr_pos, AstNode* expr);
 
   // Support for parsing of scripts.
   void ParseTopLevel();
   void ParseEnumDeclaration(const GrowableObjectArray& pending_classes,
                             const Object& tl_owner,
-                            intptr_t metadata_pos);
+                            TokenDescriptor metadata_pos);
   void ParseEnumDefinition(const Class& cls);
   void ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                              const Object& tl_owner,
-                             intptr_t metadata_pos);
+                             TokenDescriptor metadata_pos);
   void ParseClassDefinition(const Class& cls);
   void ParseMixinAppAlias(const GrowableObjectArray& pending_classes,
                           const Object& tl_owner,
-                          intptr_t metadata_pos);
+                          TokenDescriptor metadata_pos);
   void ParseTypedef(const GrowableObjectArray& pending_classes,
                     const Object& tl_owner,
-                    intptr_t metadata_pos);
+                    TokenDescriptor metadata_pos);
   void ParseTopLevelVariable(TopLevel* top_level,
-                             const Object& owner, intptr_t metadata_pos);
+                             const Object& owner, TokenDescriptor metadata_pos);
   void ParseTopLevelFunction(TopLevel* top_level,
-                             const Object& owner, intptr_t metadata_pos);
+                             const Object& owner, TokenDescriptor metadata_pos);
   void ParseTopLevelAccessor(TopLevel* top_level,
-                             const Object& owner, intptr_t metadata_pos);
+                             const Object& owner, TokenDescriptor metadata_pos);
   RawArray* EvaluateMetadata();
 
   RawFunction::AsyncModifier ParseFunctionModifier();
 
   // Support for parsing libraries.
   RawObject* CallLibraryTagHandler(Dart_LibraryTag tag,
-                                   intptr_t token_pos,
+                                   TokenDescriptor token_pos,
                                    const String& url);
   void ParseIdentList(GrowableObjectArray* names);
   void ParseLibraryDefinition(const Object& tl_owner);
   void ParseLibraryName();
   void ParseLibraryImportExport(const Object& tl_owner,
-                                intptr_t metadata_pos);
+                                TokenDescriptor metadata_pos);
   void ParseLibraryPart();
   void ParsePartHeader();
   void ParseLibraryNameObsoleteSyntax();
   void ParseLibraryImportObsoleteSyntax();
   void ParseLibraryIncludeObsoleteSyntax();
 
   void ResolveTypeFromClass(const Class& cls,
                             ClassFinalizer::FinalizationKind finalization,
                             AbstractType* type);
   RawAbstractType* ParseType(ClassFinalizer::FinalizationKind finalization,
                              bool allow_deferred_type = false,
                              bool consume_unresolved_prefix = true);
   RawAbstractType* ParseType(
       ClassFinalizer::FinalizationKind finalization,
       bool allow_deferred_type,
       bool consume_unresolved_prefix,
       LibraryPrefix* prefix);
 
   void ParseTypeParameters(const Class& cls);
   RawTypeArguments* ParseTypeArguments(
       ClassFinalizer::FinalizationKind finalization);
   void ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method);
   void ParseFieldDefinition(ClassDesc* members, MemberDesc* field);
   void CheckMemberNameConflict(ClassDesc* members, MemberDesc* member);
   void ParseClassMemberDefinition(ClassDesc* members,
-                                  intptr_t metadata_pos);
+                                  TokenDescriptor metadata_pos);
   void ParseFormalParameter(bool allow_explicit_default_value,
                             bool evaluate_metadata,
                             ParamList* params);
   void ParseFormalParameters(bool allow_explicit_default_values,
                              bool evaluate_metadata,
                              ParamList* params);
   void ParseFormalParameterList(bool allow_explicit_default_values,
                                 bool evaluate_metadata,
                                 ParamList* params);
   void CheckFieldsInitialized(const Class& cls);
   void AddImplicitConstructor(const Class& cls);
   void CheckConstructors(ClassDesc* members);
   AstNode* ParseExternalInitializedField(const Field& field);
   void ParseInitializedInstanceFields(
       const Class& cls,
       LocalVariable* receiver,
       GrowableArray<Field*>* initialized_fields);
   AstNode* CheckDuplicateFieldInit(
-      intptr_t init_pos,
+      TokenDescriptor init_pos,
       GrowableArray<Field*>* initialized_fields,
       AstNode* instance,
       Field* field,
       AstNode* init_value);
   StaticCallNode* GenerateSuperConstructorCall(
       const Class& cls,
-      intptr_t supercall_pos,
+      TokenDescriptor supercall_pos,
       LocalVariable* receiver,
       ArgumentListNode* forwarding_args);
   StaticCallNode* ParseSuperInitializer(
       const Class& cls,
       LocalVariable* receiver);
   AstNode* ParseInitializer(const Class& cls,
                             LocalVariable* receiver,
                             GrowableArray<Field*>* initialized_fields);
   void ParseConstructorRedirection(const Class& cls, LocalVariable* receiver);
   void ParseInitializers(const Class& cls,
                          LocalVariable* receiver,
                          GrowableArray<Field*>* initialized_fields);
   String& ParseNativeDeclaration();
   void ParseInterfaceList(const Class& cls);
   RawAbstractType* ParseMixins(const AbstractType& super_type);
   static StaticCallNode* BuildInvocationMirrorAllocation(
-      intptr_t call_pos,
+      TokenDescriptor call_pos,
       const String& function_name,
       const ArgumentListNode& function_args,
       const LocalVariable* temp,
       bool is_super_invocation);
   // Build arguments for a NoSuchMethodCall. If LocalVariable temp is not NULL,
   // the last argument is stored in temp.
   static ArgumentListNode* BuildNoSuchMethodArguments(
-      intptr_t call_pos,
+      TokenDescriptor call_pos,
       const String& function_name,
       const ArgumentListNode& function_args,
       const LocalVariable* temp,
       bool is_super_invocation);
-  RawFunction* GetSuperFunction(intptr_t token_pos,
+  RawFunction* GetSuperFunction(TokenDescriptor token_pos,
                                 const String& name,
                                 ArgumentListNode* arguments,
                                 bool resolve_getter,
                                 bool* is_no_such_method);
   AstNode* ParseSuperCall(const String& function_name);
-  AstNode* ParseSuperFieldAccess(const String& field_name, intptr_t field_pos);
+  AstNode* ParseSuperFieldAccess(const String& field_name,
+                                 TokenDescriptor field_pos);
   AstNode* ParseSuperOperator();
   AstNode* BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super);
 
   static bool ParseFormalParameters(const Function& func, ParamList* params);
 
   void SetupDefaultsForOptionalParams(const ParamList& params);
   ClosureNode* CreateImplicitClosureNode(const Function& func,
-                                         intptr_t token_pos,
+                                         TokenDescriptor token_pos,
                                          AstNode* receiver);
   static void AddFormalParamsToFunction(const ParamList* params,
                                         const Function& func);
   void AddFormalParamsToScope(const ParamList* params, LocalScope* scope);
 
   SequenceNode* ParseConstructor(const Function& func);
   SequenceNode* ParseFunc(const Function& func, bool check_semicolon);
 
   void ParseNativeFunctionBlock(const ParamList* params, const Function& func);
 
   SequenceNode* ParseInstanceGetter(const Function& func);
   SequenceNode* ParseInstanceSetter(const Function& func);
   SequenceNode* ParseStaticFinalGetter(const Function& func);
   SequenceNode* ParseStaticInitializer();
   SequenceNode* ParseMethodExtractor(const Function& func);
   SequenceNode* ParseNoSuchMethodDispatcher(const Function& func);
   SequenceNode* ParseInvokeFieldDispatcher(const Function& func);
   SequenceNode* ParseImplicitClosure(const Function& func);
   SequenceNode* ParseConstructorClosure(const Function& func);
 
   void BuildDispatcherScope(const Function& func,
                             const ArgumentsDescriptor& desc);
 
-  void EnsureHasReturnStatement(SequenceNode* seq, intptr_t return_pos);
+  void EnsureHasReturnStatement(SequenceNode* seq, TokenDescriptor return_pos);
   void ChainNewBlock(LocalScope* outer_scope);
   void OpenBlock();
   void OpenLoopBlock();
   void OpenFunctionBlock(const Function& func);
   void OpenAsyncClosure();
-  RawFunction* OpenAsyncFunction(intptr_t formal_param_pos);
-  RawFunction* OpenSyncGeneratorFunction(intptr_t func_pos);
+  RawFunction* OpenAsyncFunction(TokenDescriptor formal_param_pos);
+  RawFunction* OpenSyncGeneratorFunction(TokenDescriptor func_pos);
   SequenceNode* CloseSyncGenFunction(const Function& closure,
                                      SequenceNode* closure_node);
   void AddSyncGenClosureParameters(ParamList* params);
   void AddAsyncGenClosureParameters(ParamList* params);
 
   // Support for async* functions.
-  RawFunction* OpenAsyncGeneratorFunction(intptr_t func_pos);
+  RawFunction* OpenAsyncGeneratorFunction(TokenDescriptor func_pos);
   SequenceNode* CloseAsyncGeneratorFunction(const Function& closure,
                                             SequenceNode* closure_node);
   void OpenAsyncGeneratorClosure();
   SequenceNode* CloseAsyncGeneratorClosure(SequenceNode* body);
 
   void OpenAsyncTryBlock();
   SequenceNode* CloseBlock();
   SequenceNode* CloseAsyncFunction(const Function& closure,
                                    SequenceNode* closure_node);
 
   SequenceNode* CloseAsyncClosure(SequenceNode* body);
   SequenceNode* CloseAsyncTryBlock(SequenceNode* try_block);
   SequenceNode* CloseAsyncGeneratorTryBlock(SequenceNode *body);
 
   void AddAsyncClosureParameters(ParamList* params);
   void AddContinuationVariables();
   void AddAsyncClosureVariables();
   void AddAsyncGeneratorVariables();
 
   LocalVariable* LookupReceiver(LocalScope* from_scope, bool test_only);
   LocalVariable* LookupTypeArgumentsParameter(LocalScope* from_scope,
                                               bool test_only);
   void CaptureInstantiator();
-  AstNode* LoadReceiver(intptr_t token_pos);
+  AstNode* LoadReceiver(TokenDescriptor token_pos);
   AstNode* LoadFieldIfUnresolved(AstNode* node);
   AstNode* LoadClosure(PrimaryNode* primary);
-  InstanceGetterNode* CallGetter(intptr_t token_pos,
+  InstanceGetterNode* CallGetter(TokenDescriptor token_pos,
                                  AstNode* object,
                                  const String& name);
 
   AstNode* ParseAssertStatement();
   AstNode* ParseJump(String* label_name);
   AstNode* ParseIfStatement(String* label_name);
   AstNode* ParseWhileStatement(String* label_name);
   AstNode* ParseDoWhileStatement(String* label_name);
   AstNode* ParseForStatement(String* label_name);
   AstNode* ParseAwaitForStatement(String* label_name);
-  AstNode* ParseForInStatement(intptr_t forin_pos, SourceLabel* label);
+  AstNode* ParseForInStatement(TokenDescriptor forin_pos, SourceLabel* label);
   RawClass* CheckCaseExpressions(const GrowableArray<LiteralNode*>& values);
   CaseNode* ParseCaseClause(LocalVariable* switch_expr_value,
                             GrowableArray<LiteralNode*>* case_expr_values,
                             SourceLabel* case_label);
   AstNode* ParseSwitchStatement(String* label_name);
 
   // try/catch/finally parsing.
   void AddCatchParamsToScope(CatchParamDesc* exception_param,
                              CatchParamDesc* stack_trace_param,
                              LocalScope* scope);
   void SetupExceptionVariables(LocalScope* try_scope,
                                bool is_async,
                                LocalVariable** context_var,
                                LocalVariable** exception_var,
                                LocalVariable** stack_trace_var,
                                LocalVariable** saved_exception_var,
                                LocalVariable** saved_stack_trace_var);
   void SaveExceptionAndStacktrace(SequenceNode* statements,
                                   LocalVariable* exception_var,
                                   LocalVariable* stack_trace_var,
                                   LocalVariable* saved_exception_var,
                                   LocalVariable* saved_stack_trace_var);
   // Parse all the catch clause of a try.
-  SequenceNode* ParseCatchClauses(intptr_t handler_pos,
+  SequenceNode* ParseCatchClauses(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);
   // Parse or generate a finally clause.
   SequenceNode* EnsureFinallyClause(bool parse,
                                     bool is_async,
@@ skipping 62 matching lines @@
   AstNode* ParseUnaryExpr();
   AstNode* ParsePostfixExpr();
   AstNode* ParseSelectors(AstNode* primary, bool is_cascade);
   AstNode* ParseClosurization(AstNode* primary);
   AstNode* ParseCascades(AstNode* expr);
   AstNode* ParsePrimary();
   AstNode* ParseStringLiteral(bool allow_interpolation);
   String* ParseImportStringLiteral();
   AstNode* ParseCompoundLiteral();
   AstNode* ParseSymbolLiteral();
-  AstNode* ParseListLiteral(intptr_t type_pos,
+  AstNode* ParseListLiteral(TokenDescriptor type_pos,
                             bool is_const,
                             const TypeArguments& type_arguments);
-  AstNode* ParseMapLiteral(intptr_t type_pos,
+  AstNode* ParseMapLiteral(TokenDescriptor type_pos,
                            bool is_const,
                            const TypeArguments& type_arguments);
 
   RawFunction* BuildConstructorClosureFunction(const Function& ctr,
-                                               intptr_t token_pos);
+                                               TokenDescriptor token_pos);
   AstNode* ParseNewOperator(Token::Kind op_kind);
   void ParseConstructorClosurization(Function* constructor,
                                      TypeArguments* type_arguments);
 
   // An implicit argument, if non-null, is prepended to the returned list.
   ArgumentListNode* ParseActualParameters(ArgumentListNode* implicit_arguments,
                                           bool require_const);
   AstNode* ParseStaticCall(const Class& cls,
                            const String& method_name,
-                           intptr_t ident_pos);
+                           TokenDescriptor ident_pos);
   AstNode* ParseInstanceCall(AstNode* receiver,
                              const String& method_name,
-                             intptr_t ident_pos,
+                             TokenDescriptor ident_pos,
                              bool is_conditional);
   AstNode* ParseClosureCall(AstNode* closure);
   AstNode* GenerateStaticFieldLookup(const Field& field,
-                                     intptr_t ident_pos);
+                                     TokenDescriptor ident_pos);
   AstNode* GenerateStaticFieldAccess(const Class& cls,
                                      const String& field_name,
-                                     intptr_t ident_pos);
+                                     TokenDescriptor ident_pos);
 
   LocalVariable* LookupLocalScope(const String& ident);
-  void CheckInstanceFieldAccess(intptr_t field_pos, const String& field_name);
+  void CheckInstanceFieldAccess(TokenDescriptor field_pos,
+                                const String& field_name);
   bool ParsingStaticMember() const;
   const AbstractType* ReceiverType(const Class& cls);
   bool IsInstantiatorRequired() const;
-  bool ResolveIdentInLocalScope(intptr_t ident_pos,
+  bool ResolveIdentInLocalScope(TokenDescriptor ident_pos,
                                 const String &ident,
                                 AstNode** node);
   static const bool kResolveLocally = true;
   static const bool kResolveIncludingImports = false;
 
   // Resolve a primary identifier in the library or prefix scope and
   // generate the corresponding AstNode.
-  AstNode* ResolveIdentInCurrentLibraryScope(intptr_t ident_pos,
+  AstNode* ResolveIdentInCurrentLibraryScope(TokenDescriptor ident_pos,
                                              const String& ident);
-  AstNode* ResolveIdentInPrefixScope(intptr_t ident_pos,
+  AstNode* ResolveIdentInPrefixScope(TokenDescriptor ident_pos,
                                      const LibraryPrefix& prefix,
                                      const String& ident);
 
-  AstNode* ResolveIdent(intptr_t ident_pos,
+  AstNode* ResolveIdent(TokenDescriptor ident_pos,
                         const String& ident,
                         bool allow_closure_names);
-  RawString* ResolveImportVar(intptr_t ident_pos, const String& ident);
-  AstNode* OptimizeBinaryOpNode(intptr_t op_pos,
+  RawString* ResolveImportVar(TokenDescriptor ident_pos, const String& ident);
+  AstNode* OptimizeBinaryOpNode(TokenDescriptor op_pos,
                                 Token::Kind binary_op,
                                 AstNode* lhs,
                                 AstNode* rhs);
-  AstNode* ExpandAssignableOp(intptr_t op_pos,
+  AstNode* ExpandAssignableOp(TokenDescriptor op_pos,
                               Token::Kind assignment_op,
                               AstNode* lhs,
                               AstNode* rhs);
   LetNode* PrepareCompoundAssignmentNodes(AstNode** expr);
-  LocalVariable* CreateTempConstVariable(intptr_t token_pos, const char* s);
+  LocalVariable* CreateTempConstVariable(TokenDescriptor token_pos,
+                                         const char* s);
 
-  static SequenceNode* NodeAsSequenceNode(intptr_t sequence_pos,
+  static SequenceNode* NodeAsSequenceNode(TokenDescriptor sequence_pos,
                                           AstNode* node,
                                           LocalScope* scope);
 
   SequenceNode* MakeImplicitConstructor(const Function& func);
   AstNode* MakeStaticCall(const String& cls_name,
                           const String& func_name,
                           ArgumentListNode* arguments);
   String& Interpolate(const GrowableArray<AstNode*>& values);
-  AstNode* MakeAssertCall(intptr_t begin, intptr_t end);
-  AstNode* ThrowTypeError(intptr_t type_pos, const AbstractType& type,
-                           LibraryPrefix* prefix = NULL);
-  AstNode* ThrowNoSuchMethodError(intptr_t call_pos,
+  AstNode* MakeAssertCall(TokenDescriptor begin, TokenDescriptor end);
+  AstNode* ThrowTypeError(TokenDescriptor type_pos,
+                          const AbstractType& type,
+                          LibraryPrefix* prefix = NULL);
+  AstNode* ThrowNoSuchMethodError(TokenDescriptor call_pos,
                                   const Class& cls,
                                   const String& function_name,
                                   ArgumentListNode* function_arguments,
                                   InvocationMirror::Call call,
                                   InvocationMirror::Type type,
                                   const Function* func,
                                   const LibraryPrefix* prefix = NULL);
 
   void SetupSavedTryContext(LocalVariable* saved_try_context);
 
   void CheckOperatorArity(const MemberDesc& member);
 
   void EnsureExpressionTemp();
-  bool IsLegalAssignableSyntax(AstNode* expr, intptr_t end_pos);
+  bool IsLegalAssignableSyntax(AstNode* expr, TokenDescriptor end_pos);
   AstNode* CreateAssignmentNode(AstNode* original,
                                 AstNode* rhs,
                                 const String* left_ident,
-                                intptr_t left_pos,
+                                TokenDescriptor left_pos,
                                 bool is_compound = false);
   AstNode* InsertClosureCallNodes(AstNode* condition);
 
   ConstructorCallNode* CreateConstructorCallNode(
-      intptr_t token_pos,
+      TokenDescriptor token_pos,
       const TypeArguments& type_arguments,
       const Function& constructor,
       ArgumentListNode* arguments);
 
   void AddEqualityNullCheck();
 
-  AstNode* BuildClosureCall(intptr_t token_pos,
+  AstNode* BuildClosureCall(TokenDescriptor token_pos,
                             AstNode* closure,
                             ArgumentListNode* arguments);
 
-  RawInstance* TryCanonicalize(const Instance& instance, intptr_t token_pos);
-  void CacheConstantValue(intptr_t token_pos, const Instance& value);
-  bool GetCachedConstant(intptr_t token_pos, Instance* value);
+  RawInstance* TryCanonicalize(const Instance& instance,
+                               TokenDescriptor token_pos);
+  void CacheConstantValue(TokenDescriptor token_pos, const Instance& value);
+  bool GetCachedConstant(TokenDescriptor token_pos, Instance* value);
 
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return isolate_; }
   Zone* zone() const { return thread_->zone(); }
 
   Isolate* isolate_;  // Cached current isolate.
   Thread* thread_;
 
   Script& script_;
   TokenStream::Iterator tokens_iterator_;
   Token::Kind token_kind_;  // Cached token kind for current token.
-  intptr_t prev_token_pos_;
+  TokenDescriptor prev_token_pos_;
   Block* current_block_;
 
   // is_top_level_ is true if parsing the "top level" of a compilation unit,
   // that is class definitions, function type aliases, global functions,
   // global variables.
   bool is_top_level_;
 
   // await_is_keyword_ is true if we are parsing an async or generator
   // function. In this context the identifiers await, async and yield
   // are treated as keywords.
@@ skipping 45 matching lines @@
 
   intptr_t recursion_counter_;
   friend class RecursionChecker;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_