Implement eager instantiation and canonicalization of type arguments at run

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 340 matching lines @@
     return *null_array_;
   }
   static const String& null_string() {
     ASSERT(null_string_ != NULL);
     return *null_string_;
   }
   static const Instance& null_instance() {
     ASSERT(null_instance_ != NULL);
     return *null_instance_;
   }
-  static const AbstractTypeArguments& null_abstract_type_arguments() {
-    ASSERT(null_abstract_type_arguments_ != NULL);
-    return *null_abstract_type_arguments_;
+  static const TypeArguments& null_type_arguments() {
+    ASSERT(null_type_arguments_ != NULL);
+    return *null_type_arguments_;
   }
 
   static const Array& empty_array() {
     ASSERT(empty_array_ != NULL);
     return *empty_array_;
   }
 
   static const PcDescriptors& empty_descriptors() {
     ASSERT(empty_descriptors_ != NULL);
     return *empty_descriptors_;
@@ skipping 46 matching lines @@
     return *branch_offset_error_;
   }
 
   static RawClass* class_class() { return class_class_; }
   static RawClass* dynamic_class() { return dynamic_class_; }
   static RawClass* void_class() { return void_class_; }
   static RawType* dynamic_type() { return dynamic_type_; }
   static RawType* void_type() { return void_type_; }
   static RawClass* unresolved_class_class() { return unresolved_class_class_; }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
-  static RawClass* instantiated_type_arguments_class() {
-      return instantiated_type_arguments_class_;
-  }
   static RawClass* patch_class_class() { return patch_class_class_; }
   static RawClass* function_class() { return function_class_; }
   static RawClass* closure_data_class() { return closure_data_class_; }
   static RawClass* redirection_data_class() { return redirection_data_class_; }
   static RawClass* field_class() { return field_class_; }
   static RawClass* literal_token_class() { return literal_token_class_; }
   static RawClass* token_stream_class() { return token_stream_class_; }
   static RawClass* script_class() { return script_class_; }
   static RawClass* library_class() { return library_class_; }
   static RawClass* library_prefix_class() { return library_prefix_class_; }
@@ skipping 130 matching lines @@
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* dynamic_class_;  // Class of the 'dynamic' type.
   static RawClass* void_class_;  // Class of the 'void' type.
   static RawType* dynamic_type_;  // Class of the 'dynamic' type.
   static RawType* void_type_;  // Class of the 'void' type.
   static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
-  // Class of the TypeArguments vm object.
-  static RawClass* type_arguments_class_;
-  static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
+  static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
   static RawClass* patch_class_class_;  // Class of the PatchClass vm object.
   static RawClass* function_class_;  // Class of the Function vm object.
   static RawClass* closure_data_class_;  // Class of ClosureData vm obj.
   static RawClass* redirection_data_class_;  // Class of RedirectionData vm obj.
   static RawClass* field_class_;  // Class of the Field vm object.
   static RawClass* literal_token_class_;  // Class of LiteralToken vm object.
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
   static RawClass* script_class_;  // Class of the Script vm object.
   static RawClass* library_class_;  // Class of the Library vm object.
   static RawClass* library_prefix_class_;  // Class of Library prefix vm object.
@@ skipping 14 matching lines @@
   static RawClass* language_error_class_;  // Class of LanguageError.
   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
   static RawClass* unwind_error_class_;  // Class of UnwindError.
 
   // The static values below are read-only handle pointers for singleton
   // objects that are shared between the different isolates.
   static Object* null_object_;
   static Array* null_array_;
   static String* null_string_;
   static Instance* null_instance_;
-  static AbstractTypeArguments* null_abstract_type_arguments_;
+  static TypeArguments* null_type_arguments_;
   static Array* empty_array_;
   static PcDescriptors* empty_descriptors_;
   static Instance* sentinel_;
   static Instance* transition_sentinel_;
   static Instance* unknown_constant_;
   static Instance* non_constant_;
   static Bool* bool_true_;
   static Bool* bool_false_;
   static Smi* smi_illegal_cid_;
   static LanguageError* snapshot_writer_error_;
@@ skipping 219 matching lines @@
   }
   static bool IsSignatureClass(RawClass* cls) {
     return cls->ptr()->signature_function_ != Object::null();
   }
 
   // Check if this class represents a canonical signature class, i.e. not an
   // alias as defined in a typedef.
   bool IsCanonicalSignatureClass() const;
 
   // Check the subtype relationship.
-  bool IsSubtypeOf(const AbstractTypeArguments& type_arguments,
+  bool IsSubtypeOf(const TypeArguments& type_arguments,
                    const Class& other,
-                   const AbstractTypeArguments& other_type_arguments,
+                   const TypeArguments& other_type_arguments,
                    Error* bound_error) const {
     return TypeTest(kIsSubtypeOf,
                     type_arguments,
                     other,
                     other_type_arguments,
                     bound_error);
   }
 
   // Check the 'more specific' relationship.
-  bool IsMoreSpecificThan(const AbstractTypeArguments& type_arguments,
+  bool IsMoreSpecificThan(const TypeArguments& type_arguments,
                           const Class& other,
-                          const AbstractTypeArguments& other_type_arguments,
+                          const TypeArguments& other_type_arguments,
                           Error* bound_error) const {
     return TypeTest(kIsMoreSpecificThan,
                     type_arguments,
                     other,
                     other_type_arguments,
                     bound_error);
   }
 
   // Check if this is the top level class.
   bool IsTopLevel() const;
@@ skipping 279 matching lines @@
 
   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);
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
-                const AbstractTypeArguments& type_arguments,
+                const TypeArguments& type_arguments,
                 const Class& other,
-                const AbstractTypeArguments& other_type_arguments,
+                const TypeArguments& other_type_arguments,
                 Error* bound_error) const;
 
   static bool TypeTestNonRecursive(
       const Class& cls,
       TypeTestKind test_kind,
-      const AbstractTypeArguments& type_arguments,
+      const TypeArguments& type_arguments,
       const Class& other,
-      const AbstractTypeArguments& other_type_arguments,
+      const TypeArguments& other_type_arguments,
       Error* bound_error);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class AbstractType;
   friend class Instance;
   friend class Object;
   friend class Type;
 };
 
 
@@ skipping 22 matching lines @@
   void set_ident(const String& ident) const;
   void set_token_pos(intptr_t token_pos) const;
 
   static RawUnresolvedClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
-// AbstractTypeArguments is an abstract superclass.
-// Subclasses of AbstractTypeArguments are TypeArguments and
-// InstantiatedTypeArguments.
-class AbstractTypeArguments : public Object {
+// A TypeArguments is an array of AbstractType.
+class TypeArguments : public Object {
  public:
-  // Returns true if all types of this vector are finalized.
-  virtual bool IsFinalized() const { return true; }
-
-  // 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.
-  // If bound_error is not NULL, it may be set to reflect a bound error.
-  virtual RawAbstractTypeArguments* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
-      Error* bound_error,
-      GrowableObjectArray* trail = NULL) const;
-
-  // Do not clone InstantiatedTypeArguments or null vectors, since they are
-  // considered finalized.
-  virtual RawAbstractTypeArguments* CloneUnfinalized() const {
-    return this->raw();
+  intptr_t Length() const;
+  RawAbstractType* TypeAt(intptr_t index) const;
+  static intptr_t type_at_offset(intptr_t index) {
+    return OFFSET_OF(RawTypeArguments, types_) + index * kWordSize;
   }
-
-  // Null vectors are canonical.
-  virtual RawAbstractTypeArguments* Canonicalize(
-      GrowableObjectArray* trail = NULL) const {
-    return this->raw();
-  }
+  void SetTypeAt(intptr_t index, const AbstractType& value) const;
 
   // The name of this type argument vector, e.g. "<T, dynamic, List<T>, Smi>".
-  virtual RawString* Name() const {
+  RawString* Name() const {
     return SubvectorName(0, Length(), kInternalName);
   }
 
   // The name of this type argument vector, e.g. "<T, dynamic, List<T>, int>".
   // Names of internal classes are mapped to their public interfaces.
-  virtual RawString* UserVisibleName() const {
+  RawString* UserVisibleName() const {
     return SubvectorName(0, Length(), kUserVisibleName);
   }
 
   // Check if the subvector of length 'len' starting at 'from_index' of this
   // type argument vector consists solely of DynamicType.
   bool IsRaw(intptr_t from_index, intptr_t len) const {
     return IsDynamicTypes(false, from_index, len);
   }
 
   // Check if this type argument vector would consist solely of DynamicType if
   // it was instantiated from a raw (null) instantiator, i.e. consider each type
   // parameter as it would be first instantiated from a vector of dynamic types.
   // Consider only a prefix of length 'len'.
   bool IsRawInstantiatedRaw(intptr_t len) const {
     return IsDynamicTypes(true, 0, len);
   }
 
   // Check the subtype relationship, considering only a subvector of length
   // 'len' starting at 'from_index'.
-  bool IsSubtypeOf(const AbstractTypeArguments& other,
+  bool IsSubtypeOf(const TypeArguments& other,
                    intptr_t from_index,
                    intptr_t len,
                    Error* bound_error) const {
     return TypeTest(kIsSubtypeOf, other, from_index, len, bound_error);
   }
 
   // Check the 'more specific' relationship, considering only a subvector of
   // length 'len' starting at 'from_index'.
-  bool IsMoreSpecificThan(const AbstractTypeArguments& other,
+  bool IsMoreSpecificThan(const TypeArguments& other,
                           intptr_t from_index,
                           intptr_t len,
                           Error* bound_error) const {
     return TypeTest(kIsMoreSpecificThan, other, from_index, len, bound_error);
   }
 
   // Check if the vectors are equal.
-  bool Equals(const AbstractTypeArguments& other) const {
+  bool Equals(const TypeArguments& other) const {
     return IsEquivalent(other);
   }
 
-  bool IsEquivalent(const AbstractTypeArguments& other,
+  bool IsEquivalent(const TypeArguments& other,
                     GrowableObjectArray* trail = NULL) const;
 
-  // UNREACHABLEs as AbstractTypeArguments is an abstract class.
-  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(GrowableObjectArray* trail = NULL) const;
-  virtual bool IsUninstantiatedIdentity() const;
-  virtual bool CanShareInstantiatorTypeArguments(
-      const Class& instantiator_class) const;
-  virtual bool IsBounded() const;
+  bool IsResolved() const;
+  bool IsInstantiated(GrowableObjectArray* trail = NULL) const;
+  bool IsUninstantiatedIdentity() const;
+  bool CanShareInstantiatorTypeArguments(const Class& instantiator_class) const;
 
-  virtual intptr_t Hash() const;
+  // Returns true if all types of this vector are finalized.
+  bool IsFinalized() const;
+  bool IsBounded() const;
 
- private:
-  // Check if the subvector of length 'len' starting at 'from_index' of this
-  // type argument vector consists solely of DynamicType.
-  // If raw_instantiated is true, consider each type parameter to be first
-  // instantiated from a vector of dynamic types.
-  bool IsDynamicTypes(bool raw_instantiated,
-                      intptr_t from_index,
-                      intptr_t len) const;
+  // Clone this type argument vector and clone all unfinalized type arguments.
+  // Finalized type arguments are shared.
+  RawTypeArguments* CloneUnfinalized() const;
 
-  // Check the subtype or 'more specific' relationship, considering only a
-  // subvector of length 'len' starting at 'from_index'.
-  bool TypeTest(TypeTestKind test_kind,
-                const AbstractTypeArguments& other,
-                intptr_t from_index,
-                intptr_t len,
-                Error* bound_error) const;
+  // Canonicalize only if instantiated, otherwise returns 'this'.
+  RawTypeArguments* Canonicalize(GrowableObjectArray* trail = NULL) const;
 
-  // Return the internal or public name of a subvector of this type argument
-  // vector, e.g. "<T, dynamic, List<T>, int>".
-  RawString* SubvectorName(intptr_t from_index,
-                           intptr_t len,
-                           NameVisibility name_visibility) const;
-
- protected:
-  HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments, Object);
-  friend class AbstractType;
-  friend class Class;
-};
-
-
-// A TypeArguments is an array of AbstractType.
-class TypeArguments : public AbstractTypeArguments {
- public:
-  virtual intptr_t Length() const;
-  virtual RawAbstractType* TypeAt(intptr_t index) const;
-  static intptr_t type_at_offset(intptr_t index) {
-    return OFFSET_OF(RawTypeArguments, types_) + index * kWordSize;
-  }
-  virtual void SetTypeAt(intptr_t index, const AbstractType& value) const;
-  virtual bool IsResolved() const;
-  virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const;
-  virtual bool IsUninstantiatedIdentity() const;
-  virtual bool CanShareInstantiatorTypeArguments(
-      const Class& instantiator_class) const;
-  virtual bool IsFinalized() const;
-  virtual bool IsBounded() const;
-  virtual RawAbstractTypeArguments* CloneUnfinalized() const;
-  // Canonicalize only if instantiated, otherwise returns 'this'.
-  virtual RawAbstractTypeArguments* Canonicalize(
+  // 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.
+  // If bound_error is not NULL, it may be set to reflect a bound error.
+  RawTypeArguments* InstantiateFrom(
+      const TypeArguments& instantiator_type_arguments,
+      Error* bound_error,
       GrowableObjectArray* trail = NULL) const;
 
-  virtual RawAbstractTypeArguments* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
-      Error* bound_error,
-      GrowableObjectArray* trail = NULL) const;
+  // Runtime instantiation with canonicalization. Not to be used during type
+  // finalization at compile time.
+  RawTypeArguments* InstantiateAndCanonicalizeFrom(
+      const TypeArguments& instantiator_type_arguments,
+      Error* bound_error) const;
+
+  static intptr_t instantiations_offset() {
+    return OFFSET_OF(RawTypeArguments, instantiations_);
+  }
 
   static const intptr_t kBytesPerElement = kWordSize;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t length_offset() {
     return OFFSET_OF(RawTypeArguments, length_);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTypeArguments) == OFFSET_OF(RawTypeArguments, types_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
-    // Ensure that the types_ is not adding to the object length.
-    ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (1 * kWordSize)));
+    // Ensure that the types_ is not adding to the object size, which includes
+    // 2 fields: instantiations_ and length_.
+    ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (2 * kWordSize)));
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawTypeArguments) + (len * kBytesPerElement));
   }
 
+  intptr_t Hash() const;
+
   static RawTypeArguments* New(intptr_t len, Heap::Space space = Heap::kOld);
 
  private:
+  // Check if the subvector of length 'len' starting at 'from_index' of this
+  // type argument vector consists solely of DynamicType.
+  // If raw_instantiated is true, consider each type parameter to be first
+  // instantiated from a vector of dynamic types.
+  bool IsDynamicTypes(bool raw_instantiated,
+                      intptr_t from_index,
+                      intptr_t len) const;
+
+  // Check the subtype or 'more specific' relationship, considering only a
+  // subvector of length 'len' starting at 'from_index'.
+  bool TypeTest(TypeTestKind test_kind,
+                const TypeArguments& other,
+                intptr_t from_index,
+                intptr_t len,
+                Error* bound_error) const;
+
+  // Return the internal or public name of a subvector of this type argument
+  // vector, e.g. "<T, dynamic, List<T>, int>".
+  RawString* SubvectorName(intptr_t from_index,
+                           intptr_t len,
+                           NameVisibility name_visibility) const;
+
+  RawArray* instantiations() const;
+  void set_instantiations(const Array& value) const;
   RawAbstractType** TypeAddr(intptr_t index) const;
   void SetLength(intptr_t value) const;
 
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeArguments, AbstractTypeArguments);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeArguments, Object);
+  friend class AbstractType;
   friend class Class;
 };
 
-
-// An instance of InstantiatedTypeArguments is never encountered at compile
-// time, but only at run time, when type parameters can be matched to actual
-// types.
-// An instance of InstantiatedTypeArguments consists of a pair of
-// AbstractTypeArguments objects. The first type argument vector is
-// uninstantiated, because it contains type expressions referring to at least
-// one TypeParameter object, i.e. to a type that is not known at compile time.
-// The second type argument vector is the instantiator, because each type
-// parameter with index i in the first vector can be substituted (or
-// "instantiated") with the type at index i in the second type argument vector.
-class InstantiatedTypeArguments : public AbstractTypeArguments {
- public:
-  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 { return true; }
-  virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const {
-    return true;
-  }
-  virtual bool IsUninstantiatedIdentity() const {
-    UNREACHABLE();
-    return false;
-  }
-  virtual bool CanShareInstantiatorTypeArguments(
-      const Class& instantiator_class) const {
-    UNREACHABLE();
-    return false;
-  }
-  virtual bool IsBounded() const { return false; }  // Bounds were checked.
-  virtual RawAbstractTypeArguments* Canonicalize(
-      GrowableObjectArray* trail = NULL) const;
-
-  RawAbstractTypeArguments* uninstantiated_type_arguments() const {
-    return raw_ptr()->uninstantiated_type_arguments_;
-  }
-  static intptr_t uninstantiated_type_arguments_offset() {
-    return OFFSET_OF(RawInstantiatedTypeArguments,
-                     uninstantiated_type_arguments_);
-  }
-
-  RawAbstractTypeArguments* instantiator_type_arguments() const {
-    return raw_ptr()->instantiator_type_arguments_;
-  }
-  static intptr_t instantiator_type_arguments_offset() {
-    return OFFSET_OF(RawInstantiatedTypeArguments,
-                     instantiator_type_arguments_);
-  }
-
-  static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawInstantiatedTypeArguments));
-  }
-
-  static RawInstantiatedTypeArguments* New(
-      const AbstractTypeArguments& uninstantiated_type_arguments,
-      const AbstractTypeArguments& instantiator_type_arguments);
-
- private:
-  void set_uninstantiated_type_arguments(
-      const AbstractTypeArguments& value) const;
-  void set_instantiator_type_arguments(
-      const AbstractTypeArguments& value) const;
-
-  static RawInstantiatedTypeArguments* New();
-
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments,
-                                   AbstractTypeArguments);
-  friend class Class;
-};
-
 
 class PatchClass : public Object {
  public:
   RawClass* patched_class() const { return raw_ptr()->patched_class_; }
   RawClass* source_class() const { return raw_ptr()->source_class_; }
   RawScript* Script() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawPatchClass));
   }
@@ skipping 37 matching lines @@
   RawString* UserVisibleSignature() const {
     const bool instantiate = false;
     return BuildSignature(
         instantiate, kUserVisibleName, 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
   // 'C<T, R>(T, {b: B, c: C}) => R') are instantiated using the given
   // instantiator type argument vector of a C instance (e.g. '<A, D>').
-  RawString* InstantiatedSignatureFrom(
-      const AbstractTypeArguments& instantiator,
-      NameVisibility name_visibility) const {
+  RawString* InstantiatedSignatureFrom(const TypeArguments& instantiator,
+                                       NameVisibility name_visibility) const {
     const bool instantiate = true;
     return BuildSignature(instantiate, name_visibility, 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;
 
   // Build a string of the form 'T, {b: B, c: C} representing the user
   // visible formal parameters of the function.
@@ skipping 298 matching lines @@
   const char* ToFullyQualifiedCString() const;
 
   // Returns true if this function has parameters that are compatible with the
   // parameters of the other function in order for this function to override the
   // other function.
   bool HasCompatibleParametersWith(const Function& other,
                                    Error* bound_error) const;
 
   // Returns true if the type of this function is a subtype of the type of
   // the other function.
-  bool IsSubtypeOf(const AbstractTypeArguments& type_arguments,
+  bool IsSubtypeOf(const TypeArguments& type_arguments,
                    const Function& other,
-                   const AbstractTypeArguments& other_type_arguments,
+                   const TypeArguments& other_type_arguments,
                    Error* bound_error) const {
     return TypeTest(kIsSubtypeOf,
                     type_arguments,
                     other,
                     other_type_arguments,
                     bound_error);
   }
 
   // Returns true if the type of this function is more specific than the type of
   // the other function.
-  bool IsMoreSpecificThan(const AbstractTypeArguments& type_arguments,
+  bool IsMoreSpecificThan(const TypeArguments& type_arguments,
                           const Function& other,
-                          const AbstractTypeArguments& other_type_arguments,
+                          const TypeArguments& other_type_arguments,
                           Error* bound_error) const {
     return TypeTest(kIsMoreSpecificThan,
                     type_arguments,
                     other,
                     other_type_arguments,
                     bound_error);
   }
 
   // Returns true if this function represents an explicit getter function.
   bool IsGetterFunction() const {
@@ skipping 143 matching lines @@
   void set_data(const Object& value) const;
   bool is_optimizable() const {
     return OptimizableBit::decode(raw_ptr()->kind_tag_);
   }
   void set_is_optimizable(bool value) const;
 
   static RawFunction* New();
 
   void BuildSignatureParameters(bool instantiate,
                                 NameVisibility name_visibility,
-                                const AbstractTypeArguments& instantiator,
+                                const TypeArguments& instantiator,
                                 const GrowableObjectArray& pieces) const;
   RawString* BuildSignature(bool instantiate,
                             NameVisibility name_visibility,
-                            const AbstractTypeArguments& instantiator) const;
+                            const TypeArguments& instantiator) const;
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
-                const AbstractTypeArguments& type_arguments,
+                const TypeArguments& type_arguments,
                 const Function& other,
-                const AbstractTypeArguments& other_type_arguments,
+                const TypeArguments& other_type_arguments,
                 Error* bound_error) const;
 
   // Checks the type of the formal parameter at the given position for
   // subtyping or 'more specific' relationship between the type of this function
   // and the type of the other function.
   bool TestParameterType(TypeTestKind test_kind,
                          intptr_t parameter_position,
                          intptr_t other_parameter_position,
-                         const AbstractTypeArguments& type_arguments,
+                         const TypeArguments& type_arguments,
                          const Function& other,
-                         const AbstractTypeArguments& other_type_arguments,
+                         const TypeArguments& other_type_arguments,
                          Error* bound_error) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Function, Object);
   friend class Class;
   // RawFunction::VisitFunctionPointers accesses the private constructor of
   // Function.
   friend class RawFunction;
 };
 
 
@@ skipping 1761 matching lines @@
   enum Entries {
     kInstanceClassId = 0,
     kInstanceTypeArguments = 1,
     kInstantiatorTypeArguments = 2,
     kTestResult = 3,
     kTestEntryLength  = 4,
   };
 
   intptr_t NumberOfChecks() const;
   void AddCheck(intptr_t class_id,
-                const AbstractTypeArguments& instance_type_arguments,
-                const AbstractTypeArguments& instantiator_type_arguments,
+                const TypeArguments& instance_type_arguments,
+                const TypeArguments& instantiator_type_arguments,
                 const Bool& test_result) const;
   void GetCheck(intptr_t ix,
                 intptr_t* class_id,
-                AbstractTypeArguments* instance_type_arguments,
-                AbstractTypeArguments* instantiator_type_arguments,
+                TypeArguments* instance_type_arguments,
+                TypeArguments* instantiator_type_arguments,
                 Bool* test_result) const;
 
   static RawSubtypeTestCache* New();
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawSubtypeTestCache));
   }
 
   static intptr_t cache_offset() {
     return OFFSET_OF(RawSubtypeTestCache, cache_);
@@ skipping 182 matching lines @@
     return *FieldAddr(field);
   }
 
   void SetField(const Field& field, const Object& value) const {
     field.UpdateGuardedCidAndLength(value);
     StorePointer(FieldAddr(field), value.raw());
   }
 
   RawType* GetType() const;
 
-  virtual RawAbstractTypeArguments* GetTypeArguments() const;
-  virtual void SetTypeArguments(const AbstractTypeArguments& value) const;
+  virtual RawTypeArguments* GetTypeArguments() const;
+  virtual void SetTypeArguments(const TypeArguments& value) const;
 
   // Check if the type of this instance is a subtype of the given type.
   bool IsInstanceOf(const AbstractType& type,
-                    const AbstractTypeArguments& type_instantiator,
+                    const TypeArguments& type_instantiator,
                     Error* bound_error) const;
 
   // Check whether this instance is identical to the argument according to the
   // specification of dare:core's identical().
   bool IsIdenticalTo(const Instance& other) const;
 
   bool IsValidNativeIndex(int index) const {
     return ((index >= 0) && (index < clazz()->ptr()->num_native_fields_));
   }
 
@@ skipping 66 matching lines @@
   virtual bool IsBeingFinalized() const;
   virtual bool IsMalformed() const;
   virtual bool IsMalbounded() const;
   virtual bool IsMalformedOrMalbounded() const;
   virtual RawLanguageError* error() const;
   virtual void set_error(const LanguageError& 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 RawTypeArguments* arguments() const;
   virtual intptr_t token_pos() const;
   virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const;
   virtual bool Equals(const Instance& other) const {
     return IsEquivalent(other);
   }
   virtual bool IsEquivalent(const Instance& other,
                             GrowableObjectArray* trail = NULL) const;
 
   // Instantiate this type using the given type argument vector.
   // Return a new type, or return 'this' if it is already instantiated.
   // If bound_error is not NULL, it may be set to reflect a bound error.
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
+      const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       GrowableObjectArray* trail = NULL) const;
 
   // Return a clone of this unfinalized type or the type itself if it is
   // already finalized. Apply recursively to type arguments, i.e. finalized
   // type arguments of an unfinalized type are not cloned, but shared.
   virtual RawAbstractType* CloneUnfinalized() const;
 
   virtual RawInstance* CheckAndCanonicalize(const char** error_str) const {
     return Canonicalize();
@@ skipping 78 matching lines @@
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractType& other,
                 Error* bound_error) const;
 
   // Return the internal or public name of this type, including the names of its
   // type arguments, if any.
   RawString* BuildName(NameVisibility visibility) const;
 
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractType, Instance);
-  friend class AbstractTypeArguments;
   friend class Class;
   friend class Function;
+  friend class TypeArguments;
 };
 
 
 // A Type consists of a class, possibly parameterized with type
 // arguments. Example: C<T1, T2>.
 // An unresolved class is a String specifying the class name.
 //
 // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type, as
 // opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does not
 // relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
@@ skipping 16 matching lines @@
   virtual bool IsMalformed() const;
   virtual bool IsMalbounded() const;
   virtual bool IsMalformedOrMalbounded() const;
   virtual RawLanguageError* error() const { return raw_ptr()->error_; }
   virtual void set_error(const LanguageError& 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;
-  virtual RawAbstractTypeArguments* arguments() const;
-  void set_arguments(const AbstractTypeArguments& value) const;
+  virtual RawTypeArguments* arguments() const;
+  void set_arguments(const TypeArguments& value) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other,
                             GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
+      const TypeArguments& instantiator_type_arguments,
       Error* malformed_error,
       GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* Canonicalize(
       GrowableObjectArray* trail = NULL) const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
@@ skipping 41 matching lines @@
   // The 'Array' type.
   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 AbstractTypeArguments& arguments,
+                      const TypeArguments& arguments,
                       intptr_t token_pos,
                       Heap::Space space = Heap::kOld);
 
  private:
   void set_token_pos(intptr_t 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;
 };
 
 
 // A TypeRef is used to break cycles in the representation of recursive types.
 // Its only field is the recursive AbstractType it refers to.
 // Note that the cycle always involves type arguments.
 class TypeRef : public AbstractType {
  public:
   virtual bool IsFinalized() const {
     return AbstractType::Handle(type()).IsFinalized();
@@ skipping 10 matching lines @@
   virtual bool IsMalformedOrMalbounded() const {
     return AbstractType::Handle(type()).IsMalformedOrMalbounded();
   }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return true; }
   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 RawAbstractTypeArguments* arguments() const {
+  virtual RawTypeArguments* arguments() const {
     return AbstractType::Handle(type()).arguments();
   }
   virtual intptr_t token_pos() const {
     return AbstractType::Handle(type()).token_pos();
   }
   virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other,
                             GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
+      const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* Canonicalize(
       GrowableObjectArray* trail = NULL) const;
 
   virtual intptr_t Hash() const;
 
   // Return true if the receiver is contained in the trail.
   // Otherwise, if the trail is null, allocate a trail, then add the receiver to
   // the trail and return false.
@@ skipping 67 matching lines @@
   bool CheckBound(const AbstractType& bounded_type,
                   const AbstractType& upper_bound,
                   Error* bound_error) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const {
     return false;
   }
   virtual bool IsEquivalent(const Instance& other,
                             GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
+      const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* Canonicalize(
       GrowableObjectArray* trail = NULL) const {
     return raw();
   }
 
   virtual intptr_t Hash() const;
 
@@ skipping 41 matching lines @@
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const {
     return AbstractType::Handle(type()).HasResolvedTypeClass();
   }
   virtual RawClass* type_class() const {
     return AbstractType::Handle(type()).type_class();
   }
   virtual RawUnresolvedClass* unresolved_class() const {
     return AbstractType::Handle(type()).unresolved_class();
   }
-  virtual RawAbstractTypeArguments* arguments() const {
+  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 {
     return AbstractType::Handle(type()).token_pos();
   }
   virtual bool IsInstantiated(GrowableObjectArray* 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,
                             GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments,
+      const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       GrowableObjectArray* trail = NULL) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* Canonicalize(
       GrowableObjectArray* trail = NULL) const {
     return raw();
   }
 
   virtual intptr_t Hash() const;
 
@@ skipping 1066 matching lines @@
   }
   void SetAt(intptr_t index, const Object& value) const {
     // TODO(iposva): Add storing NoGCScope.
     StorePointer(ObjectAddr(index), value.raw());
   }
 
   bool IsImmutable() const {
     return raw()->GetClassId() == kImmutableArrayCid;
   }
 
-  virtual RawAbstractTypeArguments* GetTypeArguments() const {
+  virtual RawTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
-  virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
+  virtual void SetTypeArguments(const TypeArguments& value) const {
     // An Array is raw or takes one type argument. However, its type argument
     // vector may be longer than 1 due to a type optimization reusing the type
     // argument vector of the instantiator.
     ASSERT(value.IsNull() || ((value.Length() >= 1) && value.IsInstantiated()));
     StorePointer(&raw_ptr()->type_arguments_, value.raw());
   }
 
   virtual bool Equals(const Instance& other) const;
 
   static const intptr_t kBytesPerElement = kWordSize;
@@ skipping 134 matching lines @@
 
     // TODO(iposva): Add storing NoGCScope.
     DataStorePointer(ObjectAddr(index), value.raw());
   }
 
   void Add(const Object& value, Heap::Space space = Heap::kNew) const;
 
   void Grow(intptr_t new_capacity, Heap::Space space = Heap::kNew) const;
   RawObject* RemoveLast() const;
 
-  virtual RawAbstractTypeArguments* GetTypeArguments() const {
+  virtual RawTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
-  virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
+  virtual void SetTypeArguments(const TypeArguments& value) const {
     // A GrowableObjectArray is raw or takes one type argument. However, its
     // type argument vector may be longer than 1 due to a type optimization
     // reusing the type argument vector of the instantiator.
     ASSERT(value.IsNull() || ((value.Length() >= 1) && value.IsInstantiated()));
     const Array& contents = Array::Handle(data());
     contents.SetTypeArguments(value);
     StorePointer(&raw_ptr()->type_arguments_, value.raw());
   }
 
   virtual bool Equals(const Instance& other) const;
@@ skipping 474 matching lines @@
     return static_cast<intptr_t>(kFunctionOffset * kWordSize);
   }
 
   static RawContext* context(const Instance& closure) {
     return *ContextAddr(closure);
   }
   static intptr_t context_offset() {
     return static_cast<intptr_t>(kContextOffset * kWordSize);
   }
 
-  static RawAbstractTypeArguments* GetTypeArguments(const Instance& closure) {
+  static RawTypeArguments* GetTypeArguments(const Instance& closure) {
     return *TypeArgumentsAddr(closure);
   }
   static void SetTypeArguments(const Instance& closure,
-                               const AbstractTypeArguments& value) {
+                               const TypeArguments& value) {
     closure.StorePointer(TypeArgumentsAddr(closure), value.raw());
   }
   static intptr_t type_arguments_offset() {
     return static_cast<intptr_t>(kTypeArgumentsOffset * kWordSize);
   }
 
   static const char* ToCString(const Instance& closure);
 
   static intptr_t InstanceSize() {
     intptr_t size = sizeof(RawInstance) + (kNumFields * kWordSize);
     ASSERT(size == Object::RoundedAllocationSize(size));
     return size;
   }
 
   static RawInstance* New(const Function& function,
                           const Context& context,
                           Heap::Space space = Heap::kNew);
 
  private:
   static const int kTypeArgumentsOffset = 1;
   static const int kFunctionOffset = 2;
   static const int kContextOffset = 3;
   static const int kNumFields = 3;
 
-  static RawAbstractTypeArguments** TypeArgumentsAddr(const Instance& obj) {
+  static RawTypeArguments** TypeArgumentsAddr(const Instance& obj) {
     ASSERT(obj.IsClosure());
-    return reinterpret_cast<RawAbstractTypeArguments**>(
+    return reinterpret_cast<RawTypeArguments**>(
         reinterpret_cast<intptr_t>(obj.raw_ptr()) + type_arguments_offset());
   }
   static RawFunction** FunctionAddr(const Instance& obj) {
     ASSERT(obj.IsClosure());
     return reinterpret_cast<RawFunction**>(
         reinterpret_cast<intptr_t>(obj.raw_ptr()) + function_offset());
   }
   static RawContext** ContextAddr(const Instance& obj) {
     ASSERT(obj.IsClosure());
     return reinterpret_cast<RawContext**>(
@@ skipping 326 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_