Ongoing renaming of type classes:

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 36 matching lines @@
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::abstract_type_arguments_class_ =
+    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::type_array_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 16 matching lines @@
   } else if (raw_class == void_class()) {
     return kVoidClass;
   } else if (raw_class == unresolved_class_class()) {
     return kUnresolvedClassClass;
   } else if (raw_class == type_class()) {
     return kTypeClass;
   } else if (raw_class == type_parameter_class()) {
     return kTypeParameterClass;
   } else if (raw_class == instantiated_type_class()) {
     return kInstantiatedTypeClass;
+  } else if (raw_class == abstract_type_arguments_class()) {
+    return kAbstractTypeArgumentsClass;
   } else if (raw_class == type_arguments_class()) {
     return kTypeArgumentsClass;
-  } else if (raw_class == type_array_class()) {
-    return kTypeArrayClass;
   } else if (raw_class == instantiated_type_arguments_class()) {
     return kInstantiatedTypeArgumentsClass;
   } else if (raw_class == function_class()) {
     return kFunctionClass;
   } else if (raw_class == field_class()) {
     return kFieldClass;
   } else if (raw_class == token_stream_class()) {
     return kTokenStreamClass;
   } else if (raw_class == script_class()) {
     return kScriptClass;
@@ skipping 23 matching lines @@
 RawClass* Object::GetSingletonClass(int index) {
   switch (index) {
     case kClassClass: return class_class();
     case kNullClass: return null_class();
     case kDynamicClass: return dynamic_class();
     case kVoidClass: return void_class();
     case kUnresolvedClassClass: return unresolved_class_class();
     case kTypeClass: return type_class();
     case kTypeParameterClass: return type_parameter_class();
     case kInstantiatedTypeClass: return instantiated_type_class();
+    case kAbstractTypeArgumentsClass: return abstract_type_arguments_class();
     case kTypeArgumentsClass: return type_arguments_class();
-    case kTypeArrayClass: return type_array_class();
     case kInstantiatedTypeArgumentsClass:
         return instantiated_type_arguments_class();
     case kFunctionClass: return function_class();
     case kFieldClass: return field_class();
     case kTokenStreamClass: return token_stream_class();
     case kScriptClass: return script_class();
     case kLibraryClass: return library_class();
     case kLibraryPrefixClass: return library_prefix_class();
     case kCodeClass: return code_class();
     case kInstructionsClass: return instructions_class();
@@ skipping 12 matching lines @@
 const char* Object::GetSingletonClassName(int index) {
   switch (index) {
     case kClassClass: return "Class";
     case kNullClass: return "Null";
     case kDynamicClass: return "Dynamic";
     case kVoidClass: return "void";
     case kUnresolvedClassClass: return "UnresolvedClass";
     case kTypeClass: return "Type";
     case kTypeParameterClass: return "TypeParameter";
     case kInstantiatedTypeClass: return "InstantiatedType";
+    case kAbstractTypeArgumentsClass: return "AbstractTypeArguments";
     case kTypeArgumentsClass: return "TypeArguments";
-    case kTypeArrayClass: return "TypeArray";
     case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
     case kFunctionClass: return "Function";
     case kFieldClass: return "Field";
     case kTokenStreamClass: return "TokenStream";
     case kScriptClass: return "Script";
     case kLibraryClass: return "Library";
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
@@ skipping 88 matching lines @@
 
   cls = Class::New<Type>();
   type_class_ = cls.raw();
 
   cls = Class::New<TypeParameter>();
   type_parameter_class_ = cls.raw();
 
   cls = Class::New<InstantiatedType>();
   instantiated_type_class_ = cls.raw();
 
+  cls = Class::New<AbstractTypeArguments>();
+  abstract_type_arguments_class_ = cls.raw();
+
   cls = Class::New<TypeArguments>();
   type_arguments_class_ = cls.raw();
 
-  cls = Class::New<TypeArray>();
-  type_array_class_ = cls.raw();
-
   cls = Class::New<InstantiatedTypeArguments>();
   instantiated_type_arguments_class_ = cls.raw();
 
   cls = Class::New<Function>();
   function_class_ = cls.raw();
 
   cls = Class::New<Field>();
   field_class_ = cls.raw();
 
   cls = Class::New<TokenStream>();
@@ skipping 438 matching lines @@
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   // See Class::NewSignatureClass() for the setup of its type parameters.
   // During type finalization, the type arguments of the super class of the
   // owner class of its signature function will be prepended to the type
   // argument vector. Therefore, we only need to set the type arguments
   // matching the type parameters here.
   if (num_type_params > 0) {
     const Array& type_params = Array::Handle(type_parameters());
-    signature_type_arguments = TypeArguments::NewTypeArray(num_type_params);
+    signature_type_arguments = TypeArguments::New(num_type_params);
     String& type_param_name = String::Handle();
     AbstractType& type_param = AbstractType::Handle();
     for (int i = 0; i < num_type_params; i++) {
       type_param_name ^= type_params.At(i);
       type_param = AbstractType::NewTypeParameter(i, type_param_name);
       signature_type_arguments.SetTypeAt(i, type_param);
     }
   }
   const Type& signature_type = Type::Handle(
       Type::New(*this, signature_type_arguments));
@@ skipping 85 matching lines @@
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const Array& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
 }
 
 
-void Class::set_type_parameter_extends(const TypeArray& value) const {
+void Class::set_type_parameter_extends(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameter_extends_, value.raw());
 }
 
 
 intptr_t Class::NumTypeParameters() const {
   const Array& type_params = Array::Handle(type_parameters());
   if (type_params.IsNull()) {
     return 0;
   } else {
     return type_params.Length();
@@ skipping 214 matching lines @@
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script) {
   ASSERT(!signature_function.IsNull());
   const Class& owner_class = Class::Handle(signature_function.owner());
   ASSERT(!owner_class.IsNull());
   Array& type_parameters = Array::Handle();
-  TypeArray& type_parameter_extends = TypeArray::Handle();
+  TypeArguments& type_parameter_extends = TypeArguments::Handle();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   if (!signature_function.is_static()) {
     if ((owner_class.NumTypeParameters() > 0) &&
         !signature_function.HasInstantiatedSignature()) {
       type_parameters = owner_class.type_parameters();
       type_parameter_extends = owner_class.type_parameter_extends();
     }
   }
@@ skipping 191 matching lines @@
 }
 
 
 bool Class::IsCanonicalSignatureClass() const {
   const Function& function = Function::Handle(signature_function());
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
 
 bool Class::IsMoreSpecificThan(
-    const TypeArguments& type_arguments,
+    const AbstractTypeArguments& type_arguments,
     const Class& other,
-    const TypeArguments& other_type_arguments) const {
+    const AbstractTypeArguments& other_type_arguments) const {
   // Check for DynamicType.
   // The DynamicType on the lefthand side is replaced by the bottom type, which
   // is more specific than any type.
   // Any type is more specific than the DynamicType on the righthand side.
   if (IsDynamicClass() || other.IsDynamicClass()) {
     return true;
   }
   // Check for reflexivity.
   if (raw() == other.raw()) {
     const intptr_t len = NumTypeArguments();
@@ skipping 18 matching lines @@
     return fun.IsSubtypeOf(type_arguments,
                            other_fun,
                            other_type_arguments);
   }
   // Check for 'direct super type' in the case of an interface and check for
   // transitivity at the same time.
   if (other.is_interface()) {
     Array& interfaces = Array::Handle(this->interfaces());
     AbstractType& interface = AbstractType::Handle();
     Class& interface_class = Class::Handle();
-    TypeArguments& interface_args = TypeArguments::Handle();
+    AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
     for (intptr_t i = 0; i < interfaces.Length(); i++) {
       interface ^= interfaces.At(i);
       interface_class = interface.type_class();
       interface_args = interface.arguments();
       if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
         // This type implements an interface that is parameterized with generic
         // type(s), e.g. it implements Array<T>.
         // The uninstantiated type T must be instantiated using the type
         // parameters of this type before performing the type test.
         if (type_arguments.IsNull()) {
           // This type is raw, so the uninstantiated type arguments of the
           // interface cannot be instantiated and we must check against a raw
           // interface.
-          interface_args = TypeArray::null();
+          interface_args = TypeArguments::null();
         } else {
           // The type arguments of this type that are referred to by the type
           // parameters of the interface are at the end of the type vector,
           // after the type arguments of the super type of this type.
           const intptr_t offset = NumTypeArguments() - NumTypeParameters();
           interface_args = interface_args.InstantiateFrom(type_arguments,
                                                           offset);
           // TODO(regis): Check the subtyping constraints if any, i.e. if
           // interface.type_parameter_extends() is not an array of DynamicType.
           // Should we pass the constraints to InstantiateFrom and it would
@@ skipping 28 matching lines @@
                                         other_type_arguments);
 }
 
 
 bool Class::IsTopLevel() const {
   return String::Handle(Name()).Length() == 0;
 }
 
 
 bool Class::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 {
   ASSERT(is_finalized() || !ClassFinalizer::AllClassesFinalized());
   ASSERT(other.is_finalized() || !ClassFinalizer::AllClassesFinalized());
   if (test == kIsAssignableTo) {
     // The spec states that "a type T is assignable to a type S if T is a
     // subtype of S or S is a subtype of T". This is from the perspective of a
     // static checker, which does not know the actual type of the assigned
     // value. However, this type information is available at run time in checked
     // mode. We therefore apply a more restrictive subtype check, which prevents
     // heap pollution. We only keep the assignability check when assigning
     // values of a function type.
@@ skipping 277 matching lines @@
 }
 
 
 RawUnresolvedClass* AbstractType::unresolved_class() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return UnresolvedClass::null();
 }
 
 
-RawTypeArguments* AbstractType::arguments() const  {
+RawAbstractTypeArguments* AbstractType::arguments() const  {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 bool AbstractType::IsInstantiated() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
@@ skipping 15 matching lines @@
 
 
 bool AbstractType::Equals(const AbstractType& other) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 RawAbstractType* AbstractType::InstantiateFrom(
-    const TypeArguments& instantiator_type_arguments,
+    const AbstractTypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawAbstractType* AbstractType::Canonicalize() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawString* AbstractType::Name() const {
   // If the type is still being finalized, we may be reporting an error about
   // an illformed type, so proceed with caution.
-  const TypeArguments& args = TypeArguments::Handle(arguments());
+  const AbstractTypeArguments& args =
+      AbstractTypeArguments::Handle(arguments());
   const intptr_t num_args = args.IsNull() ? 0 : args.Length();
   String& class_name = String::Handle();
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
     class_name = cls.Name();
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
     if (num_type_params > num_args) {
       first_type_param_index = 0;
@@ skipping 118 matching lines @@
 
 bool AbstractType::IsMoreSpecificThan(const AbstractType& other) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // AbstractType parameters cannot be handled by Class::IsMoreSpecificThan().
   if (IsTypeParameter() || other.IsTypeParameter()) {
     return IsTypeParameter() && other.IsTypeParameter() &&
         (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
-  return cls.IsMoreSpecificThan(TypeArguments::Handle(arguments()),
-                                Class::Handle(other.type_class()),
-                                TypeArguments::Handle(other.arguments()));
+  return cls.IsMoreSpecificThan(
+      AbstractTypeArguments::Handle(arguments()),
+      Class::Handle(other.type_class()),
+      AbstractTypeArguments::Handle(other.arguments()));
 }
 
 
 bool AbstractType::Test(TypeTestKind test, const AbstractType& other) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // AbstractType parameters cannot be handled by Class::TestType().
   if (IsTypeParameter() || other.IsTypeParameter()) {
     return IsTypeParameter() && other.IsTypeParameter() &&
         (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
   if (test == kIsSubtypeOf) {
-    return cls.IsSubtypeOf(TypeArguments::Handle(arguments()),
+    return cls.IsSubtypeOf(AbstractTypeArguments::Handle(arguments()),
                             Class::Handle(other.type_class()),
-                            TypeArguments::Handle(other.arguments()));
+                            AbstractTypeArguments::Handle(other.arguments()));
   } else {
     ASSERT(test == kIsAssignableTo);
-    return cls.IsAssignableTo(TypeArguments::Handle(arguments()),
+    return cls.IsAssignableTo(AbstractTypeArguments::Handle(arguments()),
                               Class::Handle(other.type_class()),
-                              TypeArguments::Handle(other.arguments()));
+                              AbstractTypeArguments::Handle(other.arguments()));
   }
 }
 
 RawAbstractType* AbstractType::NewTypeParameter(
     intptr_t index, const String& name) {
   return TypeParameter::New(index, name);
 }
 
 
 RawAbstractType* AbstractType::NewInstantiatedType(
     const AbstractType& uninstantiated_type,
-    const TypeArguments& instantiator_type_arguments) {
+    const AbstractTypeArguments& instantiator_type_arguments) {
   return InstantiatedType::New(uninstantiated_type,
                                instantiator_type_arguments);
 }
 
 
 const char* AbstractType::ToCString() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return "AbstractType";
 }
@@ skipping 48 matching lines @@
   return Isolate::Current()->object_store()->function_interface();
 }
 
 
 RawType* Type::ListInterface() {
   return Isolate::Current()->object_store()->list_interface();
 }
 
 
 RawType* Type::NewRawType(const Class& type_class) {
-  const TypeArguments& type_arguments =
-      TypeArguments::Handle(type_class.type_parameter_extends());
+  const AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::Handle(type_class.type_parameter_extends());
   return NewParameterizedType(Object::Handle(type_class.raw()), type_arguments);
 }
 
 
 RawType* Type::NewNonParameterizedType(
     const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   Type& type = Type::Handle();
   type ^= Type::New(
       Object::Handle(type_class.raw()), no_type_arguments);
   type.set_is_finalized();
   type ^= type.Canonicalize();
   return type.raw();
 }
 
 
 RawType* Type::NewParameterizedType(const Object& clazz,
-                                    const TypeArguments& arguments) {
+                                    const AbstractTypeArguments& arguments) {
   return Type::New(clazz, arguments);
 }
 
 
 void Type::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawType::kFinalized);
 }
 
 
 void Type::set_is_being_finalized() const {
   ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawType::kBeingFinalized);
 }
 
 
 bool Type::IsResolved() const {
   if (IsFinalized()) {
     return true;
   }
   if (!HasResolvedTypeClass()) {
     return false;
   }
-  const TypeArguments& args = TypeArguments::Handle(arguments());
+  const AbstractTypeArguments& args =
+      AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsResolved();
 }
 
 
 bool Type::HasResolvedTypeClass() const {
   const Object& type_class = Object::Handle(raw_ptr()->type_class_);
   return !type_class.IsNull() && type_class.IsClass();
 }
 
 
 RawClass* Type::type_class() const {
   ASSERT(HasResolvedTypeClass());
   Class& type_class = Class::Handle();
   type_class ^= raw_ptr()->type_class_;
   return type_class.raw();
 }
 
 
 RawUnresolvedClass* Type::unresolved_class() const {
   ASSERT(!HasResolvedTypeClass());
   UnresolvedClass& unresolved_class = UnresolvedClass::Handle();
   unresolved_class ^= raw_ptr()->type_class_;
   ASSERT(!unresolved_class.IsNull());
   return unresolved_class.raw();
 }
 
 
-RawTypeArguments* Type::arguments() const {
+RawAbstractTypeArguments* Type::arguments() const {
   return raw_ptr()->arguments_;
 }
 
 
 bool Type::IsInstantiated() const {
-  const TypeArguments& args = TypeArguments::Handle(arguments());
+  const AbstractTypeArguments& args =
+      AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
-    const TypeArguments& instantiator_type_arguments,
+    const AbstractTypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
-  TypeArguments& type_arguments = TypeArguments::Handle(arguments());
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
                                                   offset);
   const Class& cls = Class::Handle(type_class());
   ASSERT(cls.is_finalized());
   Type& instantiated_type = Type::Handle(Type::New(cls, type_arguments));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
 bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsType()) {
     return false;
   }
   Type& other_parameterized_type = Type::Handle();
   other_parameterized_type ^= other.raw();
   if (type_class() != other_parameterized_type.type_class()) {
     return false;
   }
-  return TypeArguments::AreEqual(TypeArguments::Handle(arguments()),
-                                 TypeArguments::Handle(other.arguments()));
+  return AbstractTypeArguments::AreEqual(
+      AbstractTypeArguments::Handle(arguments()),
+      AbstractTypeArguments::Handle(other.arguments()));
 }
 
 
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
     // TODO(regis): Should we add null_class_, void_class_, dynamic_class_ to
@@ skipping 35 matching lines @@
   return this->raw();
 }
 
 
 void Type::set_type_class(const Object& value) const {
   ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
 
-void Type::set_arguments(const TypeArguments& value) const {
+void Type::set_arguments(const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
 RawType* Type::New() {
   const Class& type_class = Class::Handle(Object::type_class());
   RawObject* raw = Object::Allocate(type_class,
                                     Type::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
-                                             const TypeArguments& arguments) {
+                   const AbstractTypeArguments& arguments) {
   const Type& result = Type::Handle(Type::New());
   result.set_type_class(clazz);
   result.set_arguments(arguments);
   result.raw_ptr()->type_state_ = RawType::kAllocated;
   return result.raw();
 }
 
 
 void Type::set_type_state(int8_t state) const {
   ASSERT(state == RawType::kAllocated ||
          state == RawType::kBeingFinalized ||
          state == RawType::kFinalized);
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* Type::ToCString() const {
   if (IsResolved()) {
-    const TypeArguments& type_arguments = TypeArguments::Handle(arguments());
+    const AbstractTypeArguments& type_arguments =
+        AbstractTypeArguments::Handle(arguments());
     if (type_arguments.IsNull()) {
       const char* format = "Type: class '%s'";
       const char* class_name =
           String::Handle(Class::Handle(type_class()).Name()).ToCString();
       intptr_t len = OS::SNPrint(NULL, 0, format, class_name) + 1;
       char* chars = reinterpret_cast<char*>(
           Isolate::Current()->current_zone()->Allocate(len));
       OS::SNPrint(chars, len, format, class_name);
       return chars;
     } else {
       const char* format = "Type: class '%s', args:[%s]";
       const char* class_name =
           String::Handle(Class::Handle(type_class()).Name()).ToCString();
-      const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
+      const char* args_cstr =
+          AbstractTypeArguments::Handle(arguments()).ToCString();
       intptr_t len = OS::SNPrint(NULL, 0, format, class_name, args_cstr) + 1;
       char* chars = reinterpret_cast<char*>(
           Isolate::Current()->current_zone()->Allocate(len));
       OS::SNPrint(chars, len, format, class_name, args_cstr);
       return chars;
     }
   } else {
     return "Unresolved Type";
   }
 }
@@ skipping 18 matching lines @@
 }
 
 
 void TypeParameter::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 RawAbstractType* TypeParameter::InstantiateFrom(
-    const TypeArguments& instantiator_type_arguments,
+    const AbstractTypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
   return instantiator_type_arguments.TypeAt(Index() + offset);
 }
 
 
 RawTypeParameter* TypeParameter::New() {
   const Class& type_parameter_class =
@@ skipping 22 matching lines @@
   OS::SNPrint(chars, len, format, name_cstr, Index());
   return chars;
 }
 
 
 RawClass* InstantiatedType::type_class() const {
   return AbstractType::Handle(uninstantiated_type()).type_class();
 }
 
 
-RawTypeArguments* InstantiatedType::arguments() const {
-  return TypeArguments::NewInstantiatedTypeArguments(
-      TypeArguments::Handle(AbstractType::Handle(
+RawAbstractTypeArguments* InstantiatedType::arguments() const {
+  return AbstractTypeArguments::NewInstantiatedTypeArguments(
+      AbstractTypeArguments::Handle(AbstractType::Handle(
           uninstantiated_type()).arguments()),
-      TypeArguments::Handle(instantiator_type_arguments()));
+      AbstractTypeArguments::Handle(instantiator_type_arguments()));
 }
 
 
 void InstantiatedType::set_uninstantiated_type(
     const AbstractType& value) const {
   StorePointer(&raw_ptr()->uninstantiated_type_, value.raw());
 }
 
 
 void InstantiatedType::set_instantiator_type_arguments(
-    const TypeArguments& value) const {
+    const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
 }
 
 
 RawInstantiatedType* InstantiatedType::New() {
   const Class& instantiated_type_class =
       Class::Handle(Object::instantiated_type_class());
   RawObject* raw = Object::Allocate(instantiated_type_class,
                                     InstantiatedType::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawInstantiatedType*>(raw);
 }
 
 
 RawInstantiatedType* InstantiatedType::New(
     const AbstractType& uninstantiated_type,
-    const TypeArguments& instantiator_type_arguments) {
+    const AbstractTypeArguments& instantiator_type_arguments) {
   const InstantiatedType& result =
       InstantiatedType::Handle(InstantiatedType::New());
   result.set_uninstantiated_type(uninstantiated_type);
   result.set_instantiator_type_arguments(instantiator_type_arguments);
   return result.raw();
 }
 
 
 const char* InstantiatedType::ToCString() const {
   return "InstantiatedType";
 }
 
 
-intptr_t TypeArguments::Length() const  {
-  // TypeArguments is an abstract class.
+intptr_t AbstractTypeArguments::Length() const  {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return -1;
 }
 
 
-RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
-  // TypeArguments is an abstract class.
+RawAbstractType* AbstractTypeArguments::TypeAt(intptr_t index) const {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-void TypeArguments::SetTypeAt(intptr_t index, const AbstractType& value) const {
-  // TypeArguments is an abstract class.
+void AbstractTypeArguments::SetTypeAt(intptr_t index,
+                                      const AbstractType& value) const {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
 }
 
 
-bool TypeArguments::IsResolved() const {
-  // TypeArguments is an abstract class.
+bool AbstractTypeArguments::IsResolved() const {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool TypeArguments::IsInstantiated() const {
-  // TypeArguments is an abstract class.
+bool AbstractTypeArguments::IsInstantiated() const {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool TypeArguments::IsUninstantiatedIdentity() const {
-  // TypeArguments is an abstract class.
+bool AbstractTypeArguments::IsUninstantiatedIdentity() const {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool TypeArguments::Equals(const TypeArguments& other) const {
-  // TypeArguments is an abstract class.
+bool AbstractTypeArguments::Equals(const AbstractTypeArguments& other) const {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool TypeArguments::AreEqual(const TypeArguments& arguments,
-                             const TypeArguments& other_arguments) {
+bool AbstractTypeArguments::AreEqual(
+    const AbstractTypeArguments& arguments,
+    const AbstractTypeArguments& other_arguments) {
   if (arguments.raw() == other_arguments.raw()) {
     return true;
   }
   if (arguments.IsNull()) {
     return other_arguments.IsDynamicTypes(other_arguments.Length());
   }
   if (other_arguments.IsNull()) {
     return arguments.IsDynamicTypes(arguments.Length());
   }
   return arguments.Equals(other_arguments);
 }
 
 
-RawTypeArguments* TypeArguments::InstantiateFrom(
-    const TypeArguments& instantiator_type_arguments,
+RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
+    const AbstractTypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
-  // TypeArguments is an abstract class.
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-bool TypeArguments::IsDynamicTypes(intptr_t len) const {
+bool AbstractTypeArguments::IsDynamicTypes(intptr_t len) const {
   ASSERT(Length() >= len);
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     if (!type.HasResolvedTypeClass()) {
       ASSERT(type.IsTypeParameter());
       return false;
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
 
 
-bool TypeArguments::IsMoreSpecificThan(const TypeArguments& other,
-                                       intptr_t len) const {
+bool AbstractTypeArguments::IsMoreSpecificThan(
+    const AbstractTypeArguments& other,
+    intptr_t len) const {
   ASSERT(Length() >= len);
   ASSERT(!other.IsNull());
   ASSERT(other.Length() >= len);
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     other_type = other.TypeAt(i);
     ASSERT(!other_type.IsNull());
     if (!type.IsMoreSpecificThan(other_type)) {
       return false;
     }
   }
   return true;
 }
 
 
-RawTypeArguments* TypeArguments::NewTypeArray(intptr_t len) {
-  return TypeArray::New(len);
-}
-
-
-RawTypeArguments* TypeArguments::NewInstantiatedTypeArguments(
-    const TypeArguments& uninstantiated_type_arguments,
-    const TypeArguments& instantiator_type_arguments) {
+RawAbstractTypeArguments* AbstractTypeArguments::NewInstantiatedTypeArguments(
+    const AbstractTypeArguments& uninstantiated_type_arguments,
+    const AbstractTypeArguments& instantiator_type_arguments) {
   return InstantiatedTypeArguments::New(uninstantiated_type_arguments,
                                         instantiator_type_arguments);
 }
 
 
-const char* TypeArguments::ToCString() const {
-  // TypeArguments is an abstract class.
+const char* AbstractTypeArguments::ToCString() const {
+  // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
-  return "TypeArguments";
+  return "AbstractTypeArguments";
 }
 
 
-intptr_t TypeArray::Length() const {
+intptr_t TypeArguments::Length() const {
   ASSERT(!IsNull());
   return Smi::Value(raw_ptr()->length_);
 }
 
 
-RawAbstractType* TypeArray::TypeAt(intptr_t index) const {
+RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
   return *TypeAddr(index);
 }
 
 
-void TypeArray::SetTypeAt(intptr_t index, const AbstractType& value) const {
+void TypeArguments::SetTypeAt(intptr_t index, const AbstractType& value) const {
   // TODO(iposva): Add storing NoGCScope.
   *TypeAddr(index) = value.raw();
 }
 
 
-bool TypeArray::IsResolved() const {
+bool TypeArguments::IsResolved() const {
   AbstractType& type = AbstractType::Handle();
   intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsResolved()) {
       return false;
     }
   }
   return true;
 }
 
 
-bool TypeArray::IsInstantiated() const {
+bool TypeArguments::IsInstantiated() const {
   AbstractType& type = AbstractType::Handle();
   intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
       return false;
     }
   }
   return true;
 }
 
 
-bool TypeArray::IsUninstantiatedIdentity() const {
+bool TypeArguments::IsUninstantiatedIdentity() const {
   ASSERT(!IsInstantiated());
   AbstractType& type = AbstractType::Handle();
   intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsTypeParameter() || (type.Index() != i)) {
       return false;
     }
   }
   return true;
 }
 
 
-bool TypeArray::Equals(const TypeArguments& other) const {
+bool TypeArguments::Equals(const AbstractTypeArguments& other) const {
   intptr_t num_types = Length();
   if (num_types != other.Length()) {
     return false;
   }
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     other_type = other.TypeAt(i);
     if (!type.Equals(other_type)) {
       return false;
     }
   }
   return true;
 }
 
 
-RawTypeArguments* TypeArray::InstantiateFrom(
-    const TypeArguments& instantiator_type_arguments,
+RawAbstractTypeArguments* TypeArguments::InstantiateFrom(
+    const AbstractTypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   ASSERT(!IsInstantiated());
   if ((offset == 0) &&
       !instantiator_type_arguments.IsNull() &&
       IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
-  TypeArray& instantiated_array = TypeArray::Handle(TypeArray::New(num_types));
+  TypeArguments& instantiated_array =
+      TypeArguments::Handle(TypeArguments::New(num_types));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
       type = type.InstantiateFrom(instantiator_type_arguments, offset);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
-RawTypeArray* TypeArray::New(intptr_t len) {
+RawTypeArguments* TypeArguments::New(intptr_t len) {
   if ((len < 0) || (len > kMaxTypes)) {
     // TODO(iposva): Should we throw an illegal parameter exception?
     UNIMPLEMENTED();
     return null();
   }
 
-  const Class& type_array_class = Class::Handle(Object::type_array_class());
-  TypeArray& result = TypeArray::Handle();
+  const Class& type_arguments_class =
+      Class::Handle(Object::type_arguments_class());
+  TypeArguments& result = TypeArguments::Handle();
   {
-    RawObject* raw = Object::Allocate(type_array_class,
-                                      TypeArray::InstanceSize(len),
+    RawObject* raw = Object::Allocate(type_arguments_class,
+                                      TypeArguments::InstanceSize(len),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     for (intptr_t i = 0; i < len; i++) {
       *result.TypeAddr(i) = Type::null();
     }
   }
   return result.raw();
 }
 
 
-RawAbstractType** TypeArray::TypeAddr(intptr_t index) const {
+RawAbstractType** TypeArguments::TypeAddr(intptr_t index) const {
   // TODO(iposva): Determine if we should throw an exception here.
   ASSERT((index >= 0) && (index < Length()));
   return &raw_ptr()->types_[index];
 }
 
 
-void TypeArray::SetLength(intptr_t value) {
+void TypeArguments::SetLength(intptr_t value) {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   raw_ptr()->length_ = Smi::New(value);
 }
 
 
-const char* TypeArray::ToCString() const {
+const char* TypeArguments::ToCString() const {
   if (IsNull()) {
-    return "NULL TypeArray";
+    return "NULL TypeArguments";
   }
   const char* format = "%s [%s]";
-  const char* prev_cstr = "TypeArray:";
+  const char* prev_cstr = "TypeArguments:";
   for (int i = 0; i < Length(); i++) {
     const char* type_cstr = AbstractType::Handle(TypeAt(i)).ToCString();
     intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
     char* chars = reinterpret_cast<char*>(
         Isolate::Current()->current_zone()->Allocate(len));
     OS::SNPrint(chars, len, format, prev_cstr, type_cstr);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 intptr_t InstantiatedTypeArguments::Length() const {
-  return TypeArguments::Handle(uninstantiated_type_arguments()).Length();
+  return AbstractTypeArguments::Handle(
+      uninstantiated_type_arguments()).Length();
 }
 
 
 RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
   const AbstractType& type = AbstractType::Handle(
-      TypeArguments::Handle(uninstantiated_type_arguments()).TypeAt(index));
+      AbstractTypeArguments::Handle(
+          uninstantiated_type_arguments()).TypeAt(index));
   if (type.IsTypeParameter()) {
-    TypeArguments& instantiator =
-        TypeArguments::Handle(instantiator_type_arguments());
+    AbstractTypeArguments& instantiator =
+        AbstractTypeArguments::Handle(instantiator_type_arguments());
     return instantiator.TypeAt(type.Index());
   }
   if (!type.IsInstantiated()) {
     return InstantiatedType::New(
-        type, TypeArguments::Handle(instantiator_type_arguments()));
+        type, AbstractTypeArguments::Handle(instantiator_type_arguments()));
   }
   return type.raw();
 }
 
 
 void InstantiatedTypeArguments::SetTypeAt(intptr_t index,
                                           const AbstractType& value) const {
   // We only replace individual argument types during resolution at compile
   // time, when no type parameters are instantiated yet.
   UNREACHABLE();
 }
 
 
 void InstantiatedTypeArguments::set_uninstantiated_type_arguments(
-    const TypeArguments& value) const {
+    const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->uninstantiated_type_arguments_, value.raw());
 }
 
 
 void InstantiatedTypeArguments::set_instantiator_type_arguments(
-    const TypeArguments& value) const {
+    const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New() {
   const Class& instantiated_type_arguments_class =
       Class::Handle(Object::instantiated_type_arguments_class());
   RawObject* raw = Object::Allocate(instantiated_type_arguments_class,
                                     InstantiatedTypeArguments::InstanceSize(),
                                     Heap::kNew);
   return reinterpret_cast<RawInstantiatedTypeArguments*>(raw);
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New(
-    const TypeArguments& uninstantiated_type_arguments,
-    const TypeArguments& instantiator_type_arguments) {
+    const AbstractTypeArguments& uninstantiated_type_arguments,
+    const AbstractTypeArguments& instantiator_type_arguments) {
   const InstantiatedTypeArguments& result =
       InstantiatedTypeArguments::Handle(InstantiatedTypeArguments::New());
   result.set_uninstantiated_type_arguments(uninstantiated_type_arguments);
   result.set_instantiator_type_arguments(instantiator_type_arguments);
   return result.raw();
 }
 
 
 const char* InstantiatedTypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL InstantiatedTypeArguments";
   }
   const char* format = "InstantiatedTypeArguments: [%s] instantiator: [%s]\n";
   const char* arg_cstr =
-      TypeArguments::Handle(uninstantiated_type_arguments()).ToCString();
+      AbstractTypeArguments::Handle(
+          uninstantiated_type_arguments()).ToCString();
   const char* instantiator_cstr =
-      TypeArguments::Handle(instantiator_type_arguments()).ToCString();
+      AbstractTypeArguments::Handle(instantiator_type_arguments()).ToCString();
   intptr_t len =
       OS::SNPrint(NULL, 0, format, arg_cstr, instantiator_cstr) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, format, arg_cstr, instantiator_cstr);
   return chars;
 }
 
 
 void Function::SetCode(const Code& value) const {
@@ skipping 271 matching lines @@
     if (ParameterNameAt(i) != other_param_name.raw()) {
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::TestParameterType(
     intptr_t parameter_position,
-    const TypeArguments& type_arguments,
+    const AbstractTypeArguments& type_arguments,
     const Function& other,
-    const TypeArguments& other_type_arguments) const {
+    const AbstractTypeArguments& other_type_arguments) const {
   AbstractType& param_type =
       AbstractType::Handle(ParameterTypeAt(parameter_position));
   if (!param_type.IsInstantiated()) {
     param_type = param_type.InstantiateFrom(type_arguments, 0);
   }
   if (param_type.IsDynamicType()) {
     return true;
   }
   AbstractType& other_param_type =
       AbstractType::Handle(other.ParameterTypeAt(parameter_position));
   if (!other_param_type.IsInstantiated()) {
     other_param_type =
         other_param_type.InstantiateFrom(other_type_arguments, 0);
   }
   if (other_param_type.IsDynamicType()) {
     return true;
   }
   if (!param_type.IsSubtypeOf(other_param_type) &&
       !other_param_type.IsSubtypeOf(param_type)) {
     return false;
   }
   return true;
 }
 
 
-bool Function::TestType(TypeTestKind test,
-                        const TypeArguments& type_arguments,
-                        const Function& other,
-                        const TypeArguments& other_type_arguments) const {
+bool Function::TestType(
+    TypeTestKind test,
+    const AbstractTypeArguments& type_arguments,
+    const Function& other,
+    const AbstractTypeArguments& other_type_arguments) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_params = other.num_optional_parameters();
   if ((num_fixed_params != other_num_fixed_params) ||
       ((test == AbstractType::kIsSubtypeOf) &&
        (num_opt_params < other_num_opt_params))) {
     return false;
   }
   // Check the result type.
@@ skipping 198 matching lines @@
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
   Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
   for (int i = 0; i < objs.length(); i++) {
     a.SetAt(i, *objs[i]);
   }
   return a.raw();
 }
 
 
 RawString* Function::BuildSignature(bool instantiate,
-                                    const TypeArguments& instantiator,
+                                    const AbstractTypeArguments& instantiator,
                                     intptr_t offset) const {
   GrowableArray<const String*> pieces;
   const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
   const String& kColonSpace = String::Handle(String::NewSymbol(": "));
   const String& kLParen = String::Handle(String::NewSymbol("("));
   const String& kRParen = String::Handle(String::NewSymbol(") => "));
   const String& kLBracket = String::Handle(String::NewSymbol("["));
   const String& kRBracket = String::Handle(String::NewSymbol("]"));
   if (!instantiate && !is_static()) {
     const String& kSpaceExtendsSpace =
         String::Handle(String::NewSymbol(" extends "));
     const String& kLAngleBracket = String::Handle(String::NewSymbol("<"));
     const String& kRAngleBracket = String::Handle(String::NewSymbol(">"));
     const Class& function_class = Class::Handle(owner());
     ASSERT(!function_class.IsNull());
     const Array& type_parameters = Array::Handle(
         function_class.type_parameters());
     if (!type_parameters.IsNull()) {
       intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(&kLAngleBracket);
-      const TypeArray& type_parameter_extends = TypeArray::Handle(
+      const TypeArguments& type_parameter_extends = TypeArguments::Handle(
           function_class.type_parameter_extends());
       AbstractType& parameter_extends = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         String& type_parameter = String::ZoneHandle();
         type_parameter ^= type_parameters.At(i);
         pieces.Add(&type_parameter);
         parameter_extends = type_parameter_extends.TypeAt(i);
         if (!parameter_extends.IsNull() && !parameter_extends.IsDynamicType()) {
           pieces.Add(&kSpaceExtendsSpace);
           pieces.Add(&String::ZoneHandle(parameter_extends.Name()));
@@ skipping 1711 matching lines @@
   }
   return this->raw();
 }
 
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
-  TypeArguments& type_arguments = TypeArguments::Handle();
+  AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   if (cls.HasTypeArguments()) {
     type_arguments = GetTypeArguments();
   }
   const Type& type = Type::Handle(Type::New(cls, type_arguments));
   type.set_is_finalized();
   return type.raw();
 }
 
 
-RawTypeArguments* Instance::GetTypeArguments() const {
+RawAbstractTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
-  TypeArguments& type_arguments = TypeArguments::Handle();
+  AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   type_arguments ^= *FieldAddrAtOffset(field_offset);
   return type_arguments.raw();
 }
 
 
-void Instance::SetTypeArguments(const TypeArguments& value) const {
+void Instance::SetTypeArguments(const AbstractTypeArguments& value) const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   *FieldAddrAtOffset(field_offset) = value.raw();
 }
 
 
 bool Instance::TestType(TypeTestKind test,
                         const AbstractType& other,
-                        const TypeArguments& other_instantiator) const {
+                        const AbstractTypeArguments& other_instantiator) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsVoidType());
   if (IsNull()) {
     if (test == AbstractType::kIsSubtypeOf) {
       Class& other_class = Class::Handle();
       if (other.IsTypeParameter()) {
         if (other_instantiator.IsNull()) {
           return true;  // Other type is uninstantiated, i.e. Dynamic.
         }
         const AbstractType& instantiated_other =
             AbstractType::Handle(other_instantiator.TypeAt(other.Index()));
         ASSERT(instantiated_other.IsInstantiated());
         other_class = instantiated_other.type_class();
       } else {
         other_class = other.type_class();
       }
       return other_class.IsObjectClass() || other_class.IsDynamicClass();
     } else {
       ASSERT(test == AbstractType::kIsAssignableTo);
       return true;
     }
   }
   const Class& cls = Class::Handle(clazz());
-  TypeArguments& type_arguments = TypeArguments::Handle();
+  AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   const intptr_t num_type_arguments = cls.NumTypeArguments();
   if (num_type_arguments > 0) {
     type_arguments = GetTypeArguments();
     // Verify that the number of type arguments in the instance matches the
     // number of type arguments expected by the instance class.
     // A discrepancy is allowed for closures, which borrow the type argument
     // vector of their instantiator, which may be of a super class of the class
     // defining the closure. Truncating the vector to the correct length on
     // instantiation is unnecessary. The vector may therefore be longer.
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.Length() == num_type_arguments) ||
            (cls.IsSignatureClass() &&
             (type_arguments.Length() > num_type_arguments)));
   }
   Class& other_class = Class::Handle();
-  TypeArguments& other_type_arguments = TypeArguments::Handle();
+  AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator, 0), however, we can save the
   // allocation of a new AbstractType by inlining the code.
   if (other.IsTypeParameter()) {
     AbstractType& instantiated_other = AbstractType::Handle();
     if (!other_instantiator.IsNull()) {
       instantiated_other = other_instantiator.TypeAt(other.Index());
       ASSERT(instantiated_other.IsInstantiated());
     } else {
       instantiated_other = Type::DynamicType();
@@ skipping 53 matching lines @@
 
 const char* Instance::ToCString() const {
   if (IsNull()) {
     return "null";
   } else if (Isolate::Current()->no_gc_scope_depth() > 0) {
     // Can occur when running disassembler.
     return "Instance";
   } else {
     const char* kFormat = "Instance of '%s'";
     Class& cls = Class::Handle(clazz());
-    TypeArguments& type_arguments = TypeArguments::Handle();
+    AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type = Type::Handle(
         Type::NewParameterizedType(cls, type_arguments));
     const String& type_name = String::Handle(type.Name());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = reinterpret_cast<char*>(
@@ skipping 1667 matching lines @@
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsArray() || other.IsNull()) {
     return false;
   }
 
   // Must have the same type arguments.
-  if (!TypeArguments::AreEqual(
-      TypeArguments::Handle(GetTypeArguments()),
-      TypeArguments::Handle(other.GetTypeArguments()))) {
+  if (!AbstractTypeArguments::AreEqual(
+      AbstractTypeArguments::Handle(GetTypeArguments()),
+      AbstractTypeArguments::Handle(other.GetTypeArguments()))) {
     return false;
   }
 
   Array& other_arr = Array::Handle();
   other_arr ^= other.raw();
 
   intptr_t len = this->Length();
   if (len != other_arr.Length()) {
     return false;
   }
@@ skipping 421 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart