Ongoing renaming of type classes:

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 106 matching lines @@
     kNullObject = 0,
     kSentinelObject,
     kClassClass,
     kNullClass,
     kDynamicClass,
     kVoidClass,
     kUnresolvedClassClass,
     kTypeClass,
     kTypeParameterClass,
     kInstantiatedTypeClass,
+    kAbstractTypeArgumentsClass,
     kTypeArgumentsClass,
-    kTypeArrayClass,
     kInstantiatedTypeArgumentsClass,
     kFunctionClass,
     kFieldClass,
     kTokenStreamClass,
     kScriptClass,
     kLibraryClass,
     kLibraryPrefixClass,
     kCodeClass,
     kInstructionsClass,
     kPcDescriptorsClass,
@@ skipping 74 matching lines @@
   static RawClass* dynamic_class() { return dynamic_class_; }
   static RawClass* void_class() { return void_class_; }
   static RawClass* unresolved_class_class() { return unresolved_class_class_; }
   static RawClass* type_class() {
       return type_class_;
   }
   static RawClass* type_parameter_class() { return type_parameter_class_; }
   static RawClass* instantiated_type_class() {
       return instantiated_type_class_;
   }
+  static RawClass* abstract_type_arguments_class() {
+    return abstract_type_arguments_class_;
+  }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
-  static RawClass* type_array_class() { return type_array_class_; }
   static RawClass* instantiated_type_arguments_class() {
       return instantiated_type_arguments_class_;
   }
   static RawClass* function_class() { return function_class_; }
   static RawClass* field_class() { return field_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_; }
   static RawClass* code_class() { return code_class_; }
@@ skipping 83 matching lines @@
   static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
   static RawClass* dynamic_class_;  // Class of the 'Dynamic' type.
   static RawClass* void_class_;  // Class of the 'void' type.
   static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
   static RawClass* type_class_;  // Class of Type.
   static RawClass* type_parameter_class_;  // Class of TypeParameter vm object.
   static RawClass* instantiated_type_class_;  // Class of InstantiatedType.
-  static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
-  static RawClass* type_array_class_;  // Class of the TypeArray vm object.
+  // Class of AbstractTypeArguments vm object.
+  static RawClass* abstract_type_arguments_class_;
+  // Class of the TypeArguments vm object.
+  static RawClass* type_arguments_class_;
   static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
   static RawClass* function_class_;  // Class of the Function vm object.
   static RawClass* field_class_;  // Class of the Field 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.
   static RawClass* code_class_;  // Class of the Code vm object.
   static RawClass* instructions_class_;  // Class of the Instructions vm object.
   static RawClass* pc_descriptors_class_;  // Class of PcDescriptors vm object.
@@ skipping 73 matching lines @@
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
   // The type parameters are specified as an array of Strings.
   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?
-  RawTypeArray* type_parameter_extends() const {
+  RawTypeArguments* type_parameter_extends() const {
     return raw_ptr()->type_parameter_extends_;
   }
-  void set_type_parameter_extends(const TypeArray& value) const;
+  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;
 
   // The type argument vector is flattened and includes the type arguments of
   // the super class.
   bool HasTypeArguments() const;
   intptr_t NumTypeArguments() const;
 
@@ skipping 56 matching lines @@
   // Check if this class represents a signature class.
   bool IsSignatureClass() const {
     return 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 "more specific than" relationship.
-  bool IsMoreSpecificThan(const TypeArguments& type_arguments,
-                          const Class& other,
-                          const TypeArguments& other_type_arguments) const;
+  bool IsMoreSpecificThan(
+      const AbstractTypeArguments& type_arguments,
+      const Class& other,
+      const AbstractTypeArguments& other_type_arguments) const;
 
   // Check the subtype relationship.
-  bool IsSubtypeOf(const TypeArguments& type_arguments,
+  bool IsSubtypeOf(const AbstractTypeArguments& type_arguments,
                    const Class& other,
-                   const TypeArguments& other_type_arguments) const {
+                   const AbstractTypeArguments& other_type_arguments) const {
     return TestType(kIsSubtypeOf,
                     type_arguments,
                     other,
                     other_type_arguments);
   }
 
   // Check the assignability relationship.
-  bool IsAssignableTo(const TypeArguments& type_arguments,
+  bool IsAssignableTo(const AbstractTypeArguments& type_arguments,
                       const Class& dst,
-                      const TypeArguments& dst_type_arguments) const {
+                      const AbstractTypeArguments& dst_type_arguments) const {
     return TestType(kIsAssignableTo,
                     type_arguments,
                     dst,
                     dst_type_arguments);
   }
 
   // Check if this is the top level class.
   bool IsTopLevel() const;
 
   RawArray* fields() const { return raw_ptr()->fields_; }
@@ skipping 93 matching lines @@
   void set_constants(const Array& value) const;
   RawArray* constants() const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
 
   void CalculateFieldOffsets() const;
 
   // Check the subtype or assignability relationship.
   bool TestType(TypeTestKind test,
-                const TypeArguments& type_arguments,
+                const AbstractTypeArguments& type_arguments,
                 const Class& other,
-                const TypeArguments& other_type_arguments) const;
+                const AbstractTypeArguments& other_type_arguments) const;
 
   // Assigns empty array to all raw class array fields.
   void InitEmptyFields();
 
   HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class Object;
   friend class Instance;
   friend class Type;
 };
 
@@ skipping 41 matching lines @@
 // 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 RawTypeArguments* arguments() 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.
   // Return a new type, or return 'this' if it is already instantiated.
   virtual RawAbstractType* InstantiateFrom(
-      const TypeArguments& instantiator_type_arguments,
+      const AbstractTypeArguments& instantiator_type_arguments,
       intptr_t offset) 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 57 matching lines @@
 
   // 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* NewInstantiatedType(
       const AbstractType& uninstantiated_type,
-      const TypeArguments& instantiator_type_arguments);
+      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);
   friend class Class;
 };
 
 
 // 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.
 class Type : public AbstractType {
  public:
   virtual bool IsFinalized() const {
     return raw_ptr()->type_state_ == RawType::kFinalized;
   }
   void set_is_finalized() const;
   virtual bool IsBeingFinalized() const {
     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 RawTypeArguments* arguments() const;
-  void set_arguments(const TypeArguments& value) 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 TypeArguments& instantiator_type_arguments,
+      const AbstractTypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
   virtual RawAbstractType* Canonicalize() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
   }
 
   // The type of the literal 'null'.
   static RawType* NullType();
 
@@ skipping 29 matching lines @@
 
   // 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);
 
   // The finalized type of the given non-parameterized class.
   static RawType* NewNonParameterizedType(const Class& type_class);
 
   static RawType* NewParameterizedType(
-      const Object& type_class, const TypeArguments& arguments);
+      const Object& type_class, const AbstractTypeArguments& arguments);
 
   static RawType* New(const Object& clazz,
-                                   const TypeArguments& arguments);
+                      const AbstractTypeArguments& arguments);
 
  private:
   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.
 class TypeParameter : 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 false; }
   virtual RawString* Name() const { return raw_ptr()->name_; }
   virtual intptr_t Index() const { return raw_ptr()->index_; }
   virtual bool IsInstantiated() const { return false; }
   virtual bool Equals(const AbstractType& other) const;
   virtual RawAbstractType* InstantiateFrom(
-      const TypeArguments& instantiator_type_arguments,
+      const AbstractTypeArguments& instantiator_type_arguments,
       intptr_t offset) 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;
   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 TypeArguments 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.
+// 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 RawTypeArguments* arguments() const;
+  virtual RawAbstractTypeArguments* arguments() const;
   virtual bool IsInstantiated() const { return true; }
 
   RawAbstractType* uninstantiated_type() const {
     return raw_ptr()->uninstantiated_type_;
   }
-  RawTypeArguments* instantiator_type_arguments() const {
+  RawAbstractTypeArguments* instantiator_type_arguments() const {
     return raw_ptr()->instantiator_type_arguments_;
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawInstantiatedType));
   }
 
   static RawInstantiatedType* New(
       const AbstractType& uninstantiated_type,
-      const TypeArguments& instantiator_type_arguments);
+      const AbstractTypeArguments& instantiator_type_arguments);
 
  private:
   void set_uninstantiated_type(const AbstractType& value) const;
-  void set_instantiator_type_arguments(const TypeArguments& value) const;
+  void set_instantiator_type_arguments(
+      const AbstractTypeArguments& value) const;
   static RawInstantiatedType* New();
 
   HEAP_OBJECT_IMPLEMENTATION(InstantiatedType, AbstractType);
   friend class Class;
 };
 
 
-// TypeArguments is an abstract superclass.
-// Subclasses of TypeArguments are TypeArray and InstantiatedTypes.
-class TypeArguments : public Object {
+// AbstractTypeArguments is an abstract superclass.
+// Subclasses of AbstractTypeArguments are TypeArguments and InstantiatedTypes.
+class AbstractTypeArguments : public Object {
  public:
-  static bool AreEqual(const TypeArguments& arguments,
-                       const TypeArguments& other_arguments);
+  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.
-  virtual RawTypeArguments* InstantiateFrom(
-      const TypeArguments& instantiator_type_arguments,
+  virtual RawAbstractTypeArguments* InstantiateFrom(
+      const AbstractTypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
   // 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'.
-  bool IsMoreSpecificThan(const TypeArguments& other, intptr_t len) const;
+  bool IsMoreSpecificThan(
+      const AbstractTypeArguments& other, intptr_t len) const;
 
-  static RawTypeArguments* NewTypeArray(intptr_t len);
+  static RawAbstractTypeArguments* NewInstantiatedTypeArguments(
+      const AbstractTypeArguments& uninstantiated_type_arguments,
+      const AbstractTypeArguments& instantiator_type_arguments);
 
-  static RawTypeArguments* NewInstantiatedTypeArguments(
-      const TypeArguments& uninstantiated_type_arguments,
-      const TypeArguments& instantiator_type_arguments);
-
-  // UNREACHABLEs as TypeArguments is an abstract class.
+  // 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() const;
   virtual bool IsUninstantiatedIdentity() const;
-  virtual bool Equals(const TypeArguments& other) const;
+  virtual bool Equals(const AbstractTypeArguments& other) const;
 
  protected:
-  HEAP_OBJECT_IMPLEMENTATION(TypeArguments, Object);
+  HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments, Object);
   friend class Class;
 };
 
 
-// A TypeArray is simply an array of Types.
-class TypeArray : public TypeArguments {
+// A TypeArguments is simply an array of Types.
+class TypeArguments : 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;
   virtual bool IsInstantiated() const;
   virtual bool IsUninstantiatedIdentity() const;
-  virtual bool Equals(const TypeArguments& other) const;
+  virtual bool Equals(const AbstractTypeArguments& other) const;
 
-  virtual RawTypeArguments* InstantiateFrom(
-      const TypeArguments& instantiator_type_arguments,
+  virtual RawAbstractTypeArguments* InstantiateFrom(
+      const AbstractTypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
-  static intptr_t length_offset() { return OFFSET_OF(RawTypeArray, length_); }
+  static intptr_t length_offset() {
+    return OFFSET_OF(RawTypeArguments, length_);
+  }
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawTypeArray) == OFFSET_OF(RawTypeArray, types_));
+    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(RawTypeArray) == 2 * kWordSize);
-    return RoundedAllocationSize(sizeof(RawTypeArray) + (len * kWordSize));
+    ASSERT(sizeof(RawTypeArguments) == 2 * kWordSize);
+    return RoundedAllocationSize(sizeof(RawTypeArguments) + (len * kWordSize));
   }
 
-  static RawTypeArray* New(intptr_t len);
+  static RawTypeArguments* New(intptr_t len);
 
  private:
   // Make sure that the array size cannot wrap around.
   static const intptr_t kMaxTypes = 512 * 1024 * 1024;
   RawAbstractType** TypeAddr(intptr_t index) const;
   void SetLength(intptr_t value);
 
-  HEAP_OBJECT_IMPLEMENTATION(TypeArray, TypeArguments);
+  HEAP_OBJECT_IMPLEMENTATION(TypeArguments, AbstractTypeArguments);
   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 TypeArguments
-// 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.
+// 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 TypeArguments {
+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() const { return true; }
   virtual bool IsUninstantiatedIdentity() const  { return false; }
 
-  RawTypeArguments* uninstantiated_type_arguments() 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_);
   }
 
-  RawTypeArguments* instantiator_type_arguments() const {
+  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 TypeArguments& uninstantiated_type_arguments,
-      const TypeArguments& instantiator_type_arguments);
+      const AbstractTypeArguments& uninstantiated_type_arguments,
+      const AbstractTypeArguments& instantiator_type_arguments);
 
  private:
-  void set_uninstantiated_type_arguments(const TypeArguments& value) const;
-  void set_instantiator_type_arguments(const TypeArguments& value) const;
+  void set_uninstantiated_type_arguments(
+      const AbstractTypeArguments& value) const;
+  void set_instantiator_type_arguments(
+      const AbstractTypeArguments& value) const;
   static RawInstantiatedTypeArguments* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments, TypeArguments);
+  HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments, AbstractTypeArguments);
   friend class Class;
 };
 
 
 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);
   }
 
   // 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 TypeArguments& instantiator,
-                                       intptr_t offset) const {
+  RawString* InstantiatedSignatureFrom(
+      const AbstractTypeArguments& instantiator,
+      intptr_t offset) const {
     return BuildSignature(true, instantiator, offset);
   }
 
   // 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;
 
@@ skipping 101 matching lines @@
   // ast printing. The special ':' character, if present, is replaced by '_'.
   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. Parameter types are ignored.
   bool HasCompatibleParametersWith(const Function& other) const;
 
   // Returns true if the type of this function is a subtype of the type of
   // the other function.
-  bool IsSubtypeOf(const TypeArguments& type_arguments,
+  bool IsSubtypeOf(const AbstractTypeArguments& type_arguments,
                    const Function& other,
-                   const TypeArguments& other_type_arguments) const {
+                   const AbstractTypeArguments& other_type_arguments) const {
     return TestType(kIsSubtypeOf,
                     type_arguments,
                     other,
                     other_type_arguments);
   }
 
   // Returns true if the type of this function can be assigned to the type of
   // the destination function.
-  bool IsAssignableTo(const TypeArguments& type_arguments,
+  bool IsAssignableTo(const AbstractTypeArguments& type_arguments,
                       const Function& dst,
-                      const TypeArguments& dst_type_arguments) const {
+                      const AbstractTypeArguments& dst_type_arguments) const {
     return TestType(kIsAssignableTo,
                     type_arguments,
                     dst,
                     dst_type_arguments);
   }
 
   // Returns true if this function represents a (possibly implicit) closure
   // function.
   bool IsClosureFunction() const {
     return kind() == RawFunction::kClosureFunction;
@@ skipping 56 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 TypeArguments& instantiator,
+                            const AbstractTypeArguments& instantiator,
                             intptr_t offset) 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 TypeArguments& type_arguments,
+                const AbstractTypeArguments& type_arguments,
                 const Function& other,
-                const TypeArguments& other_type_arguments) const;
+                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
   // of the other function.
-  bool TestParameterType(intptr_t parameter_position,
-                         const TypeArguments& type_arguments,
-                         const Function& other,
-                         const TypeArguments& other_type_arguments) const;
+  bool TestParameterType(
+      intptr_t parameter_position,
+      const AbstractTypeArguments& type_arguments,
+      const Function& other,
+      const AbstractTypeArguments& other_type_arguments) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Function, Object);
   friend class Class;
 };
 
 
 class Field : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   bool is_static() const { return raw_ptr()->is_static_; }
@@ skipping 781 matching lines @@
   RawObject* GetField(const Field& field) const {
     return *FieldAddr(field);
   }
 
   void SetField(const Field& field, const Object& value) const {
     *FieldAddr(field) = value.raw();
   }
 
   RawType* GetType() const;
 
-  virtual RawTypeArguments* GetTypeArguments() const;
-  virtual void SetTypeArguments(const TypeArguments& value) const;
+  virtual RawAbstractTypeArguments* GetTypeArguments() const;
+  virtual void SetTypeArguments(const AbstractTypeArguments& value) const;
 
   // Check if this instance is an instance of the given type.
   bool IsInstanceOf(const AbstractType& type,
-                    const TypeArguments& type_instantiator) const {
+                    const AbstractTypeArguments& type_instantiator) const {
     return TestType(kIsSubtypeOf, type, type_instantiator);
   }
 
   // Check if this instance is assignable to the given type.
   bool IsAssignableTo(const AbstractType& type,
-                      const TypeArguments& type_instantiator) const {
+                      const AbstractTypeArguments& type_instantiator) const {
     return TestType(kIsAssignableTo, type, type_instantiator);
   }
 
   bool IsValidNativeIndex(int index) const;
 
   intptr_t GetNativeField(int index) const {
     return *NativeFieldAddr(index);
   }
 
   void SetNativeField(int index, intptr_t value) const {
@@ skipping 22 matching lines @@
   }
   void SetFieldAtOffset(intptr_t offset, const Object& value) const {
     *FieldAddrAtOffset(offset) = value.raw();
   }
   bool IsValidFieldOffset(int offset) const;
 
   // Check the subtype or assignability relationship between the type of this
   // instance and the given type.
   bool TestType(TypeTestKind test,
                 const AbstractType& type,
-                const TypeArguments& type_instantiator) const;
+                const AbstractTypeArguments& type_instantiator) const;
 
   // TODO(iposva): Determine if this gets in the way of Smi.
   HEAP_OBJECT_IMPLEMENTATION(Instance, Object);
   friend class Class;
 };
 
 
 class Number : public Instance {
  public:
   // TODO(iposva): Fill in a useful Number interface.
@@ skipping 669 matching lines @@
   static intptr_t data_offset() { return length_offset() + kWordSize; }
 
   RawObject* At(intptr_t index) const {
     return *ObjectAddr(index);
   }
   void SetAt(intptr_t index, const Object& value) const {
     // TODO(iposva): Add storing NoGCScope.
     *ObjectAddr(index) = value.raw();
   }
 
-  virtual RawTypeArguments* GetTypeArguments() const {
+  virtual RawAbstractTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
-  virtual void SetTypeArguments(const TypeArguments& value) const {
+  virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
     raw_ptr()->type_arguments_ = value.raw();
   }
 
   virtual bool Equals(const Instance& other) const;
 
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawArray, type_arguments_);
   }
 
   static intptr_t InstanceSize() {
@@ skipping 129 matching lines @@
 class Closure : public Instance {
  public:
   RawFunction* function() const { return raw_ptr()->function_; }
   static intptr_t function_offset() {
     return OFFSET_OF(RawClosure, function_);
   }
 
   RawContext* context() const { return raw_ptr()->context_; }
   static intptr_t context_offset() { return OFFSET_OF(RawClosure, context_); }
 
-  virtual RawTypeArguments* GetTypeArguments() const {
+  virtual RawAbstractTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
-  virtual void SetTypeArguments(const TypeArguments& value) const {
+  virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
     raw_ptr()->type_arguments_ = value.raw();
   }
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawClosure, type_arguments_);
   }
 
   // TODO(iposva): Remove smrck support once mapping to arbitrary is available.
   RawInteger* smrck() const { return raw_ptr()->smrck_; }
   void set_smrck(const Integer& smrck) const {
     raw_ptr()->smrck_ = smrck.raw();
@@ skipping 179 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_