Add token index position to classes and types for more accurate error reporting.

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"
@@ skipping 435 matching lines @@
 
   ObjectKind instance_kind() const { return raw_ptr()->instance_kind_; }
   void set_instance_kind(ObjectKind value) {
     raw_ptr()->instance_kind_ = value;
   }
 
   RawString* Name() const;
 
   RawScript* script() const { return raw_ptr()->script_; }
 
+  intptr_t token_index() const { return raw_ptr()->token_index_; }
+
   // 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() {
     return OFFSET_OF(RawClass, signature_function_);
   }
 
   // Return the signature type of this signature class.
   // For example, if this class represents a signature of the form
   // '<T, R>(T, [b: B, c: C]) => R', then its signature type is a parameterized
   // type with this class as the type class and type parameters 'T' and 'R'
   // as its type argument vector.
   RawType* SignatureType() const;
 
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
   // The type parameters are specified as an array of Strings.
+  // TODO(regis): Store them as an array of TypeParameter with token_index.
   RawArray* type_parameters() const { return raw_ptr()->type_parameters_; }
   void set_type_parameters(const Array& value) const;
   intptr_t NumTypeParameters() const;
 
   // Type parameters may optionally extend a Type (Dynamic if no extends).
   // TODO(regis): Should it be Object instead of Dynamic?
   RawTypeArguments* type_parameter_extends() const {
     return raw_ptr()->type_parameter_extends_;
   }
   void set_type_parameter_extends(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) const;
+  RawTypeParameter* LookupTypeParameter(const String& type_name,
+                                        intptr_t token_index) 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 149 matching lines @@
 
   RawArray* constants() const;
 
   void Finalize() const;
 
   // Allocate a class used for VM internal objects.
   template <class FakeObject> static RawClass* New();
 
   // Allocate an instance class which has a VM implementation.
   template <class FakeInstance> static RawClass* New(const String& name,
-                                                     const Script& script);
+                                                     const Script& script,
+                                                     intptr_t token_index);
 
   // Allocate instance classes and interfaces.
-  static RawClass* New(const String& name, const Script& script);
-  static RawClass* NewInterface(const String& name, const Script& script);
+  static RawClass* New(const String& name,
+                       const Script& script,
+                       intptr_t token_index);
+  static RawClass* NewInterface(const String& name,
+                                const Script& script,
+                                intptr_t token_index);
   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_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;
@@ skipping 31 matching lines @@
   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(intptr_t token_index,
-                                 const LibraryPrefix& library_prefix,
-                                 const String& ident);
+  static RawUnresolvedClass* New(const LibraryPrefix& library_prefix,
+                                 const String& ident,
+                                 intptr_t token_index);
 
  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_ident(const String& ident) const;
-  void set_library_prefix(const LibraryPrefix& library_prefix) const;
 
   static RawUnresolvedClass* New();
 
   HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
 // AbstractType is an abstract superclass.
 // Subclasses of AbstractType are Type, TypeParameter, and
 // InstantiatedType.
 //
 // Caution: 'RawAbstractType*' denotes a 'raw' pointer to a VM object of class
 // AbstractType, as opposed to 'AbstractType' denoting a 'handle' to the same
 // object. 'RawAbstractType' does not relate to a 'raw type', as opposed to a
 // 'cooked type' or 'rare type'.
 class AbstractType : public Object {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsBeingFinalized() 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 bool IsInstantiated() const;
   virtual bool Equals(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.
   virtual RawAbstractType* Canonicalize() const;
@@ skipping 59 matching lines @@
   // Check the subtype relationship.
   bool IsSubtypeOf(const AbstractType& other) const {
     return Test(kIsSubtypeOf, other);
   }
 
   // Check the assignability relationship.
   bool IsAssignableTo(const AbstractType& dst) const {
     return Test(kIsAssignableTo, dst);
   }
 
-  static RawAbstractType* NewTypeParameter(intptr_t index, const String& name);
+  static RawAbstractType* NewTypeParameter(intptr_t index,
+                                           const String& name,
+                                           intptr_t token_index);
 
   static RawAbstractType* NewInstantiatedType(
       const AbstractType& uninstantiated_type,
       const AbstractTypeArguments& instantiator_type_arguments);
 
  protected:
   // Check the subtype or assignability relationship.
   bool Test(TypeTestKind test, const AbstractType& other) const;
 
   HEAP_OBJECT_IMPLEMENTATION(AbstractType, Object);
@@ skipping 14 matching lines @@
     return raw_ptr()->type_state_ == RawType::kBeingFinalized;
   }
   void set_is_being_finalized() 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;
   virtual RawAbstractTypeArguments* arguments() const;
   void set_arguments(const AbstractTypeArguments& value) const;
+  virtual intptr_t token_index() const { return raw_ptr()->token_index_; }
   virtual bool IsInstantiated() const;
   virtual bool Equals(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 26 matching lines @@
 
   // The 'Function' interface type.
   static RawType* FunctionInterface();
 
   // The 'List' interface type.
   static RawType* ListInterface();
 
   // The least specific valid raw type of the given class.
   // For example, type A<Dynamic> would be returned for class A<T>, and type
   // B<Dynamic, A<Dynamic>> would be returned for B<U, V extends A>.
-  static RawType* NewRawType(const Class& type_class);
+  static RawType* NewRawType(const Class& type_class, intptr_t token_index);
 
   // 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);
+                      const AbstractTypeArguments& arguments,
+                      intptr_t token_index);
 
  private:
+  void set_token_index(intptr_t token_index) const;
   void set_type_state(int8_t state) const;
 
   static RawType* New();
 
   HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
 };
 
 
 // A TypeParameter, in the context of a parameterized class, references a type
 // parameter of a class by its index (and by its name for debugging purposes).
 // For example, the type parameter 'V' is specified as index 1 in the context of
 // the class HashMap<K, V>. At compile time, the TypeParameter is not
 // instantiated yet, i.e. it is only a place holder.
 // Upon finalization, the TypeParameter index is changed to reflect its position
 // as type argument (rather than type parameter) of the enclosing class.
 class TypeParameter : public AbstractType {
  public:
   virtual bool IsFinalized() const {
     return raw_ptr()->type_state_ == RawTypeParameter::kFinalized;
   }
   void set_is_finalized() const;
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return false; }
   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 bool IsInstantiated() const { return false; }
   virtual bool Equals(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(intptr_t index, const String& name);
+  static RawTypeParameter* New(intptr_t index,
+                               const String& name,
+                               intptr_t token_index);
 
  private:
   void set_name(const String& value) const;
+  void set_token_index(intptr_t token_index) const;
   void set_type_state(int8_t state) const;
   static RawTypeParameter* New();
 
   HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // An instance of InstantiatedType is never encountered at compile time, but
 // only at run time, when type parameters can be matched to actual types.
 // An instance of InstantiatedType consists of an uninstantiated AbstractType
 // object and of a AbstractTypeArguments object. The type is uninstantiated,
 // because it refers to at least one TypeParameter object, i.e. to a type that
 // is not known at compile time.
 // The type argument vector is the instantiator, because each type parameter
 // with index i in the uninstantiated type can be substituted (or
 // "instantiated") with the type at index i in the type argument vector.
 class InstantiatedType : public AbstractType {
  public:
   virtual bool IsFinalized() const { return true; }
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return true; }
   virtual RawClass* type_class() const;
   virtual RawAbstractTypeArguments* arguments() const;
+  virtual intptr_t token_index() const;
   virtual bool IsInstantiated() const { return true; }
 
   RawAbstractType* uninstantiated_type() const {
     return raw_ptr()->uninstantiated_type_;
   }
   RawAbstractTypeArguments* instantiator_type_arguments() const {
     return raw_ptr()->instantiator_type_arguments_;
   }
 
   static intptr_t InstanceSize() {
@@ skipping 2608 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_