Adjust index of type parameters at finalization time (fix issue 718).

runtime/vm/object.h

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 687 matching lines @@
   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 bool IsInstantiated() const;
   virtual bool Equals(const AbstractType& other) const;
 
-  // Instantiate this type using the given type argument vector starting at the
-  // given offset.
+  // 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,
-      intptr_t offset) const;
+      const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Return the canonical version of this type.
   virtual RawAbstractType* Canonicalize() const;
 
   // The name of this type, including the names of its type arguments, if any.
   virtual RawString* Name() const;
 
   // The index of this type parameter. Fail if not a type parameter.
   virtual intptr_t Index() const;
 
@@ skipping 90 matching lines @@
   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 bool IsInstantiated() const;
   virtual bool Equals(const AbstractType& other) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
-      intptr_t offset) const;
+      const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
   }
 
   // The type of the literal 'null'.
   static RawType* NullType();
 
   // The 'Dynamic' type.
@@ skipping 48 matching lines @@
   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 true; }
+  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 bool IsInstantiated() const { return false; }
   virtual bool Equals(const AbstractType& other) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
-      intptr_t offset) const;
+      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);
 
  private:
-  void set_index(intptr_t value) const;
   void set_name(const String& value) 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
@@ skipping 42 matching lines @@
 // AbstractTypeArguments is an abstract superclass.
 // Subclasses of AbstractTypeArguments are TypeArguments and InstantiatedTypes.
 class AbstractTypeArguments : public Object {
  public:
   static bool AreEqual(const AbstractTypeArguments& arguments,
                        const AbstractTypeArguments& other_arguments);
 
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
-  // type of the instantiator type argument vector starting at the given offset.
+  // type of the instantiator type argument vector.
   virtual RawAbstractTypeArguments* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
-      intptr_t offset) const;
+      const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Do not canonicalize InstantiatedTypeArguments or NULL objects
   virtual RawAbstractTypeArguments* Canonicalize() const { return this->raw(); }
 
   // Check if this type argument vector consists solely of DynamicType,
   // considering only a prefix of length 'len'.
   bool IsDynamicTypes(intptr_t len) const;
 
   // Check the "more specific than" relationship, considering only a prefix of
   // length 'len'.
@@ skipping 22 matching lines @@
   virtual intptr_t Length() const;
   virtual RawAbstractType* TypeAt(intptr_t index) const;
   virtual void SetTypeAt(intptr_t index, const AbstractType& value) const;
   virtual bool IsResolved() const;
   virtual bool IsInstantiated() const;
   virtual bool IsUninstantiatedIdentity() const;
   // Canonicalize only if instantiated, otherwise returns 'this'.
   virtual RawAbstractTypeArguments* Canonicalize() const;
 
   virtual RawAbstractTypeArguments* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
-      intptr_t offset) const;
+      const AbstractTypeArguments& instantiator_type_arguments) const;
 
   static intptr_t length_offset() {
     return OFFSET_OF(RawTypeArguments, length_);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTypeArguments) == OFFSET_OF(RawTypeArguments, types_));
     return 0;
   }
 
@@ skipping 74 matching lines @@
 };
 
 
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
 
   // Build a string of the form '<T, R>(T, [b: B, c: C]) => R' representing the
   // signature of the given function.
   RawString* Signature() const {
-    return BuildSignature(false, TypeArguments::Handle(), 0);
+    return BuildSignature(false, TypeArguments::Handle());
   }
 
   // Build a string of the form '(A, [b: B, c: C]) => D' representing the
   // signature of the given function, where all generic types (e.g. '<T, R>' in
   // '<T, R>(T, [b: B, c: C]) => R') are instantiated using the given
   // instantiator type argument vector (e.g. '<A, D>').
   RawString* InstantiatedSignatureFrom(
-      const AbstractTypeArguments& instantiator,
-      intptr_t offset) const {
-    return BuildSignature(true, instantiator, offset);
+      const AbstractTypeArguments& instantiator) const {
+    return BuildSignature(true, instantiator);
   }
 
   // Returns true if the signature of this function is instantiated, i.e. if it
   // does not involve generic parameter types or generic result type.
   bool HasInstantiatedSignature() const;
 
   RawClass* owner() const { return raw_ptr()->owner_; }
   void set_owner(const Class& value) const;
 
   RawAbstractType* result_type() const { return raw_ptr()->result_type_; }
@@ skipping 190 matching lines @@
   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_implicit_closure_function(const Function& value) const;
   static RawFunction* New();
 
   RawString* BuildSignature(bool instantiate,
-                            const AbstractTypeArguments& instantiator,
-                            intptr_t offset) const;
+                            const AbstractTypeArguments& instantiator) const;
 
   // Checks the subtype or assignability relationship between the type of this
   // function and the type of the other function.
   bool TestType(TypeTestKind test,
                 const AbstractTypeArguments& type_arguments,
                 const Function& other,
                 const AbstractTypeArguments& other_type_arguments) const;
 
   // Checks the type of the formal parameter at the given position for
   // assignability relationship between the type of this function and the type
@@ skipping 1919 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_