Make the parser agnostic to the TokenStream implementation. This is the first step towards compacti…

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"
@@ skipping 462 matching lines @@
 
   intptr_t id() const { return raw_ptr()->id_; }
   void set_id(intptr_t value) const {
     raw_ptr()->id_ = value;
   }
 
   RawString* Name() const;
 
   RawScript* script() const { return raw_ptr()->script_; }
 
-  intptr_t token_index() const { return raw_ptr()->token_index_; }
+  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
   // This class represents the signature class of a closure function if
   // signature_function() is not null.
   // The associated function may be a closure function (with code) or a
   // signature function (without code) solely describing the result type and
   // parameter types of the signature.
   RawFunction* signature_function() const {
     return raw_ptr()->signature_function_;
   }
   static intptr_t signature_function_offset() {
@@ skipping 23 matching lines @@
   // Type parameter bounds (implicitly Dynamic if not explicitly specified) as
   // an array of AbstractType.
   RawTypeArguments* type_parameter_bounds() const {
     return raw_ptr()->type_parameter_bounds_;
   }
   void set_type_parameter_bounds(const TypeArguments& value) const;
 
   // Return a TypeParameter if the type_name is a type parameter of this class.
   // Return null otherwise.
   RawTypeParameter* LookupTypeParameter(const String& type_name,
-                                        intptr_t token_index) const;
+                                        intptr_t token_pos) const;
 
   // The type argument vector is flattened and includes the type arguments of
   // the super class.
   bool HasTypeArguments() const;
   intptr_t NumTypeArguments() const;
 
   // If this class is parameterized, each instance has a type_arguments field.
   static const intptr_t kNoTypeArguments = -1;
   intptr_t type_arguments_instance_field_offset() const {
     ASSERT(is_finalized() || is_prefinalized());
@@ skipping 96 matching lines @@
   RawArray* fields() const { return raw_ptr()->fields_; }
   void SetFields(const Array& value) const;
 
   // Returns true if non-static fields are defined.
   bool HasInstanceFields() const;
 
   RawArray* functions() const { return raw_ptr()->functions_; }
   void SetFunctions(const Array& value) const;
 
   void AddClosureFunction(const Function& function) const;
-  RawFunction* LookupClosureFunction(intptr_t token_index) const;
+  RawFunction* LookupClosureFunction(intptr_t token_pos) const;
 
   RawFunction* LookupDynamicFunction(const String& name) const;
   RawFunction* LookupStaticFunction(const String& name) const;
   RawFunction* LookupConstructor(const String& name) const;
   RawFunction* LookupFactory(const String& name) const;
   RawFunction* LookupFunction(const String& name) const;
   RawFunction* LookupGetterFunction(const String& name) const;
   RawFunction* LookupSetterFunction(const String& name) const;
-  RawFunction* LookupFunctionAtToken(intptr_t token_index) const;
+  RawFunction* LookupFunctionAtToken(intptr_t token_pos) const;
   RawField* LookupInstanceField(const String& name) const;
   RawField* LookupStaticField(const String& name) const;
   RawField* LookupField(const String& name) const;
 
   RawLibraryPrefix* LookupLibraryPrefix(const String& name) const;
 
   void InsertCanonicalConstant(intptr_t index, const Instance& constant) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClass));
@@ skipping 41 matching lines @@
   RawArray* constants() const;
 
   void Finalize() const;
 
   // Allocate a class used for VM internal objects.
   template <class FakeObject> static RawClass* New();
 
   // Allocate instance classes and interfaces.
   static RawClass* New(const String& name,
                        const Script& script,
-                       intptr_t token_index);
+                       intptr_t token_pos);
   static RawClass* NewInterface(const String& name,
                                 const Script& script,
-                                intptr_t token_index);
+                                intptr_t token_pos);
   static RawClass* NewNativeWrapper(Library* library,
                                     const String& name,
                                     int num_fields);
 
   // Allocate a class representing a function signature described by
   // signature_function, which must be a closure function or a signature
   // function.
   // The class may be type parameterized unless the signature_function is in a
   // static scope. In that case, the type parameters are copied from the owner
   // class of signature_function.
   static RawClass* NewSignatureClass(const String& name,
                                      const Function& signature_function,
                                      const Script& script);
 
   // Return a class object corresponding to the specified kind. If
   // a canonicalized version of it exists then that object is returned
   // otherwise a new object is allocated and returned.
   static RawClass* GetClass(ObjectKind kind);
 
  private:
   void set_name(const String& value) const;
   void set_script(const Script& value) const;
-  void set_token_index(intptr_t value) const;
+  void set_token_pos(intptr_t value) const;
   void set_signature_function(const Function& value) const;
   void set_signature_type(const AbstractType& value) const;
   void set_class_state(int8_t state) const;
 
   void set_constants(const Array& value) const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
 
   void CalculateFieldOffsets() const;
 
   // Assigns empty array to all raw class array fields.
   void InitEmptyFields();
 
   RawFunction* LookupAccessorFunction(const char* prefix,
                                       intptr_t prefix_length,
                                       const String& name) const;
 
   // Allocate an instance class which has a VM implementation.
   template <class FakeInstance> static RawClass* New(intptr_t id);
   template <class FakeInstance> static RawClass* New(const String& name,
                                                      const Script& script,
-                                                     intptr_t token_index);
+                                                     intptr_t token_pos);
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractTypeArguments& type_arguments,
                 const Class& other,
                 const AbstractTypeArguments& other_type_arguments,
                 Error* malformed_error) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class Object;
   friend class Instance;
   friend class AbstractType;
   friend class Type;
 };
 
 
 // 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_index() const { return raw_ptr()->token_index_; }
+  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
   RawClass* factory_signature_class() const {
     return raw_ptr()->factory_signature_class_;
   }
   void set_factory_signature_class(const Class& value) const;
 
   RawString* Name() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnresolvedClass));
   }
   static RawUnresolvedClass* New(const LibraryPrefix& library_prefix,
                                  const String& ident,
-                                 intptr_t token_index);
+                                 intptr_t token_pos);
 
  private:
   void set_library_prefix(const LibraryPrefix& library_prefix) const;
   void set_ident(const String& ident) const;
-  void set_token_index(intptr_t token_index) const;
+  void set_token_pos(intptr_t token_pos) const;
 
   static RawUnresolvedClass* New();
 
   HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
 // AbstractType is an abstract superclass.
 // Subclasses of AbstractType are Type and TypeParameter.
 class AbstractType : public Object {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsBeingFinalized() const;
   virtual bool IsMalformed() const;
   virtual RawError* malformed_error() const;
   virtual void set_malformed_error(const Error& value) const;
   virtual bool IsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawAbstractTypeArguments* arguments() const;
-  virtual intptr_t token_index() const;
+  virtual intptr_t token_pos() const;
   virtual bool IsInstantiated() const;
   virtual bool Equals(const AbstractType& other) const;
   virtual bool IsIdentical(const AbstractType& other) const;
 
   // Instantiate this type using the given type argument vector.
   // Return a new type, or return 'this' if it is already instantiated.
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Return the canonical version of this type.
@@ skipping 110 matching lines @@
   virtual RawError* malformed_error() const;
   virtual void set_malformed_error(const Error& value) const;
   virtual bool IsResolved() const;  // Class and all arguments classes resolved.
   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;
   RawString* TypeClassName() const;
   virtual RawAbstractTypeArguments* arguments() const;
   void set_arguments(const AbstractTypeArguments& value) const;
-  virtual intptr_t token_index() const { return raw_ptr()->token_index_; }
+  virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const;
   virtual bool Equals(const AbstractType& other) const;
   virtual bool IsIdentical(const AbstractType& other) const;
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
   }
@@ skipping 29 matching lines @@
   static RawType* FunctionInterface();
 
   // The 'List' interface type.
   static RawType* ListInterface();
 
   // The finalized type of the given non-parameterized class.
   static RawType* NewNonParameterizedType(const Class& type_class);
 
   static RawType* New(const Object& clazz,
                       const AbstractTypeArguments& arguments,
-                      intptr_t token_index);
+                      intptr_t token_pos);
 
  private:
-  void set_token_index(intptr_t token_index) const;
+  void set_token_pos(intptr_t token_pos) const;
   void set_type_state(int8_t state) const;
 
   static RawType* New();
 
   HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
 };
 
 
 // A TypeParameter represents a type parameter of a parameterized class.
@@ skipping 13 matching lines @@
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsMalformed() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return false; }
   RawClass* parameterized_class() const {
       return raw_ptr()->parameterized_class_;
   }
   virtual RawString* Name() const { return raw_ptr()->name_; }
   virtual intptr_t Index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const;
-  virtual intptr_t token_index() const { return raw_ptr()->token_index_; }
+  virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const { return false; }
   virtual bool Equals(const AbstractType& other) const;
   virtual bool IsIdentical(const AbstractType& other) const;
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const { return raw(); }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTypeParameter));
   }
 
   static RawTypeParameter* New(const Class& parameterized_class,
                                intptr_t index,
                                const String& name,
-                               intptr_t token_index);
+                               intptr_t token_pos);
 
  private:
   void set_parameterized_class(const Class& value) const;
   void set_name(const String& value) const;
-  void set_token_index(intptr_t token_index) const;
+  void set_token_pos(intptr_t token_pos) const;
   void set_type_state(int8_t state) const;
   static RawTypeParameter* New();
 
   HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // AbstractTypeArguments is an abstract superclass.
 // Subclasses of AbstractTypeArguments are TypeArguments and
@@ skipping 312 matching lines @@
       case RawFunction::kClosureFunction:
       case RawFunction::kConstructor:
         return false;
       default:
         UNREACHABLE();
         return false;
     }
   }
   bool IsInFactoryScope() const;
 
-  intptr_t token_index() const { return raw_ptr()->token_index_; }
+  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
-  intptr_t end_token_index() const { return raw_ptr()->end_token_index_; }
-  void set_end_token_index(intptr_t value) const {
-    raw_ptr()->end_token_index_ = value;
+  intptr_t end_token_pos() const { return raw_ptr()->end_token_pos_; }
+  void set_end_token_pos(intptr_t value) const {
+    raw_ptr()->end_token_pos_ = value;
   }
 
   static intptr_t num_fixed_parameters_offset() {
     return OFFSET_OF(RawFunction, num_fixed_parameters_);
   }
   intptr_t num_fixed_parameters() const {
     return raw_ptr()->num_fixed_parameters_;
   }
   void set_num_fixed_parameters(intptr_t value) const;
 
@@ skipping 110 matching lines @@
 
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFunction));
   }
 
   static RawFunction* New(const String& name,
                           RawFunction::Kind kind,
                           bool is_static,
                           bool is_const,
-                          intptr_t token_index);
+                          intptr_t token_pos);
 
   // Allocates a new Function object representing a closure function, as well as
   // a new associated Class object representing the signature class of the
   // function.
   // The function and the class share the same given name.
   static RawFunction* NewClosureFunction(const String& name,
                                          const Function& parent,
-                                         intptr_t token_index);
+                                         intptr_t token_pos);
 
   static const int kCtorPhaseInit = 1 << 0;
   static const int kCtorPhaseBody = 1 << 1;
   static const int kCtorPhaseAll = (kCtorPhaseInit | kCtorPhaseBody);
 
  private:
   void set_name(const String& value) const;
   void set_kind(RawFunction::Kind value) const;
   void set_is_static(bool is_static) const;
   void set_is_const(bool is_const) const;
   void set_parent_function(const Function& value) const;
-  void set_token_index(intptr_t value) const;
+  void set_token_pos(intptr_t value) const;
   void set_implicit_closure_function(const Function& value) const;
   static RawFunction* New();
 
   RawString* BuildSignature(bool instantiate,
                             const AbstractTypeArguments& instantiator) const;
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractTypeArguments& type_arguments,
                 const Function& other,
@@ skipping 38 matching lines @@
   RawAbstractType* type() const  { return raw_ptr()->type_; }
   void set_type(const AbstractType& value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawField));
   }
 
   static RawField* New(const String& name,
                        bool is_static,
                        bool is_final,
-                       intptr_t token_index);
+                       intptr_t token_pos);
 
   static intptr_t value_offset() { return OFFSET_OF(RawField, value_); }
 
-  intptr_t token_index() const { return raw_ptr()->token_index_; }
+  intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
   bool has_initializer() const { return raw_ptr()->has_initializer_; }
   void set_has_initializer(bool has_initializer) const {
     raw_ptr()->has_initializer_ = has_initializer;
   }
 
   // Constructs getter and setter names for fields and vice versa.
   static RawString* GetterName(const String& field_name);
   static RawString* GetterSymbol(const String& field_name);
   static RawString* SetterName(const String& field_name);
   static RawString* SetterSymbol(const String& field_name);
   static RawString* NameFromGetter(const String& getter_name);
   static RawString* NameFromSetter(const String& setter_name);
   static bool IsGetterName(const String& function_name);
   static bool IsSetterName(const String& function_name);
 
  private:
   void set_name(const String& value) const;
   void set_is_static(bool is_static) const {
     raw_ptr()->is_static_ = is_static;
   }
   void set_is_final(bool is_final) const {
     raw_ptr()->is_final_ = is_final;
   }
-  void set_token_index(intptr_t token_index) const {
-    raw_ptr()->token_index_ = token_index;
+  void set_token_pos(intptr_t token_pos) const {
+    raw_ptr()->token_pos_ = token_pos;
   }
   static RawField* New();
 
   HEAP_OBJECT_IMPLEMENTATION(Field, Object);
   friend class Class;
 };
 
 
 class LiteralToken : public Object {
  public:
@@ skipping 72 matching lines @@
 
   void Tokenize(const String& private_key) const;
 
   RawString* GetLine(intptr_t line_number) const;
 
   RawString* GetSnippet(intptr_t from_line,
                         intptr_t from_column,
                         intptr_t to_line,
                         intptr_t to_column) const;
 
-  void GetTokenLocation(intptr_t token_index,
+  void GetTokenLocation(intptr_t token_pos,
                         intptr_t* line, intptr_t* column) const;
 
   intptr_t TokenIndexAtLine(intptr_t line_number) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawScript));
   }
 
   static RawScript* New(const String& url,
                         const String& source,
@@ skipping 98 matching lines @@
   // Library imports.
   void AddImport(const Library& library) const;
   RawLibrary* LookupImport(const String& url) const;
   intptr_t num_imports() const { return raw_ptr()->num_imports_; }
   RawLibrary* ImportAt(intptr_t index) const;
   RawLibraryPrefix* ImportPrefixAt(intptr_t index) const;
 
   RawFunction* LookupFunctionInSource(const String& script_url,
                                       intptr_t line_number) const;
   RawFunction* LookupFunctionInScript(const Script& script,
-                                      intptr_t token_index) const;
+                                      intptr_t token_pos) const;
 
   // Resolving native methods for script loaded in the library.
   Dart_NativeEntryResolver native_entry_resolver() const {
     return raw_ptr()->native_entry_resolver_;
   }
   void set_native_entry_resolver(Dart_NativeEntryResolver value) const {
     raw_ptr()->native_entry_resolver_ = value;
   }
 
   RawString* PrivateName(const String& name) const;
@@ skipping 205 matching lines @@
   PcDescriptors::Kind DescriptorKind(intptr_t index) const;
   const char* KindAsStr(intptr_t index) const;
   intptr_t NodeId(intptr_t index) const;
   intptr_t TokenIndex(intptr_t index) const;
   intptr_t TryIndex(intptr_t index) const;
 
   void AddDescriptor(intptr_t index,
                      uword pc,
                      PcDescriptors::Kind kind,
                      intptr_t node_id,
-                     intptr_t token_index,
+                     intptr_t token_pos,
                      intptr_t try_index) const {
     SetPC(index, pc);
     SetKind(index, kind);
     SetNodeId(index, node_id);
-    SetTokenIndex(index, token_index);
+    SetTokenIndex(index, token_pos);
     SetTryIndex(index, try_index);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawPcDescriptors) == OFFSET_OF(RawPcDescriptors, data_));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(
         sizeof(RawPcDescriptors) + (len * kNumberOfEntries * kWordSize));
@@ skipping 386 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.
 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_index) const;
+  void SetTokenIndexAt(intptr_t scope_index, intptr_t 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_const) const;
 
   RawAbstractType* TypeAt(intptr_t scope_index) const;
   void SetTypeAt(intptr_t scope_index, const AbstractType& type) const;
 
@@ skipping 2566 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_