Replace intptr_t with TokenDescriptor

runtime/vm/object.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_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/json_stream.h"
 #include "vm/bitmap.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/method_recognizer.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/report.h"
 #include "vm/scanner.h"
 #include "vm/tags.h"
 #include "vm/thread.h"
+#include "vm/token_descriptor.h"
 #include "vm/verified_memory.h"
 
 namespace dart {
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
@@ skipping 895 matching lines @@
   RawString* Name() const;
   RawString* PrettyName() const;
   RawString* UserVisibleName() const;
   bool IsInFullSnapshot() const;
 
   virtual RawString* DictionaryName() const { return Name(); }
 
   RawScript* script() const { return raw_ptr()->script_; }
   void set_script(const Script& value) const;
 
-  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
-  void set_token_pos(intptr_t value) const;
+  TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
+  void set_token_pos(TokenDescriptor value) const;
 
-  intptr_t ComputeEndTokenPos() const;
+  TokenDescriptor ComputeEndTokenPos() const;
 
   // This class represents a typedef if the signature function is not null.
   RawFunction* signature_function() const {
     return raw_ptr()->signature_function_;
   }
   void set_signature_function(const Function& value) const;
 
   // Return the Type with type parameters declared by this class filled in with
   // dynamic and type parameters declared in superclasses filled in as declared
   // in superclass clauses.
@@ skipping 344 matching lines @@
                       const Array& param_values) const;
 
   RawError* EnsureIsFinalized(Thread* thread) const;
 
   // Allocate a class used for VM internal objects.
   template <class FakeObject> static RawClass* New();
 
   // Allocate instance classes.
   static RawClass* New(const String& name,
                        const Script& script,
-                       intptr_t token_pos);
+                       TokenDescriptor token_pos);
   static RawClass* NewNativeWrapper(const Library& library,
                                     const String& name,
                                     int num_fields);
 
   // Allocate the raw string classes.
   static RawClass* NewStringClass(intptr_t class_id);
 
   // Allocate the raw TypedData classes.
   static RawClass* NewTypedDataClass(intptr_t class_id);
 
@@ skipping 142 matching lines @@
 
 
 // Unresolved class is used for storing unresolved names which will be resolved
 // to a class after all classes have been loaded and finalized.
 class UnresolvedClass : public Object {
  public:
   RawLibraryPrefix* library_prefix() const {
     return raw_ptr()->library_prefix_;
   }
   RawString* ident() const { return raw_ptr()->ident_; }
-  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
+  TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
 
   RawString* Name() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnresolvedClass));
   }
 
   static RawUnresolvedClass* New(const LibraryPrefix& library_prefix,
                                  const String& ident,
-                                 intptr_t token_pos);
+                                 TokenDescriptor token_pos);
 
  private:
   void set_library_prefix(const LibraryPrefix& library_prefix) const;
   void set_ident(const String& ident) const;
-  void set_token_pos(intptr_t token_pos) const;
+  void set_token_pos(TokenDescriptor token_pos) const;
 
   static RawUnresolvedClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
 typedef ZoneGrowableHandlePtrArray<const AbstractType> Trail;
 typedef ZoneGrowableHandlePtrArray<const AbstractType>* TrailPtr;
@@ skipping 492 matching lines @@
         return "?";
     }
   }
 
   // It is only meaningful to interptret range feedback stored in the ICData
   // when all checks are Mint or Smi.
   bool HasRangeFeedback() const;
   RangeFeedback DecodeRangeFeedbackAt(intptr_t idx) const;
 
   void PrintToJSONArray(const JSONArray& jsarray,
-                        intptr_t token_pos,
+                        TokenDescriptor token_pos,
                         bool is_static_call) const;
   void PrintToJSONArrayNew(const JSONArray& jsarray,
-                           intptr_t token_pos,
+                           TokenDescriptor token_pos,
                            bool is_static_call) const;
 
   // Initialize the preallocated empty ICData entry arrays.
   static void InitOnce();
 
   enum {
     kCachedICDataArrayCount = 4
   };
 
  private:
@@ skipping 291 matching lines @@
       case RawFunction::kClosureFunction:
       case RawFunction::kConstructor:
         return false;
       default:
         UNREACHABLE();
         return false;
     }
   }
   bool IsInFactoryScope() const;
 
-  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
-  void set_token_pos(intptr_t value) const;
+  TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
+  void set_token_pos(TokenDescriptor value) const;
 
-  intptr_t end_token_pos() const { return raw_ptr()->end_token_pos_; }
-  void set_end_token_pos(intptr_t value) const {
+  TokenDescriptor end_token_pos() const { return raw_ptr()->end_token_pos_; }
+  void set_end_token_pos(TokenDescriptor value) const {
     StoreNonPointer(&raw_ptr()->end_token_pos_, value);
   }
 
   intptr_t num_fixed_parameters() const {
     return raw_ptr()->num_fixed_parameters_;
   }
   void set_num_fixed_parameters(intptr_t value) const;
 
   bool HasOptionalParameters() const {
     return raw_ptr()->num_optional_parameters_ != 0;
@@ skipping 267 matching lines @@
   }
 
   static RawFunction* New(const String& name,
                           RawFunction::Kind kind,
                           bool is_static,
                           bool is_const,
                           bool is_abstract,
                           bool is_external,
                           bool is_native,
                           const Object& owner,
-                          intptr_t token_pos);
+                          TokenDescriptor token_pos);
 
   // Allocates a new Function object representing a closure function.
   static RawFunction* NewClosureFunction(const String& name,
                                          const Function& parent,
-                                         intptr_t token_pos);
+                                         TokenDescriptor token_pos);
 
   // Allocates a new Function object representing a signature function.
   // The owner is the scope class of the function type.
   static RawFunction* NewSignatureFunction(const Class& owner,
-                                           intptr_t token_pos);
+                                           TokenDescriptor token_pos);
 
   static RawFunction* NewEvalFunction(const Class& owner,
                                       const Script& script,
                                       bool is_static);
 
   RawFunction* CreateMethodExtractor(const String& getter_name) const;
   RawFunction* GetMethodExtractor(const String& getter_name) const;
 
   // Allocate new function object, clone values from this function. The
   // owner of the clone is new_owner.
@@ skipping 272 matching lines @@
     return RoundedAllocationSize(sizeof(RawField));
   }
 
   static RawField* New(const String& name,
                        bool is_static,
                        bool is_final,
                        bool is_const,
                        bool is_reflectable,
                        const Class& owner,
                        const AbstractType& type,
-                       intptr_t token_pos);
+                       TokenDescriptor token_pos);
 
   static RawField* NewTopLevel(const String& name,
                                bool is_final,
                                bool is_const,
                                const Object& owner,
-                               intptr_t token_pos);
+                               TokenDescriptor token_pos);
 
   // Allocate new field object, clone values from this field. The
   // owner of the clone is new_owner.
   RawField* Clone(const Class& new_owner) const;
 
   static intptr_t instance_field_offset() {
     return OFFSET_OF(RawField, value_.offset_);
   }
   static intptr_t static_value_offset() {
     return OFFSET_OF(RawField, value_.static_value_);
   }
 
   static intptr_t kind_bits_offset() { return OFFSET_OF(RawField, kind_bits_); }
 
-  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
+  TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
 
   bool has_initializer() const {
     return HasInitializerBit::decode(raw_ptr()->kind_bits_);
   }
   // Called by parser after allocating field.
   void set_has_initializer(bool has_initializer) const {
     ASSERT(Thread::Current()->IsMutatorThread());
     set_kind_bits(HasInitializerBit::update(has_initializer,
                                             raw_ptr()->kind_bits_));
   }
@@ skipping 157 matching lines @@
   }
   void set_is_final(bool is_final) const {
     set_kind_bits(FinalBit::update(is_final, raw_ptr()->kind_bits_));
   }
   void set_is_const(bool value) const {
     set_kind_bits(ConstBit::update(value, raw_ptr()->kind_bits_));
   }
   void set_owner(const Object& value) const {
     StorePointer(&raw_ptr()->owner_, value.raw());
   }
-  void set_token_pos(intptr_t token_pos) const {
+  void set_token_pos(TokenDescriptor token_pos) const {
     StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
   }
   void set_kind_bits(intptr_t value) const {
     StoreNonPointer(&raw_ptr()->kind_bits_, static_cast<uint8_t>(value));
   }
 
   static RawField* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Field, Object);
   friend class Class;
@@ skipping 29 matching lines @@
 
 class TokenStream : public Object {
  public:
   RawGrowableObjectArray* TokenObjects() const;
   void SetTokenObjects(const GrowableObjectArray& value) const;
 
   RawExternalTypedData* GetStream() const;
   void SetStream(const ExternalTypedData& stream) const;
 
   RawString* GenerateSource() const;
-  RawString* GenerateSource(intptr_t start, intptr_t end) const;
-  intptr_t ComputeSourcePosition(intptr_t tok_pos) const;
+  RawString* GenerateSource(TokenDescriptor start,
+                            TokenDescriptor end) const;
+  TokenDescriptor ComputeSourcePosition(TokenDescriptor tok_pos) const;
 
   RawString* PrivateKey() const;
 
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTokenStream));
   }
 
@@ skipping 11 matching lines @@
    public:
     enum StreamType {
       kNoNewlines,
       kAllTokens
     };
 
     Iterator(const TokenStream& tokens,
              intptr_t token_pos,
              Iterator::StreamType stream_type = kNoNewlines);
 
+    Iterator(const TokenStream& tokens,
+             TokenDescriptor token_pos,
+             Iterator::StreamType stream_type = kNoNewlines);
+
     void SetStream(const TokenStream& tokens, intptr_t token_pos);
+    void SetStream(const TokenStream& tokens, TokenDescriptor token_pos);
     bool IsValid() const;
 
     inline Token::Kind CurrentTokenKind() const {
       return cur_token_kind_;
     }
 
     Token::Kind LookaheadTokenKind(intptr_t num_tokens);
 
     intptr_t CurrentPosition() const;
     void SetCurrentPosition(intptr_t value);
+    void SetCurrentPosition(TokenDescriptor token_pos);
 
     void Advance();
 
     RawObject* CurrentToken() const;
     RawString* CurrentLiteral() const;
     RawString* MakeLiteralToken(const Object& obj) const;
 
    private:
     // Read token from the token stream (could be a simple token or an index
     // into the token objects array for IDENT or literal tokens).
@@ skipping 49 matching lines @@
   RawLibrary* FindLibrary() const;
   RawString* GetLine(intptr_t line_number,
                      Heap::Space space = Heap::kNew) const;
   RawString* GetSnippet(intptr_t from_line,
                         intptr_t from_column,
                         intptr_t to_line,
                         intptr_t to_column) const;
 
   void SetLocationOffset(intptr_t line_offset, intptr_t col_offset) const;
 
-  void GetTokenLocation(intptr_t token_pos,
+  void GetTokenLocation(TokenDescriptor token_pos,
                         intptr_t* line,
                         intptr_t* column,
                         intptr_t* token_len = NULL) const;
 
   // Returns index of first and last token on the given line. Returns both
   // indices < 0 if no token exists on or after the line. If a token exists
   // after, but not on given line, returns in *first_token_index the index of
   // the first token after the line, and a negative value in *last_token_index.
   void TokenRangeAtLine(intptr_t line_number,
-                        intptr_t* first_token_index,
-                        intptr_t* last_token_index) const;
+                        TokenDescriptor* first_token_index,
+                        TokenDescriptor* last_token_index) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawScript));
   }
 
   static RawScript* New(const String& url,
                         const String& source,
                         RawScript::Kind kind);
 
  private:
@@ skipping 147 matching lines @@
   // look in the scopes of all libraries that are imported
   // without a library prefix.
   RawObject* ResolveName(const String& name) const;
 
   void AddAnonymousClass(const Class& cls) const;
 
   void AddExport(const Namespace& ns) const;
 
   void AddClassMetadata(const Class& cls,
                         const Object& tl_owner,
-                        intptr_t token_pos) const;
-  void AddFieldMetadata(const Field& field, intptr_t token_pos) const;
-  void AddFunctionMetadata(const Function& func, intptr_t token_pos) const;
-  void AddLibraryMetadata(const Object& tl_owner, intptr_t token_pos) const;
+                        TokenDescriptor token_pos) const;
+  void AddFieldMetadata(const Field& field, TokenDescriptor token_pos) const;
+  void AddFunctionMetadata(const Function& func,
+                           TokenDescriptor token_pos) const;
+  void AddLibraryMetadata(const Object& tl_owner,
+                          TokenDescriptor token_pos) const;
   void AddTypeParameterMetadata(const TypeParameter& param,
-                                intptr_t token_pos) const;
+                                TokenDescriptor token_pos) const;
   RawObject* GetMetadata(const Object& obj) const;
 
   RawClass* toplevel_class() const {
     return raw_ptr()->toplevel_class_;
   }
   void set_toplevel_class(const Class& value) const;
 
   RawGrowableObjectArray* patch_classes() const {
     return raw_ptr()->patch_classes_;
   }
@@ skipping 136 matching lines @@
                                       bool import_core_lib);
   RawObject* LookupEntry(const String& name, intptr_t *index) const;
 
   static bool IsKeyUsed(intptr_t key);
   void AllocatePrivateKey() const;
 
   RawString* MakeMetadataName(const Object& obj) const;
   RawField* GetMetadataField(const String& metaname) const;
   void AddMetadata(const Object& owner,
                    const String& name,
-                   intptr_t token_pos) const;
+                   TokenDescriptor token_pos) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Library, Object);
 
   friend class Bootstrap;
   friend class Class;
   friend class Debugger;
   friend class DictionaryIterator;
   friend class Namespace;
   friend class Object;
 };
 
 
 // A Namespace contains the names in a library dictionary, filtered by
 // the show/hide combinators.
 class Namespace : public Object {
  public:
   RawLibrary* library() const { return raw_ptr()->library_; }
   RawArray* show_names() const { return raw_ptr()->show_names_; }
   RawArray* hide_names() const { return raw_ptr()->hide_names_; }
 
-  void AddMetadata(const Object& owner, intptr_t token_pos);
+  void AddMetadata(const Object& owner, TokenDescriptor token_pos);
   RawObject* GetMetadata() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawNamespace));
   }
 
   bool HidesName(const String& name) const;
   RawObject* Lookup(const String& name) const;
 
   static RawNamespace* New(const Library& library,
@@ skipping 276 matching lines @@
 
         if ((cur_kind_ & kind_mask_) != 0) {
           return true;  // Current is valid.
         }
       }
       return false;
     }
 
     uword PcOffset() const { return cur_pc_offset_; }
     intptr_t DeoptId() const { return cur_deopt_id_; }
-    intptr_t TokenPos() const { return cur_token_pos_; }
+    TokenDescriptor TokenPos() const { return TokenDescriptor(cur_token_pos_); }
     intptr_t TryIndex() const { return cur_try_index_; }
     RawPcDescriptors::Kind Kind() const {
       return static_cast<RawPcDescriptors::Kind>(cur_kind_);
     }
 
    private:
     friend class PcDescriptors;
 
     // For nested iterations, starting at element after.
     explicit Iterator(const Iterator& iter)
@@ skipping 72 matching lines @@
       while (byte_index_ < code_source_map_.Length()) {
         cur_pc_offset_ += code_source_map_.DecodeInteger(&byte_index_);
         cur_token_pos_ += code_source_map_.DecodeInteger(&byte_index_);
 
         return true;
       }
       return false;
     }
 
     uword PcOffset() const { return cur_pc_offset_; }
-    intptr_t TokenPos() const { return cur_token_pos_; }
+    TokenDescriptor TokenPos() const { return TokenDescriptor(cur_token_pos_); }
 
    private:
     friend class CodeSourceMap;
 
     const CodeSourceMap& code_source_map_;
     intptr_t byte_index_;
 
     intptr_t cur_pc_offset_;
     intptr_t cur_token_pos_;
   };
@@ skipping 413 matching lines @@
                                Assembler* assembler,
                                bool optimized);
   static RawCode* LookupCode(uword pc);
   static RawCode* LookupCodeInVmIsolate(uword pc);
   static RawCode* FindCode(uword pc, int64_t timestamp);
 
   int32_t GetPointerOffsetAt(int index) const {
     NoSafepointScope no_safepoint;
     return *PointerOffsetAddrAt(index);
   }
-  intptr_t GetTokenIndexOfPC(uword pc) const;
+  TokenDescriptor GetTokenIndexOfPC(uword pc) const;
 
   enum {
     kInvalidPc = -1
   };
 
   uword GetLazyDeoptPc() const;
 
   // Find pc, return 0 if not found.
   uword GetPcForDeoptId(intptr_t deopt_id, RawPcDescriptors::Kind kind) const;
   intptr_t GetDeoptIdForOsr(uword pc) const;
@@ skipping 184 matching lines @@
 // functions enclosing the local function. Each captured variable is represented
 // by its token position in the source, its name, its type, its allocation index
 // in the context, and its context level. The function nesting level and loop
 // nesting level are not preserved, since they are only used until the context
 // level is assigned. In addition the ContextScope has a field 'is_implicit'
 // which is true if the ContextScope was created for an implicit closure.
 class ContextScope : public Object {
  public:
   intptr_t num_variables() const { return raw_ptr()->num_variables_; }
 
-  intptr_t TokenIndexAt(intptr_t scope_index) const;
-  void SetTokenIndexAt(intptr_t scope_index, intptr_t token_pos) const;
+  TokenDescriptor TokenIndexAt(intptr_t scope_index) const;
+  void SetTokenIndexAt(intptr_t scope_index, TokenDescriptor token_pos) const;
 
   RawString* NameAt(intptr_t scope_index) const;
   void SetNameAt(intptr_t scope_index, const String& name) const;
 
   bool IsFinalAt(intptr_t scope_index) const;
   void SetIsFinalAt(intptr_t scope_index, bool is_final) const;
 
   bool IsConstAt(intptr_t scope_index) const;
   void SetIsConstAt(intptr_t scope_index, bool is_const) const;
 
@@ skipping 203 matching lines @@
   // Build, cache, and return formatted message.
   RawString* FormatMessage() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawLanguageError));
   }
 
   // A null script means no source and a negative token_pos means no position.
   static RawLanguageError* NewFormatted(const Error& prev_error,
                                         const Script& script,
-                                        intptr_t token_pos,
+                                        TokenDescriptor token_pos,
                                         bool report_after_token,
                                         Report::Kind kind,
                                         Heap::Space space,
                                         const char* format, ...)
     PRINTF_ATTRIBUTE(7, 8);
 
   static RawLanguageError* NewFormattedV(const Error& prev_error,
                                          const Script& script,
-                                         intptr_t token_pos,
+                                         TokenDescriptor token_pos,
                                          bool report_after_token,
                                          Report::Kind kind,
                                          Heap::Space space,
                                          const char* format, va_list args);
 
   static RawLanguageError* New(const String& formatted_message,
                                Report::Kind kind = Report::kError,
                                Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
   RawError* previous_error() const {
     return raw_ptr()->previous_error_;
   }
   void set_previous_error(const Error& value) const;
 
   RawScript* script() const { return raw_ptr()->script_; }
   void set_script(const Script& value) const;
 
-  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
-  void set_token_pos(intptr_t value) const;
+  TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
+  void set_token_pos(TokenDescriptor value) const;
 
   bool report_after_token() const { return raw_ptr()->report_after_token_; }
   void set_report_after_token(bool value);
 
   void set_kind(uint8_t value) const;
 
   RawString* message() const { return raw_ptr()->message_; }
   void set_message(const String& value) const;
 
   RawString* formatted_message() const { return raw_ptr()->formatted_message_; }
@@ skipping 262 matching lines @@
   virtual bool IsMalformedOrMalbounded() const;
   virtual RawLanguageError* error() const;
   virtual void set_error(const LanguageError& value) const;
   virtual bool IsResolved() const;
   virtual void SetIsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual void set_arguments(const TypeArguments& value) const;
-  virtual intptr_t token_pos() const;
+  virtual TokenDescriptor token_pos() const;
   virtual bool IsInstantiated(TrailPtr trail = NULL) const;
   virtual bool CanonicalizeEquals(const Instance& other) const {
     return Equals(other);
   }
   virtual bool Equals(const Instance& other) const {
     return IsEquivalent(other);
   }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
 
@@ skipping 166 matching lines @@
   virtual bool IsResolved() const {
     return raw_ptr()->type_state_ >= RawType::kResolved;
   }
   virtual void SetIsResolved() const;
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
   void set_type_class(const Object& value) const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const { return raw_ptr()->arguments_; }
   virtual void set_arguments(const TypeArguments& value) const;
-  virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
+  virtual TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated(TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr trail = NULL,
       Heap::Space space = Heap::kNew) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* CloneUninstantiated(
@@ skipping 53 matching lines @@
   static RawType* ArrayType();
 
   // The 'Function' type.
   static RawType* Function();
 
   // The finalized type of the given non-parameterized class.
   static RawType* NewNonParameterizedType(const Class& type_class);
 
   static RawType* New(const Object& clazz,
                       const TypeArguments& arguments,
-                      intptr_t token_pos,
+                      TokenDescriptor token_pos,
                       Heap::Space space = Heap::kOld);
 
  private:
-  void set_token_pos(intptr_t token_pos) const;
+  void set_token_pos(TokenDescriptor token_pos) const;
   void set_type_state(int8_t state) const;
 
   static RawType* New(Heap::Space space = Heap::kOld);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
   friend class TypeArguments;
 };
 
 
@@ skipping 48 matching lines @@
   // IsDynamicType(), IsBoolType(), etc...
   virtual bool HasResolvedTypeClass() const { return false; }
   // Return scope_class from virtual type_class() to factorize finalization
   // with Type, also a parameterized type.
   virtual RawClass* type_class() const { return scope_class(); }
   RawClass* scope_class() const { return raw_ptr()->scope_class_; }
   void set_scope_class(const Class& value) const;
   virtual RawTypeArguments* arguments() const { return raw_ptr()->arguments_; }
   virtual void set_arguments(const TypeArguments& value) const;
   RawFunction* signature() const { return raw_ptr()->signature_; }
-  virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
+  virtual TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated(TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* malformed_error,
       TrailPtr trail = NULL,
       Heap::Space space = Heap::kNew) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* CloneUninstantiated(
       const Class& new_owner,
       TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFunctionType));
   }
 
   static RawFunctionType* New(const Class& scope_class,
                               const TypeArguments& arguments,
                               const Function& signature,
-                              intptr_t token_pos,
+                              TokenDescriptor token_pos,
                               Heap::Space space = Heap::kOld);
 
  private:
   void set_signature(const Function& value) const;
-  void set_token_pos(intptr_t token_pos) const;
+  void set_token_pos(TokenDescriptor token_pos) const;
   void set_type_state(int8_t state) const;
 
   static RawFunctionType* New(Heap::Space space = Heap::kOld);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(FunctionType, AbstractType);
   friend class Class;
   friend class TypeArguments;
 };
 
 
@@ skipping 23 matching lines @@
     return AbstractType::Handle(type()).HasResolvedTypeClass();
   }
   RawAbstractType* type() const { return raw_ptr()->type_; }
   void set_type(const AbstractType& value) const;
   virtual RawClass* type_class() const {
     return AbstractType::Handle(type()).type_class();
   }
   virtual RawTypeArguments* arguments() const {
     return AbstractType::Handle(type()).arguments();
   }
-  virtual intptr_t token_pos() const {
+  virtual TokenDescriptor token_pos() const {
     return AbstractType::Handle(type()).token_pos();
   }
   virtual bool IsInstantiated(TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other,
                             TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return true; }
   virtual RawTypeRef* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr trail = NULL,
@@ skipping 62 matching lines @@
   RawAbstractType* bound() const { return raw_ptr()->bound_; }
   void set_bound(const AbstractType& value) const;
   // Returns true if bounded_type is below upper_bound, otherwise return false
   // and set bound_error if both bounded_type and upper_bound are instantiated.
   // If one or both are not instantiated, returning false only means that the
   // bound cannot be checked yet and this is not an error.
   bool CheckBound(const AbstractType& bounded_type,
                   const AbstractType& upper_bound,
                   Error* bound_error,
                   Heap::Space space = Heap::kNew) const;
-  virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
+  virtual TokenDescriptor token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated(TrailPtr trail = NULL) const {
     return false;
   }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return false; }
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr trail = NULL,
       Heap::Space space = Heap::kNew) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* CloneUninstantiated(
       const Class& new_owner, TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const {
     return raw();
   }
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTypeParameter));
   }
 
   static RawTypeParameter* New(const Class& parameterized_class,
                                intptr_t index,
                                const String& name,
                                const AbstractType& bound,
-                               intptr_t token_pos);
+                               TokenDescriptor token_pos);
 
  private:
   void set_parameterized_class(const Class& value) const;
   void set_name(const String& value) const;
-  void set_token_pos(intptr_t token_pos) const;
+  void set_token_pos(TokenDescriptor token_pos) const;
   void set_type_state(int8_t state) const;
 
   static RawTypeParameter* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // A BoundedType represents a type instantiated at compile time from a type
@@ skipping 25 matching lines @@
     return AbstractType::Handle(type()).unresolved_class();
   }
   virtual RawTypeArguments* arguments() const {
     return AbstractType::Handle(type()).arguments();
   }
   RawAbstractType* type() const { return raw_ptr()->type_; }
   RawAbstractType* bound() const { return raw_ptr()->bound_; }
   RawTypeParameter* type_parameter() const {
     return raw_ptr()->type_parameter_;
   }
-  virtual intptr_t token_pos() const {
+  virtual TokenDescriptor token_pos() const {
     return AbstractType::Handle(type()).token_pos();
   }
   virtual bool IsInstantiated(TrailPtr trail = NULL) const {
     // It is not possible to encounter an instantiated bounded type with an
     // uninstantiated upper bound. Therefore, we do not need to check if the
     // bound is instantiated. Moreover, doing so could lead into cycles, as in
     // class C<T extends C<C>> { }.
     return AbstractType::Handle(type()).IsInstantiated();
   }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
@@ skipping 43 matching lines @@
   // A MixinAppType object is unfinalized by definition, since it is replaced at
   // class finalization time with a finalized (and possibly malformed or
   // malbounded) Type object.
   virtual bool IsFinalized() const { return false; }
   virtual bool IsMalformed() const { return false; }
   virtual bool IsMalbounded() const { return false; }
   virtual bool IsMalformedOrMalbounded() const { return false; }
   virtual bool IsResolved() const { return false; }
   virtual bool HasResolvedTypeClass() const { return false; }
   virtual RawString* Name() const;
-  virtual intptr_t token_pos() const;
+  virtual TokenDescriptor token_pos() const;
 
   // Returns the mixin composition depth of this mixin application type.
   intptr_t Depth() const;
 
   // Returns the declared super type of the mixin application, which will also
   // be the super type of the first synthesized class, e.g. class "S&M" will
   // refer to super type "S<T>".
   RawAbstractType* super_type() const { return raw_ptr()->super_type_; }
 
   // Returns the mixin type at the given mixin composition depth, e.g. N<V> at
@@ skipping 2531 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_