Implement eager instantiation and canonicalization of type arguments at run

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 71 matching lines @@
 // These are initialized to a value that will force a illegal memory access if
 // they are being used.
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 Object* Object::null_object_ = NULL;
 Array* Object::null_array_ = NULL;
 String* Object::null_string_ = NULL;
 Instance* Object::null_instance_ = NULL;
-AbstractTypeArguments* Object::null_abstract_type_arguments_ = NULL;
+TypeArguments* Object::null_type_arguments_ = NULL;
 Array* Object::empty_array_ = NULL;
 PcDescriptors* Object::empty_descriptors_ = NULL;
 Instance* Object::sentinel_ = NULL;
 Instance* Object::transition_sentinel_ = NULL;
 Instance* Object::unknown_constant_ = NULL;
 Instance* Object::non_constant_ = NULL;
 Bool* Object::bool_true_ = NULL;
 Bool* Object::bool_false_ = NULL;
 Smi* Object::smi_illegal_cid_ = NULL;
 LanguageError* Object::snapshot_writer_error_ = NULL;
 LanguageError* Object::branch_offset_error_ = NULL;
 
 RawObject* Object::null_ = reinterpret_cast<RawObject*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawType* Object::dynamic_type_ = reinterpret_cast<RawType*>(RAW_NULL);
 RawType* Object::void_type_ = reinterpret_cast<RawType*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::instantiated_type_arguments_class_ =
-    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::closure_data_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::redirection_data_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::literal_token_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);
@@ skipping 314 matching lines @@
   }
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   // Allocate the read only object handles here.
   null_object_ = Object::ReadOnlyHandle();
   null_array_ = Array::ReadOnlyHandle();
   null_string_ = String::ReadOnlyHandle();
   null_instance_ = Instance::ReadOnlyHandle();
-  null_abstract_type_arguments_ = AbstractTypeArguments::ReadOnlyHandle();
+  null_type_arguments_ = TypeArguments::ReadOnlyHandle();
   empty_array_ = Array::ReadOnlyHandle();
   empty_descriptors_ = PcDescriptors::ReadOnlyHandle();
   sentinel_ = Instance::ReadOnlyHandle();
   transition_sentinel_ = Instance::ReadOnlyHandle();
   unknown_constant_ =  Instance::ReadOnlyHandle();
   non_constant_ =  Instance::ReadOnlyHandle();
   bool_true_ = Bool::ReadOnlyHandle();
   bool_false_ = Bool::ReadOnlyHandle();
   smi_illegal_cid_ = Smi::ReadOnlyHandle();
   snapshot_writer_error_ = LanguageError::ReadOnlyHandle();
   branch_offset_error_ = LanguageError::ReadOnlyHandle();
 
 
   // Allocate and initialize the null instance.
   // 'null_' must be the first object allocated as it is used in allocation to
   // clear the object.
   {
     uword address = heap->Allocate(Instance::InstanceSize(), Heap::kOld);
     null_ = reinterpret_cast<RawInstance*>(address + kHeapObjectTag);
     // The call below is using 'null_' to initialize itself.
     InitializeObject(address, kNullCid, Instance::InstanceSize());
   }
 
   *null_object_ = Object::null();
   *null_array_ = Array::null();
   *null_string_ = String::null();
   *null_instance_ = Instance::null();
-  *null_abstract_type_arguments_ = AbstractTypeArguments::null();
+  *null_type_arguments_ = TypeArguments::null();
 
   // Initialize the empty array handle to null_ in order to be able to check
   // if the empty array was allocated (RAW_NULL is not available).
   *empty_array_ = Array::null();
 
   Class& cls = Class::Handle();
 
   // Allocate and initialize the class class.
   {
     intptr_t size = Class::InstanceSize();
@@ skipping 51 matching lines @@
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
   }
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
   cls = Class::New<TypeArguments>();
   type_arguments_class_ = cls.raw();
 
-  cls = Class::New<InstantiatedTypeArguments>();
-  instantiated_type_arguments_class_ = cls.raw();
-
   cls = Class::New<PatchClass>();
   patch_class_class_ = cls.raw();
 
   cls = Class::New<Function>();
   function_class_ = cls.raw();
 
   cls = Class::New<ClosureData>();
   closure_data_class_ = cls.raw();
 
   cls = Class::New<RedirectionData>();
@@ skipping 149 matching lines @@
   error_str = String::New("Branch offset overflow");
   *branch_offset_error_ = LanguageError::New(error_str);
 
   ASSERT(!null_object_->IsSmi());
   ASSERT(!null_array_->IsSmi());
   ASSERT(null_array_->IsArray());
   ASSERT(!null_string_->IsSmi());
   ASSERT(null_string_->IsString());
   ASSERT(!null_instance_->IsSmi());
   ASSERT(null_instance_->IsInstance());
-  ASSERT(!null_abstract_type_arguments_->IsSmi());
-  ASSERT(null_abstract_type_arguments_->IsAbstractTypeArguments());
+  ASSERT(!null_type_arguments_->IsSmi());
+  ASSERT(null_type_arguments_->IsTypeArguments());
   ASSERT(!empty_array_->IsSmi());
   ASSERT(empty_array_->IsArray());
   ASSERT(!sentinel_->IsSmi());
   ASSERT(sentinel_->IsInstance());
   ASSERT(!transition_sentinel_->IsSmi());
   ASSERT(transition_sentinel_->IsInstance());
   ASSERT(!unknown_constant_->IsSmi());
   ASSERT(unknown_constant_->IsInstance());
   ASSERT(!non_constant_->IsSmi());
   ASSERT(non_constant_->IsInstance());
@@ skipping 15 matching lines @@
 
 void Object::RegisterSingletonClassNames() {
   Class& cls = Class::Handle();
 
   // Set up names for all VM singleton classes.
   SET_CLASS_NAME(class, Class);
   SET_CLASS_NAME(dynamic, Dynamic);
   SET_CLASS_NAME(void, Void);
   SET_CLASS_NAME(unresolved_class, UnresolvedClass);
   SET_CLASS_NAME(type_arguments, TypeArguments);
-  SET_CLASS_NAME(instantiated_type_arguments, InstantiatedTypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
   SET_CLASS_NAME(function, Function);
   SET_CLASS_NAME(closure_data, ClosureData);
   SET_CLASS_NAME(redirection_data, RedirectionData);
   SET_CLASS_NAME(field, Field);
   SET_CLASS_NAME(literal_token, LiteralToken);
   SET_CLASS_NAME(token_stream, TokenStream);
   SET_CLASS_NAME(script, Script);
   SET_CLASS_NAME(library, LibraryClass);
   SET_CLASS_NAME(library_prefix, LibraryPrefix);
@@ skipping 850 matching lines @@
 
   // Return the still unfinalized signature type.
   ASSERT(!signature_type.IsFinalized());
   return signature_type.raw();
 }
 
 
 RawAbstractType* Class::RareType() const {
   const Type& type = Type::Handle(Type::New(
       *this,
-      Object::null_abstract_type_arguments(),
+      Object::null_type_arguments(),
       Scanner::kNoSourcePos));
   return ClassFinalizer::FinalizeType(*this,
                                       type,
                                       ClassFinalizer::kCanonicalize);
 }
 
 
 RawAbstractType* Class::DeclarationType() const {
   const TypeArguments& args = TypeArguments::Handle(type_parameters());
   const Type& type = Type::Handle(Type::New(
@@ skipping 386 matching lines @@
   if (!FLAG_overlap_type_arguments ||
       (num_type_params == 0) ||
       (super_type() == AbstractType::null()) ||
       (super_type() == isolate->object_store()->object_type())) {
     set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   ASSERT(!IsMixinApplication() || is_mixin_type_applied());
   const AbstractType& sup_type = AbstractType::Handle(isolate, super_type());
   ASSERT(sup_type.IsResolved());
-  const AbstractTypeArguments& sup_type_args =
-      AbstractTypeArguments::Handle(isolate, sup_type.arguments());
+  const TypeArguments& sup_type_args =
+      TypeArguments::Handle(isolate, sup_type.arguments());
   if (sup_type_args.IsNull()) {
     // The super type is raw or the super class is non generic.
     // In either case, overlapping is not possible.
     set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   const intptr_t num_sup_type_args = sup_type_args.Length();
   // At this point, the super type may or may not be finalized. In either case,
   // the result of this function must remain the same.
   // The value of num_sup_type_args may increase when the super type is
   // finalized, but the last num_sup_type_args type arguments will not be
   // modified by finalization, only shifted to higher indices in the vector.
   // They may however get wrapped in a BoundedType, which we skip.
-  const AbstractTypeArguments& type_params =
-      AbstractTypeArguments::Handle(isolate, type_parameters());
+  const TypeArguments& type_params =
+      TypeArguments::Handle(isolate, type_parameters());
   // Determine the maximum overlap of a prefix of the vector consisting of the
   // type parameters of this class with a suffix of the vector consisting of the
   // type arguments of the super type of this class.
   // The number of own type arguments of this class is the number of its type
   // parameters minus the number of type arguments in the overlap.
   // Attempt to overlap the whole vector of type parameters; reduce the size
   // of the vector (keeping the first type parameter) until it fits or until
   // its size is zero.
   TypeParameter& type_param = TypeParameter::Handle(isolate);
   AbstractType& sup_type_arg = AbstractType::Handle(isolate);
@@ skipping 870 matching lines @@
     case kDynamicCid:
       return Symbols::Dynamic().raw();
     case kVoidCid:
       return Symbols::Void().raw();
     case kClassCid:
       return Symbols::Class().raw();
     case kUnresolvedClassCid:
       return Symbols::UnresolvedClass().raw();
     case kTypeArgumentsCid:
       return Symbols::TypeArguments().raw();
-    case kInstantiatedTypeArgumentsCid:
-      return Symbols::InstantiatedTypeArguments().raw();
     case kPatchClassCid:
       return Symbols::PatchClass().raw();
     case kFunctionCid:
       return Symbols::Function().raw();
     case kClosureDataCid:
       return Symbols::ClosureData().raw();
     case kRedirectionDataCid:
       return Symbols::RedirectionData().raw();
     case kFieldCid:
       return Symbols::Field().raw();
@@ skipping 274 matching lines @@
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
 
 // If test_kind == kIsSubtypeOf, checks if type S is a subtype of type T.
 // If test_kind == kIsMoreSpecificThan, checks if S is more specific than T.
 // Type S is specified by this class parameterized with 'type_arguments', and
 // type T by class 'other' parameterized with 'other_type_arguments'.
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
-bool Class::TypeTestNonRecursive(
-    const Class& cls,
-    Class::TypeTestKind test_kind,
-    const AbstractTypeArguments& type_arguments,
-    const Class& other,
-    const AbstractTypeArguments& other_type_arguments,
-    Error* bound_error) {
+bool Class::TypeTestNonRecursive(const Class& cls,
+                                 Class::TypeTestKind test_kind,
+                                 const TypeArguments& type_arguments,
+                                 const Class& other,
+                                 const TypeArguments& other_type_arguments,
+                                 Error* bound_error) {
   // Use the thsi object as if it was the receiver of this method, but instead
   // of recursing reset it to the super class and loop.
   Class& thsi = Class::Handle(cls.raw());
   while (true) {
     ASSERT(!thsi.IsVoidClass());
     // Check for DynamicType.
     // Each occurrence of DynamicType in type T is interpreted as the dynamic
     // type, a supertype of all types.
     if (other.IsDynamicClass()) {
       return true;
@@ skipping 79 matching lines @@
                               bound_error)) {
               return true;
             }
       }
     }
     // Check for 'direct super type' specified in the implements clause
     // and check for transitivity at the same time.
     Array& interfaces = Array::Handle(thsi.interfaces());
     AbstractType& interface = AbstractType::Handle();
     Class& interface_class = Class::Handle();
-    AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
+    TypeArguments& interface_args = TypeArguments::Handle();
     Error& error = Error::Handle();
     for (intptr_t i = 0; i < interfaces.Length(); i++) {
       interface ^= interfaces.At(i);
       if (!interface.IsFinalized()) {
         // We may be checking bounds at finalization time and can encounter
         // a still unfinalized interface.
         ClassFinalizer::FinalizeType(
             thsi, interface, ClassFinalizer::kCanonicalize);
         interfaces.SetAt(i, interface);
       }
@@ skipping 43 matching lines @@
   return false;
 }
 
 
 // If test_kind == kIsSubtypeOf, checks if type S is a subtype of type T.
 // If test_kind == kIsMoreSpecificThan, checks if S is more specific than T.
 // Type S is specified by this class parameterized with 'type_arguments', and
 // type T by class 'other' parameterized with 'other_type_arguments'.
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
-bool Class::TypeTest(
-                     TypeTestKind test_kind,
-                     const AbstractTypeArguments& type_arguments,
+bool Class::TypeTest(TypeTestKind test_kind,
+                     const TypeArguments& type_arguments,
                      const Class& other,
-                     const AbstractTypeArguments& other_type_arguments,
+                     const TypeArguments& other_type_arguments,
                      Error* bound_error) const {
   return TypeTestNonRecursive(*this,
                               test_kind,
                               type_arguments,
                               other,
                               other_type_arguments,
                               bound_error);
 }
 
 
@@ skipping 422 matching lines @@
   OS::SNPrint(chars, len, format, cname);
   return chars;
 }
 
 
 void UnresolvedClass::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
-intptr_t AbstractTypeArguments::Length() const  {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return -1;
-}
-
-
-RawAbstractType* AbstractTypeArguments::TypeAt(intptr_t index) const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void AbstractTypeArguments::SetTypeAt(intptr_t index,
-                                      const AbstractType& value) const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-}
-
-
-bool AbstractTypeArguments::IsResolved() const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return false;
-}
-
-
-bool AbstractTypeArguments::IsInstantiated(GrowableObjectArray* trail) const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return false;
-}
-
-
-bool AbstractTypeArguments::IsUninstantiatedIdentity() const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return false;
-}
-
-
-bool AbstractTypeArguments::CanShareInstantiatorTypeArguments(
-      const Class& instantiator_class) const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return false;
-}
-
-
-bool AbstractTypeArguments::IsBounded() const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return false;
-}
-
-
 static intptr_t FinalizeHash(uword hash) {
   hash += hash << 3;
   hash ^= hash >> 11;
   hash += hash << 15;
   return hash;
 }
 
 
-intptr_t AbstractTypeArguments::Hash() const {
+intptr_t TypeArguments::Hash() const {
   if (IsNull()) return 0;
   uword result = 0;
   const intptr_t num_types = Length();
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     result += type.Hash();
     result += result << 10;
     result ^= result >> 6;
   }
   return FinalizeHash(result);
 }
 
 
-RawString* AbstractTypeArguments::SubvectorName(
-    intptr_t from_index,
-    intptr_t len,
-    NameVisibility name_visibility) const {
+RawString* TypeArguments::SubvectorName(intptr_t from_index,
+                                        intptr_t len,
+                                        NameVisibility name_visibility) const {
   ASSERT(from_index + len <= Length());
   String& name = String::Handle();
   const intptr_t num_strings = 2*len + 1;  // "<""T"", ""T"">".
   const Array& strings = Array::Handle(Array::New(num_strings));
   intptr_t s = 0;
   strings.SetAt(s++, Symbols::LAngleBracket());
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     name = type.BuildName(name_visibility);
     strings.SetAt(s++, name);
     if (i < len - 1) {
       strings.SetAt(s++, Symbols::CommaSpace());
     }
   }
   strings.SetAt(s++, Symbols::RAngleBracket());
   ASSERT(s == num_strings);
   name = String::ConcatAll(strings);
   return Symbols::New(name);
 }
 
 
-bool AbstractTypeArguments::IsEquivalent(const AbstractTypeArguments& other,
-                                         GrowableObjectArray* trail) const {
+bool TypeArguments::IsEquivalent(const TypeArguments& other,
+                                 GrowableObjectArray* trail) const {
   if (this->raw() == other.raw()) {
     return true;
   }
   if (IsNull() || other.IsNull()) {
     return false;
   }
   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.IsEquivalent(other_type, trail)) {
       return false;
     }
   }
   return true;
 }
 
 
-RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
-    Error* bound_error,
-    GrowableObjectArray* trail) const {
-  // AbstractTypeArguments is an abstract class.
-  UNREACHABLE();
-  return NULL;
-}
-
-
-bool AbstractTypeArguments::IsDynamicTypes(bool raw_instantiated,
-                                           intptr_t from_index,
-                                           intptr_t len) const {
+bool TypeArguments::IsDynamicTypes(bool raw_instantiated,
+                                   intptr_t from_index,
+                                   intptr_t len) const {
   ASSERT(Length() >= (from_index + len));
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     ASSERT(!type.IsNull());
     if (!type.HasResolvedTypeClass()) {
       if (raw_instantiated && type.IsTypeParameter()) {
         // An uninstantiated type parameter is equivalent to dynamic (even in
         // the presence of a malformed bound in checked mode).
         continue;
       }
       return false;
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
 
 
-bool AbstractTypeArguments::TypeTest(TypeTestKind test_kind,
-                                     const AbstractTypeArguments& other,
-                                     intptr_t from_index,
-                                     intptr_t len,
-                                     Error* bound_error) const {
+bool TypeArguments::TypeTest(TypeTestKind test_kind,
+                             const TypeArguments& other,
+                             intptr_t from_index,
+                             intptr_t len,
+                             Error* bound_error) const {
   ASSERT(Length() >= (from_index + len));
   ASSERT(!other.IsNull());
   ASSERT(other.Length() >= (from_index + len));
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     ASSERT(!type.IsNull());
     other_type = other.TypeAt(from_index + i);
     ASSERT(!other_type.IsNull());
     if (!type.TypeTest(test_kind, other_type, bound_error)) {
       return false;
     }
   }
   return true;
 }
 
 
-const char* AbstractTypeArguments::ToCString() const {
-  // AbstractTypeArguments is an abstract class, valid only for representing
-  // null.
-  if (IsNull()) {
-    return "NULL AbstractTypeArguments";
-  }
-  UNREACHABLE();
-  return "AbstractTypeArguments";
+void TypeArguments::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  JSONObject jsobj(stream);
 }
 
 
-void AbstractTypeArguments::PrintToJSONStream(JSONStream* stream,
-                                              bool ref) const {
-  JSONObject jsobj(stream);
+RawArray* TypeArguments::instantiations() const {
+  return raw_ptr()->instantiations_;
+}
+
+void TypeArguments::set_instantiations(const Array& value) const {
+  ASSERT(!value.IsNull());
+  StorePointer(&raw_ptr()->instantiations_, value.raw());
 }
 
 
 intptr_t TypeArguments::Length() const {
   ASSERT(!IsNull());
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
@@ skipping 114 matching lines @@
     }
   }
   // As a second requirement, the type arguments corresponding to the super type
   // must be identical. Overlapping ones have already been checked starting at
   // first_type_param_offset.
   if (first_type_param_offset == 0) {
     return true;
   }
   AbstractType& super_type = AbstractType::Handle(
       instantiator_class.super_type());
-  const AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle(
+  const TypeArguments& super_type_args = TypeArguments::Handle(
       super_type.arguments());
   if (super_type_args.IsNull()) {
     return false;
   }
   AbstractType& super_type_arg = AbstractType::Handle();
   for (intptr_t i = 0;
        (i < first_type_param_offset) && (i < num_type_args); i++) {
     type_arg = TypeAt(i);
     super_type_arg = super_type_args.TypeAt(i);
     if (!type_arg.Equals(super_type_arg)) {
@@ skipping 27 matching lines @@
       return true;
     }
     if (type.IsTypeParameter()) {
       const AbstractType& bound = AbstractType::Handle(
           TypeParameter::Cast(type).bound());
       if (!bound.IsObjectType() && !bound.IsDynamicType()) {
         return true;
       }
       continue;
     }
-    const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
+    const TypeArguments& type_args = TypeArguments::Handle(
         Type::Cast(type).arguments());
     if (!type_args.IsNull() && type_args.IsBounded()) {
       return true;
     }
   }
   return false;
 }
 
 
-RawAbstractTypeArguments* TypeArguments::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
+RawTypeArguments* TypeArguments::InstantiateFrom(
+    const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     GrowableObjectArray* trail) const {
   ASSERT(!IsInstantiated());
   if (!instantiator_type_arguments.IsNull() &&
       IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArguments& instantiated_array =
       TypeArguments::Handle(TypeArguments::New(num_types, Heap::kNew));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsBeingFinalized() && !type.IsInstantiated()) {
       type = type.InstantiateFrom(instantiator_type_arguments,
                                   bound_error,
                                   trail);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
+RawTypeArguments* TypeArguments::InstantiateAndCanonicalizeFrom(
+    const TypeArguments& instantiator_type_arguments,
+    Error* bound_error) const {
+  ASSERT(!IsInstantiated());
+  ASSERT(instantiator_type_arguments.IsNull() ||
+         instantiator_type_arguments.IsCanonical());
+  // Lookup instantiator and, if found, return paired instantiated result.
+  Array& prior_instantiations = Array::Handle(instantiations());
+  ASSERT(!prior_instantiations.IsNull());
+  intptr_t length = prior_instantiations.Length();
+  intptr_t index = 0;
+  while (index < length) {
+    if (prior_instantiations.At(index) == instantiator_type_arguments.raw()) {
+      return TypeArguments::RawCast(prior_instantiations.At(index + 1));
+    }
+    if (prior_instantiations.At(index) == Smi::New(StubCode::kNoInstantiator)) {
+      break;
+    }
+    index += 2;
+  }
+  TypeArguments& result = TypeArguments::Handle();
+  result ^= InstantiateFrom(instantiator_type_arguments, bound_error);
+  if ((bound_error != NULL) && !bound_error->IsNull()) {
+    return result.raw();
+  }

[Ivan Posva, 2014/02/07 18:48:43]

Please add a comment explaining that everything below here is only with a
successful instantiation.

[regis, 2014/02/07 19:42:00]

Done.

+  result ^= result.Canonicalize();
+  // Add instantiator and result to instantiations array.
+  if ((index + 2) > length) {
+    // Grow the instantiations array.
+    length = (length == 0) ? 2 : length * 2;

[srdjan, 2014/02/07 17:32:17]

The growth seems to aggressive. I would never grow than maybe 4 entries?

[regis, 2014/02/07 19:42:00]

Done:
    length = (length == 0) ? 2 : length + 4;

But I will revisit in a follow-up change after more measurements.

+    prior_instantiations =
+        Array::Grow(prior_instantiations, length, Heap::kOld);
+    set_instantiations(prior_instantiations);
+  }
+  prior_instantiations.SetAt(index, instantiator_type_arguments);
+  prior_instantiations.SetAt(index + 1, result);
+  if ((index + 2) < length) {
+    prior_instantiations.SetAt(index + 2,
+        Smi::Handle(Smi::New(StubCode::kNoInstantiator)));
+  }
+  return result.raw();
+}
+
+
 RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TypeArguments::New: invalid len %" Pd "\n", len);
   }
   TypeArguments& result = TypeArguments::Handle();
   {
     RawObject* raw = Object::Allocate(TypeArguments::kClassId,
                                       TypeArguments::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     // Length must be set before we start storing into the array.
     result.SetLength(len);
   }
+  result.set_instantiations(Object::empty_array());
   return result.raw();
 }
 
 
 
 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];
 }
@@ skipping 71 matching lines @@
   TypeArguments& current = TypeArguments::Handle(isolate);
   current ^= table.At(index);
   while (!current.IsNull() && !current.Equals(arguments)) {
     index = (index + 1) & (table_size - 1);  // Move to next element.
     current ^= table.At(index);
   }
   return index;  // Index of element if found or slot into which to add it.
 }
 
 
-RawAbstractTypeArguments* TypeArguments::CloneUnfinalized() const {
-  if (IsFinalized()) {
+RawTypeArguments* TypeArguments::CloneUnfinalized() const {
+  if (IsNull() || IsFinalized()) {
     return raw();
   }
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
   const TypeArguments& clone = TypeArguments::Handle(
       TypeArguments::New(num_types));
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     type = type.CloneUnfinalized();
     clone.SetTypeAt(i, type);
   }
   return clone.raw();
 }
 
 
-RawAbstractTypeArguments* TypeArguments::Canonicalize(
+RawTypeArguments* TypeArguments::Canonicalize(
     GrowableObjectArray* trail) const {
   if (IsNull() || IsCanonical()) {
     ASSERT(IsOld());
     return this->raw();
   }
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
   const Array& table = Array::Handle(isolate,
                                      object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
@@ skipping 17 matching lines @@
       result ^= Object::Clone(*this, Heap::kOld);
     } else {
       result ^= this->raw();
     }
     ASSERT(result.IsOld());
     InsertIntoCanonicalTypeArguments(isolate, table, result, index);
   }
   ASSERT(result.Equals(*this));
   ASSERT(!result.IsNull());
   ASSERT(result.IsTypeArguments());
+  ASSERT(result.IsCanonical());
   return result.raw();
 }
 
 
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL TypeArguments";
   }
   const char* format = "%s [%s]";
   const char* prev_cstr = "TypeArguments:";
   for (int i = 0; i < Length(); i++) {
     const AbstractType& type_at = AbstractType::Handle(TypeAt(i));
     const char* type_cstr = type_at.IsNull() ? "null" : type_at.ToCString();
     intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, prev_cstr, type_cstr);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
-void TypeArguments::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-}
-
-
-intptr_t InstantiatedTypeArguments::Length() const {
-  return AbstractTypeArguments::Handle(
-      uninstantiated_type_arguments()).Length();
-}
-
-
-RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
-  AbstractType& type = AbstractType::Handle(AbstractTypeArguments::Handle(
-      uninstantiated_type_arguments()).TypeAt(index));
-  if (!type.IsInstantiated()) {
-    const AbstractTypeArguments& instantiator_type_args =
-        AbstractTypeArguments::Handle(instantiator_type_arguments());
-    Error& bound_error = Error::Handle();
-    type = type.InstantiateFrom(instantiator_type_args, &bound_error);
-    // InstantiatedTypeArguments cannot include unchecked bounds.
-    // In the presence of unchecked bounds, no InstantiatedTypeArguments are
-    // allocated, but the type arguments are instantiated individually and their
-    // bounds are checked.
-    ASSERT(bound_error.IsNull());
-  }
-  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();
-}
-
-
-RawAbstractTypeArguments* InstantiatedTypeArguments::Canonicalize(
-    GrowableObjectArray* trail) const {
-  const intptr_t num_types = Length();
-  const TypeArguments& type_args = TypeArguments::Handle(
-      TypeArguments::New(num_types, Heap::kOld));
-  AbstractType& type = AbstractType::Handle();
-  for (intptr_t i = 0; i < num_types; i++) {
-    type = TypeAt(i);
-    type_args.SetTypeAt(i, type);
-  }
-  return type_args.Canonicalize(trail);
-}
-
-
-void InstantiatedTypeArguments::set_uninstantiated_type_arguments(
-    const AbstractTypeArguments& value) const {
-  StorePointer(&raw_ptr()->uninstantiated_type_arguments_, value.raw());
-}
-
-
-void InstantiatedTypeArguments::set_instantiator_type_arguments(
-    const AbstractTypeArguments& value) const {
-  StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
-}
-
-
-RawInstantiatedTypeArguments* InstantiatedTypeArguments::New() {
-  ASSERT(Object::instantiated_type_arguments_class() != Class::null());
-  RawObject* raw = Object::Allocate(InstantiatedTypeArguments::kClassId,
-                                    InstantiatedTypeArguments::InstanceSize(),
-                                    Heap::kNew);
-  return reinterpret_cast<RawInstantiatedTypeArguments*>(raw);
-}
-
-
-RawInstantiatedTypeArguments* InstantiatedTypeArguments::New(
-    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]";
-  const char* arg_cstr =
-      AbstractTypeArguments::Handle(
-          uninstantiated_type_arguments()).ToCString();
-  const char* instantiator_cstr =
-      AbstractTypeArguments::Handle(instantiator_type_arguments()).ToCString();
-  intptr_t len =
-      OS::SNPrint(NULL, 0, format, arg_cstr, instantiator_cstr) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, arg_cstr, instantiator_cstr);
-  return chars;
-}
-
-
-void InstantiatedTypeArguments::PrintToJSONStream(JSONStream* stream,
-                                                  bool ref) const {
-  JSONObject jsobj(stream);
-}
-
-
 const char* PatchClass::ToCString() const {
   const char* kFormat = "PatchClass for %s";
   const Class& cls = Class::Handle(patched_class());
   const char* cls_name = cls.ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, cls_name) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name);
   return chars;
 }
 
@@ skipping 830 matching lines @@
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other,
                                            Error* bound_error) const {
   ASSERT(FLAG_error_on_bad_override);
   ASSERT((bound_error != NULL) && bound_error->IsNull());
   // Check that this function's signature type is a subtype of the other
   // function's signature type.
-  if (!TypeTest(kIsSubtypeOf, Object::null_abstract_type_arguments(),
-                other, Object::null_abstract_type_arguments(), bound_error)) {
+  if (!TypeTest(kIsSubtypeOf, Object::null_type_arguments(),
+                other, Object::null_type_arguments(), bound_error)) {
     // For more informative error reporting, use the location of the other
     // function here, since the caller will use the location of this function.
     *bound_error = LanguageError::NewFormatted(
         *bound_error,  // A bound error if non null.
         Script::Handle(other.script()),
         other.token_pos(),
         LanguageError::kError,
         Heap::kNew,
         "signature type '%s' of function '%s' is not a subtype of signature "
         "type '%s' of function '%s'",
@@ skipping 18 matching lines @@
 // parameter of the other function.
 // If test_kind == kIsMoreSpecificThan, checks if the type of the specified
 // parameter of this function is more specific than the type of the specified
 // parameter of the other function.
 // Note that we do not apply contravariance of parameter types, but covariance
 // of both parameter types and result type.
 bool Function::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 {
   AbstractType& other_param_type =
       AbstractType::Handle(other.ParameterTypeAt(other_parameter_position));
   if (!other_param_type.IsInstantiated()) {
     other_param_type = other_param_type.InstantiateFrom(other_type_arguments,
                                                         bound_error);
     ASSERT((bound_error == NULL) || bound_error->IsNull());
   }
   if (other_param_type.IsDynamicType()) {
     return true;
@@ skipping 16 matching lines @@
     ASSERT(test_kind == kIsMoreSpecificThan);
     if (!param_type.IsMoreSpecificThan(other_param_type, bound_error)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::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 {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_pos_params =
       other.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_named_params =
       other.NumOptionalNamedParameters();
   // This function requires the same arguments or less and accepts the same
@@ skipping 290 matching lines @@
   const TypeArguments& instantiator = TypeArguments::Handle();
   BuildSignatureParameters(false, kUserVisibleName, instantiator, pieces);
   const Array& strings = Array::Handle(Array::MakeArray(pieces));
   return String::ConcatAll(strings);
 }
 
 
 void Function::BuildSignatureParameters(
     bool instantiate,
     NameVisibility name_visibility,
-    const AbstractTypeArguments& instantiator,
+    const TypeArguments& instantiator,
     const GrowableObjectArray& pieces) const {
   AbstractType& param_type = AbstractType::Handle();
   const intptr_t num_params = NumParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   String& name = String::Handle();
   intptr_t i = 0;
@@ skipping 53 matching lines @@
     ObjectStore* object_store = Isolate::Current()->object_store();
     const Context& context = Context::Handle(object_store->empty_context());
     const Instance& closure =
         Instance::Handle(Closure::New(*this, context, Heap::kOld));
     set_implicit_static_closure(closure);
   }
   return implicit_static_closure();
 }
 
 
-RawString* Function::BuildSignature(
-    bool instantiate,
-    NameVisibility name_visibility,
-    const AbstractTypeArguments& instantiator) const {
+RawString* Function::BuildSignature(bool instantiate,
+                                    NameVisibility name_visibility,
+                                    const TypeArguments& instantiator) const {
   const GrowableObjectArray& pieces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   String& name = String::Handle();
   if (!instantiate && !is_static() && (name_visibility == kInternalName)) {
     // Prefix the signature with its signature class and type parameters, if any
     // (e.g. "Map<K, V>(K) => bool"). In case of a function type alias, the
     // signature class name is the alias name.
     // The signature of static functions cannot be type parameterized.
     const Class& function_class = Class::Handle(Owner());
     ASSERT(!function_class.IsNull());
@@ skipping 5430 matching lines @@
 
 
 intptr_t SubtypeTestCache::NumberOfChecks() const {
   // Do not count the sentinel;
   return (Array::Handle(cache()).Length() / kTestEntryLength) - 1;
 }
 
 
 void SubtypeTestCache::AddCheck(
     intptr_t instance_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 {
   intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(cache());
   intptr_t new_len = data.Length() + kTestEntryLength;
   data = Array::Grow(data, new_len);
   set_cache(data);
   intptr_t data_pos = old_num * kTestEntryLength;
   data.SetAt(data_pos + kInstanceClassId,
       Smi::Handle(Smi::New(instance_class_id)));
   data.SetAt(data_pos + kInstanceTypeArguments, instance_type_arguments);
   data.SetAt(data_pos + kInstantiatorTypeArguments,
       instantiator_type_arguments);
   data.SetAt(data_pos + kTestResult, test_result);
 }
 
 
-void SubtypeTestCache::GetCheck(
-    intptr_t ix,
-    intptr_t* instance_class_id,
-    AbstractTypeArguments* instance_type_arguments,
-    AbstractTypeArguments* instantiator_type_arguments,
-    Bool* test_result) const {
+void SubtypeTestCache::GetCheck(intptr_t ix,
+                                intptr_t* instance_class_id,
+                                TypeArguments* instance_type_arguments,
+                                TypeArguments* instantiator_type_arguments,
+                                Bool* test_result) const {
   Array& data = Array::Handle(cache());
   intptr_t data_pos = ix * kTestEntryLength;
   *instance_class_id =
       Smi::Value(Smi::RawCast(data.At(data_pos + kInstanceClassId)));
   *instance_type_arguments ^= data.At(data_pos + kInstanceTypeArguments);
   *instantiator_type_arguments ^=
       data.At(data_pos + kInstantiatorTypeArguments);
   *test_result ^= data.At(data_pos + kTestResult);
 }
 
@@ skipping 534 matching lines @@
 }
 
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   Type& type = Type::Handle(cls.CanonicalType());
   if (type.IsNull()) {
-    AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
+    TypeArguments& type_arguments = TypeArguments::Handle();
     if (cls.NumTypeArguments() > 0) {
       type_arguments = GetTypeArguments();
     }
     type = Type::New(cls, type_arguments, Scanner::kNoSourcePos);
     type.SetIsFinalized();
     type ^= type.Canonicalize();
   }
   return type.raw();
 }
 
 
-RawAbstractTypeArguments* Instance::GetTypeArguments() const {
+RawTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
-  AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
+  TypeArguments& type_arguments = TypeArguments::Handle();
   type_arguments ^= *FieldAddrAtOffset(field_offset);
   return type_arguments.raw();
 }
 
 
-void Instance::SetTypeArguments(const AbstractTypeArguments& value) const {
+void Instance::SetTypeArguments(const TypeArguments& value) const {
+  ASSERT(value.IsNull() || value.IsCanonical());
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   SetFieldAtOffset(field_offset, value);
 }
 
 
 bool Instance::IsInstanceOf(const AbstractType& other,
-                            const AbstractTypeArguments& other_instantiator,
+                            const TypeArguments& other_instantiator,
                             Error* bound_error) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsMalformed());
   ASSERT(!other.IsMalbounded());
   if (other.IsVoidType()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
   const Class& cls = Class::Handle(isolate, clazz());
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(isolate);
+  TypeArguments& type_arguments =
+      TypeArguments::Handle(isolate);
   if (cls.NumTypeArguments() > 0) {
     type_arguments = GetTypeArguments();
-    if (!type_arguments.IsNull() && !type_arguments.IsCanonical()) {
-      type_arguments = type_arguments.Canonicalize();
-      SetTypeArguments(type_arguments);
-    }
+    ASSERT(type_arguments.IsNull() || type_arguments.IsCanonical());
     // The number of type arguments in the instance must be greater or equal to
     // 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 subclass of the class
     // defining the closure. Truncating the vector to the correct length on
     // instantiation is unnecessary. The vector may therefore be longer.
     // Also, an optimization reuses the type argument vector of the instantiator
     // of generic instances when its layout is compatible.
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.Length() >= cls.NumTypeArguments()));
   }
   Class& other_class = Class::Handle(isolate);
-  AbstractTypeArguments& other_type_arguments =
-      AbstractTypeArguments::Handle(isolate);
+  TypeArguments& other_type_arguments = TypeArguments::Handle(isolate);
   // Note that we may encounter a bound error in checked mode.
   if (!other.IsInstantiated()) {
     const AbstractType& instantiated_other = AbstractType::Handle(
         isolate, other.InstantiateFrom(other_instantiator, bound_error));
     if ((bound_error != NULL) && !bound_error->IsNull()) {
       ASSERT(FLAG_enable_type_checks);
       return false;
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
@@ skipping 106 matching lines @@
     return "non_constant";
   } else if (Isolate::Current()->no_gc_scope_depth() > 0) {
     // Can occur when running disassembler.
     return "Instance";
   } else {
     if (IsClosure()) {
       return Closure::ToCString(*this);
     }
     const char* kFormat = "Instance of '%s'";
     const Class& cls = Class::Handle(clazz());
-    AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
+    TypeArguments& type_arguments = TypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type =
         Type::Handle(Type::New(cls, type_arguments, Scanner::kNoSourcePos));
     const String& type_name = String::Handle(type.UserVisibleName());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
@@ skipping 87 matching lines @@
 }
 
 
 RawUnresolvedClass* AbstractType::unresolved_class() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return UnresolvedClass::null();
 }
 
 
-RawAbstractTypeArguments* AbstractType::arguments() const  {
+RawTypeArguments* AbstractType::arguments() const  {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 intptr_t AbstractType::token_pos() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return -1;
@@ skipping 57 matching lines @@
 
 bool AbstractType::IsEquivalent(const Instance& other,
                                 GrowableObjectArray* trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 RawAbstractType* AbstractType::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
+    const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     GrowableObjectArray* trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawAbstractType* AbstractType::CloneUnfinalized() const {
   // AbstractType is an abstract class.
@@ skipping 20 matching lines @@
     type_name = String::Concat(type_name, Symbols::SpaceExtendsSpace());
     // Build the bound name without causing divergence.
     const AbstractType& bound = AbstractType::Handle(
         BoundedType::Cast(*this).bound());
     String& bound_name = String::Handle();
     if (bound.IsTypeParameter()) {
       bound_name = TypeParameter::Cast(bound).name();
     } else if (bound.IsType()) {
       const Class& cls = Class::Handle(Type::Cast(bound).type_class());
       bound_name = cls.Name();
-      if (Type::Cast(bound).arguments() != AbstractTypeArguments::null()) {
+      if (Type::Cast(bound).arguments() != TypeArguments::null()) {
         bound_name = String::Concat(bound_name, Symbols::OptimizedOut());
       }
     } else {
       bound_name = String::New(Symbols::OptimizedOut());
     }
     type_name = String::Concat(type_name, bound_name);
     return Symbols::New(type_name);
   }
   if (IsTypeParameter()) {
     return TypeParameter::Cast(*this).name();
   }
   // If the type is still being finalized, we may be reporting an error about
   // a malformed type, so proceed with caution.
-  const AbstractTypeArguments& args =
-      AbstractTypeArguments::Handle(arguments());
+  const TypeArguments& args = TypeArguments::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());
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
     if (name_visibility == kInternalName) {
       class_name = cls.Name();
     } else {
@@ skipping 188 matching lines @@
     if (bound.IsMoreSpecificThan(other, bound_error)) {
       return true;
     }
     return false;  // TODO(regis): We should return "maybe after instantiation".
   }
   if (other.IsTypeParameter()) {
     return false;  // TODO(regis): We should return "maybe after instantiation".
   }
   const Class& cls = Class::Handle(type_class());
   return cls.TypeTest(test_kind,
-                      AbstractTypeArguments::Handle(arguments()),
+                      TypeArguments::Handle(arguments()),
                       Class::Handle(other.type_class()),
-                      AbstractTypeArguments::Handle(other.arguments()),
+                      TypeArguments::Handle(other.arguments()),
                       bound_error);
 }
 
 
 intptr_t AbstractType::Hash() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return 0;
 }
 
@@ skipping 170 matching lines @@
 }
 
 
 bool Type::IsResolved() const {
   if (IsFinalized()) {
     return true;
   }
   if (!HasResolvedTypeClass()) {
     return false;
   }
-  const AbstractTypeArguments& args =
-      AbstractTypeArguments::Handle(arguments());
+  const TypeArguments& args = TypeArguments::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();
 }
 
 
@@ skipping 17 matching lines @@
   ASSERT(!unresolved_class.IsNull());
   return unresolved_class.raw();
 #else
   ASSERT(!Object::Handle(raw_ptr()->type_class_).IsNull());
   ASSERT(Object::Handle(raw_ptr()->type_class_).IsUnresolvedClass());
   return reinterpret_cast<RawUnresolvedClass*>(raw_ptr()->type_class_);
 #endif
 }
 
 
-RawAbstractTypeArguments* Type::arguments() const {
+RawTypeArguments* Type::arguments() const {
   return raw_ptr()->arguments_;
 }
 
 
 bool Type::IsInstantiated(GrowableObjectArray* trail) const {
   if (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) {
     return true;
   }
   if (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated) {
     return false;
   }
-  const AbstractTypeArguments& args =
-      AbstractTypeArguments::Handle(arguments());
+  const TypeArguments& args = TypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated(trail);
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
+    const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     GrowableObjectArray* trail) const {
   ASSERT(IsFinalized() || IsBeingFinalized());
   ASSERT(!IsInstantiated());
   // Return the uninstantiated type unchanged if malformed. No copy needed.
   if (IsMalformed()) {
     return raw();
   }
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(arguments());
+  TypeArguments& type_arguments = TypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
                                                   bound_error,
                                                   trail);
   // Note that the type class has to be resolved at this time, but not
   // necessarily finalized yet. We may be checking bounds at compile time.
   const Class& cls = Class::Handle(type_class());
   // This uninstantiated type is not modified, as it can be instantiated
   // with different instantiators.
   Type& instantiated_type = Type::Handle(
       Type::New(cls, type_arguments, token_pos()));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.SetIsFinalized();
+  // Canonicalization is not part of instantiation.
   return instantiated_type.raw();
 }
 
 
 bool Type::IsEquivalent(const Instance& other,
                         GrowableObjectArray* trail) const {
   ASSERT(!IsNull());
   if (raw() == other.raw()) {
     return true;
   }
@@ skipping 22 matching lines @@
     return true;
   }
   const Class& cls = Class::Handle(type_class());
   const intptr_t num_type_params = cls.NumTypeParameters();
   if (num_type_params == 0) {
     // Shortcut unnecessary handle allocation below.
     return true;
   }
   const intptr_t num_type_args = cls.NumTypeArguments();
   const intptr_t from_index = num_type_args - num_type_params;
-  const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
-      arguments());
-  const AbstractTypeArguments& other_type_args = AbstractTypeArguments::Handle(
+  const TypeArguments& type_args = TypeArguments::Handle(arguments());
+  const TypeArguments& other_type_args = TypeArguments::Handle(
       other_type.arguments());
   if (type_args.IsNull()) {
     return other_type_args.IsRaw(from_index, num_type_params);
   }
   if (other_type_args.IsNull()) {
     return type_args.IsRaw(from_index, num_type_params);
   }
   ASSERT(type_args.Length() >= (from_index + num_type_params));
   ASSERT(other_type_args.Length() >= (from_index + num_type_params));
   AbstractType& type_arg = AbstractType::Handle();
   AbstractType& other_type_arg = AbstractType::Handle();
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_arg = type_args.TypeAt(from_index + i);
     other_type_arg = other_type_args.TypeAt(from_index + i);
     if (!type_arg.IsEquivalent(other_type_arg, trail)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawAbstractType* Type::CloneUnfinalized() const {
   ASSERT(IsResolved());
   if (IsFinalized()) {
     return raw();
   }
   ASSERT(!IsMalformed());  // Malformed types are finalized.
   ASSERT(!IsBeingFinalized());  // Cloning must occur prior to finalization.
-  AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(arguments());
+  TypeArguments& type_args = TypeArguments::Handle(arguments());
   type_args = type_args.CloneUnfinalized();
   const Class& type_cls = Class::Handle(type_class());
   return Type::New(type_cls, type_args, token_pos());
 }
 
 
 RawAbstractType* Type::Canonicalize(GrowableObjectArray* trail) const {
   ASSERT(IsFinalized());
   if (IsCanonical() || IsMalformed()) {
-    ASSERT(IsMalformed() || AbstractTypeArguments::Handle(arguments()).IsOld());
+    ASSERT(IsMalformed() || TypeArguments::Handle(arguments()).IsOld());
     return this->raw();
   }
   Isolate* isolate = Isolate::Current();
   Type& type = Type::Handle(isolate);
   const Class& cls = Class::Handle(isolate, type_class());
   if (cls.raw() == Object::dynamic_class() && (isolate != Dart::vm_isolate())) {
     return Object::dynamic_type();
   }
   // Fast canonical lookup/registry for simple types.
   if ((cls.NumTypeArguments() == 0) && !cls.IsSignatureClass()) {
@@ skipping 24 matching lines @@
     if (type.IsNull()) {
       break;
     }
     ASSERT(type.IsFinalized());
     if (this->Equals(type)) {
       return type.raw();
     }
     index++;
   }
   // Canonicalize the type arguments.
-  AbstractTypeArguments& type_args =
-      AbstractTypeArguments::Handle(isolate, arguments());
+  TypeArguments& type_args = TypeArguments::Handle(isolate, arguments());
   // In case the type is first canonicalized at runtime, its type argument
   // vector may be longer than necessary. This is not an issue.
   ASSERT(type_args.IsNull() || (type_args.Length() >= cls.NumTypeArguments()));
   type_args = type_args.Canonicalize(trail);
   set_arguments(type_args);
   // The type needs to be added to the list. Grow the list if it is full.
   if (index == canonical_types_len) {
     const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
     const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
     const Array& new_canonical_types = Array::Handle(
@@ skipping 32 matching lines @@
   SetCanonical();
   return this->raw();
 }
 
 
 intptr_t Type::Hash() const {
   ASSERT(IsFinalized());
   uword result = 1;
   if (IsMalformed()) return result;
   result += Class::Handle(type_class()).id();
-  result += AbstractTypeArguments::Handle(arguments()).Hash();
+  result += TypeArguments::Handle(arguments()).Hash();
   return FinalizeHash(result);
 }
 
 
 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 AbstractTypeArguments& value) const {
+void Type::set_arguments(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
 RawType* Type::New(Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->type_class() != Class::null());
   RawObject* raw = Object::Allocate(Type::kClassId,
                                     Type::InstanceSize(),
                                     space);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
-                   const AbstractTypeArguments& arguments,
+                   const TypeArguments& arguments,
                    intptr_t token_pos,
                    Heap::Space space) {
   const Type& result = Type::Handle(Type::New(space));
   result.set_type_class(clazz);
   result.set_arguments(arguments);
   result.set_token_pos(token_pos);
   result.raw_ptr()->type_state_ = RawType::kAllocated;
   return result.raw();
 }
 
 
 void Type::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
 
 
 void Type::set_type_state(int8_t state) const {
   ASSERT((state == RawType::kAllocated) ||
          (state == RawType::kBeingFinalized) ||
          (state == RawType::kFinalizedInstantiated) ||
          (state == RawType::kFinalizedUninstantiated));
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* Type::ToCString() const {
   if (IsResolved()) {
-    const AbstractTypeArguments& type_arguments =
-        AbstractTypeArguments::Handle(arguments());
+    const TypeArguments& type_arguments = TypeArguments::Handle(arguments());
     const char* class_name;
     if (HasResolvedTypeClass()) {
       class_name = String::Handle(
           Class::Handle(type_class()).Name()).ToCString();
     } else {
       class_name = UnresolvedClass::Handle(unresolved_class()).ToCString();
     }
     if (type_arguments.IsNull()) {
       const char* format = "Type: class '%s'";
       intptr_t len = OS::SNPrint(NULL, 0, format, class_name) + 1;
       char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
       OS::SNPrint(chars, len, format, class_name);
       return chars;
     } else {
       const char* format = "Type: class '%s', args:[%s]";
-      const char* args_cstr =
-          AbstractTypeArguments::Handle(arguments()).ToCString();
+      const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
       intptr_t len = OS::SNPrint(NULL, 0, format, class_name, args_cstr) + 1;
       char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
       OS::SNPrint(chars, len, format, class_name, args_cstr);
       return chars;
     }
   } else {
     return "Unresolved Type";
   }
 }
 
@@ skipping 17 matching lines @@
     return true;
   }
   if (TestAndAddBuddyToTrail(&trail, other)) {
     return true;
   }
   return AbstractType::Handle(type()).IsEquivalent(other, trail);
 }
 
 
 RawAbstractType* TypeRef::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
+    const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     GrowableObjectArray* trail) const {
   TypeRef& instantiated_type_ref = TypeRef::Handle();
   instantiated_type_ref ^= OnlyBuddyInTrail(trail);
   if (!instantiated_type_ref.IsNull()) {
     return instantiated_type_ref.raw();
   }
   instantiated_type_ref = TypeRef::New(Type::Handle(Type::DynamicType()));
   AddOnlyBuddyToTrail(&trail, instantiated_type_ref);
   const AbstractType& ref_type = AbstractType::Handle(type());
@@ skipping 113 matching lines @@
   result.set_type(type);
   return result.raw();
 }
 
 
 const char* TypeRef::ToCString() const {
   const char* format = "TypeRef: %s%s";
   const char* type_cstr = String::Handle(Class::Handle(AbstractType::Handle(
       type()).type_class()).Name()).ToCString();
   const char* args_cstr = (AbstractType::Handle(
-      type()).arguments() == AbstractTypeArguments::null()) ? "" : "<...>";
+      type()).arguments() == TypeArguments::null()) ? "" : "<...>";
   intptr_t len = OS::SNPrint(NULL, 0, format, type_cstr, args_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, type_cstr, args_cstr);
   return chars;
 }
 
 
 void TypeRef::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
@@ skipping 48 matching lines @@
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void TypeParameter::set_bound(const AbstractType& value) const {
   StorePointer(&raw_ptr()->bound_, value.raw());
 }
 
 
 RawAbstractType* TypeParameter::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
+    const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     GrowableObjectArray* trail) const {
   ASSERT(IsFinalized());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
   const AbstractType& type_arg = AbstractType::Handle(
       instantiator_type_arguments.TypeAt(index()));
   // There is no need to canonicalize the instantiated type parameter, since all
   // type arguments are canonicalized at type finalization time. It would be too
@@ skipping 204 matching lines @@
 
 void BoundedType::set_type_parameter(const TypeParameter& value) const {
   // A null type parameter is set when marking a type malformed because of a
   // bound error at compile time.
   ASSERT(value.IsNull() || value.IsFinalized());
   StorePointer(&raw_ptr()->type_parameter_, value.raw());
 }
 
 
 RawAbstractType* BoundedType::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
+    const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     GrowableObjectArray* trail) const {
   ASSERT(IsFinalized());
   AbstractType& bounded_type = AbstractType::Handle(type());
   if (!bounded_type.IsInstantiated()) {
     bounded_type = bounded_type.InstantiateFrom(instantiator_type_arguments,
                                                 bound_error,
                                                 trail);
   }
   if (FLAG_enable_type_checks && bound_error->IsNull()) {
@@ skipping 2657 matching lines @@
     // Both handles point to the same raw instance.
     return true;
   }
 
   // An Array may be compared to an ImmutableArray.
   if (!other.IsArray() || other.IsNull()) {
     return false;
   }
 
   // Both arrays must have the same type arguments.
-  const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
-      GetTypeArguments());
-  const AbstractTypeArguments& other_type_args = AbstractTypeArguments::Handle(
+  const TypeArguments& type_args = TypeArguments::Handle(GetTypeArguments());
+  const TypeArguments& other_type_args = TypeArguments::Handle(
       other.GetTypeArguments());
   if (!type_args.Equals(other_type_args)) {
     return false;
   }
 
   const Array& other_arr = Array::Cast(other);
 
   intptr_t len = this->Length();
   if (len != other_arr.Length()) {
     return false;
@@ skipping 56 matching lines @@
 void Array::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 RawArray* Array::Grow(const Array& source, int new_length, Heap::Space space) {
   const Array& result = Array::Handle(Array::New(new_length, space));
   intptr_t len = 0;
   if (!source.IsNull()) {
     len = source.Length();
-    result.SetTypeArguments(
-        AbstractTypeArguments::Handle(source.GetTypeArguments()));
+    result.SetTypeArguments(TypeArguments::Handle(source.GetTypeArguments()));
   }
   ASSERT(new_length >= len);  // Cannot copy 'source' into new array.
   ASSERT(new_length != len);  // Unnecessary copying of array.
   Object& obj = Object::Handle();
   for (int i = 0; i < len; i++) {
     obj = source.At(i);
     result.SetAt(i, obj);
   }
   return result.raw();
 }
@@ skipping 123 matching lines @@
   }
 
   const GrowableObjectArray& other_arr = GrowableObjectArray::Cast(other);
 
   // The capacity and length of both objects must be equal.
   if (Capacity() != other_arr.Capacity() || Length() != other_arr.Length()) {
     return false;
   }
 
   // Both arrays must have the same type arguments.
-  const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
-      GetTypeArguments());
-  const AbstractTypeArguments& other_type_args = AbstractTypeArguments::Handle(
+  const TypeArguments& type_args = TypeArguments::Handle(GetTypeArguments());
+  const TypeArguments& other_type_args = TypeArguments::Handle(
       other.GetTypeArguments());
   if (!type_args.Equals(other_type_args)) {
     return false;
   }
 
   // The data part in both arrays must be identical.
   const Array& contents = Array::Handle(data());
   const Array& other_contents = Array::Handle(other_arr.data());
   for (intptr_t i = 0; i < Length(); i++) {
     if (contents.At(i) != other_contents.At(i)) {
@@ skipping 996 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart