Renaming type classes as discussed:

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 32 matching lines @@
 RawObject* Object::null_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::sentinel_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::transition_sentinel_ =
     reinterpret_cast<RawInstance*>(RAW_NULL);
 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::parameterized_type_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::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);
@@ skipping 15 matching lines @@
   if (raw_class == class_class()) {
     return kClassClass;
   } else if (raw_class == null_class()) {
     return kNullClass;
   } else if (raw_class == dynamic_class()) {
     return kDynamicClass;
   } else if (raw_class == void_class()) {
     return kVoidClass;
   } else if (raw_class == unresolved_class_class()) {
     return kUnresolvedClassClass;
-  } else if (raw_class == parameterized_type_class()) {
-    return kParameterizedTypeClass;
+  } 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 == type_arguments_class()) {
     return kTypeArgumentsClass;
   } else if (raw_class == type_array_class()) {
     return kTypeArrayClass;
   } else if (raw_class == instantiated_type_arguments_class()) {
     return kInstantiatedTypeArgumentsClass;
@@ skipping 28 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 kParameterizedTypeClass: return parameterized_type_class();
+    case kTypeClass: return type_class();
     case kTypeParameterClass: return type_parameter_class();
     case kInstantiatedTypeClass: return instantiated_type_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();
@@ skipping 13 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 kParameterizedTypeClass: return "ParameterizedType";
+    case kTypeClass: return "Type";
     case kTypeParameterClass: return "TypeParameter";
     case kInstantiatedTypeClass: return "InstantiatedType";
     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";
@@ skipping 83 matching lines @@
   dynamic_class_ = cls.raw();
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
   cls = Class::New<Instance>();
   cls.set_is_finalized();
   void_class_ = cls.raw();
 
-  cls = Class::New<ParameterizedType>();
-  parameterized_type_class_ = cls.raw();
+  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<TypeArguments>();
   type_arguments_class_ = cls.raw();
 
@@ skipping 65 matching lines @@
   cls.set_script(script);
   lib.AddClass(cls);
 }
 
 
 void Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
-  ParameterizedType& type = ParameterizedType::Handle();
+  Type& type = Type::Handle();
   Array& array = Array::Handle();
 
   // All RawArray fields will be initialized to an empty array, therefore
   // initialize array class first.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   // Array and ImmutableArray are the only VM classes that are parameterized.
   // Since they are pre-finalized, CalculateFieldOffsets() is not called, so we
   // need to set the offset of their type_arguments_ field, which is explicitly
@@ skipping 218 matching lines @@
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
   Bootstrap::Compile(core_lib, script);
   Bootstrap::Compile(core_impl_lib, impl_script);
 
   Bootstrap::SetupNativeResolver();
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
-  cls.set_super_type(Type::Handle());
+  cls.set_super_type(AbstractType::Handle());
 
   ClassFinalizer::VerifyBootstrapClasses();
 }
 
 
 void Object::InitFromSnapshot(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
@@ skipping 103 matching lines @@
 RawString* Class::Name() const {
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != null_);  // Or GetSingletonClassIndex will not work.
   intptr_t index = GetSingletonClassIndex(raw());
   return String::NewSymbol(GetSingletonClassName(index));
 }
 
 
-RawType* Class::SignatureType() const {
+RawAbstractType* Class::SignatureType() const {
   // Return the first canonical signature type if already computed.
   const Array& signature_types = Array::Handle(canonical_types());
   if (signature_types.Length() > 0) {
-    Type& signature_type = Type::Handle();
+    AbstractType& signature_type = AbstractType::Handle();
     signature_type ^= signature_types.At(0);
     if (!signature_type.IsNull()) {
       return signature_type.raw();
     }
   }
   ASSERT(IsSignatureClass());
   TypeArguments& signature_type_arguments = TypeArguments::Handle();
   const intptr_t num_type_params = NumTypeParameters();
   // 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);
     String& type_param_name = String::Handle();
-    Type& type_param = Type::Handle();
+    AbstractType& type_param = AbstractType::Handle();
     for (int i = 0; i < num_type_params; i++) {
       type_param_name ^= type_params.At(i);
-      type_param = Type::NewTypeParameter(i, type_param_name);
+      type_param = AbstractType::NewTypeParameter(i, type_param_name);
       signature_type_arguments.SetTypeAt(i, type_param);
     }
   }
-  const ParameterizedType& signature_type = ParameterizedType::Handle(
-      ParameterizedType::New(*this, signature_type_arguments));
+  const Type& signature_type = Type::Handle(
+      Type::New(*this, signature_type_arguments));
 
   // Return the still unfinalized signature type.
   ASSERT(!signature_type.IsFinalized());
   return signature_type.raw();
 }
 
 
 template <class FakeObject>
 RawClass* Class::New() {
   Class& class_class = Class::Handle(Object::class_class());
@@ skipping 123 matching lines @@
     // More efficient than calling NumTypeArguments().
     return type_arguments_instance_field_offset() != kNoTypeArguments;
   } else {
     // No need to check NumTypeArguments() if class has type parameters.
     return (NumTypeParameters() > 0) || (NumTypeArguments() > 0);
   }
 }
 
 
 RawClass* Class::SuperClass() const {
-  const Type& sup_type = Type::Handle(super_type());
+  const AbstractType& sup_type = AbstractType::Handle(super_type());
   if (sup_type.IsNull()) {
     return Class::null();
   }
   return sup_type.type_class();
 }
 
 
-void Class::set_super_type(const Type& value) const {
+void Class::set_super_type(const AbstractType& value) const {
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
 bool Class::HasFactoryClass() const {
   const Object& factory_class = Object::Handle(raw_ptr()->factory_class_);
   return !factory_class.IsNull();
 }
 
 
@@ skipping 193 matching lines @@
   // Unless the signature function already has a signature class, create a
   // canonical signature class by having the signature function point back to
   // the signature class.
   if (signature_function.signature_class() == Object::null()) {
     signature_function.set_signature_class(result);
   }
   result.set_is_finalized();
   // Instances of a signature class can only be closures.
   ASSERT(result.instance_size() == Closure::InstanceSize());
   // Cache the signature type as the first canonicalized type in result.
-  const Type& signature_type = Type::Handle(result.SignatureType());
+  const AbstractType& signature_type =
+      AbstractType::Handle(result.SignatureType());
   ASSERT(!signature_type.IsFinalized());
   const Array& new_canonical_types = Array::Handle(Array::New(1, Heap::kOld));
   new_canonical_types.SetAt(0, signature_type);
   result.set_canonical_types(new_canonical_types);
   return result.raw();
 }
 
 
 RawClass* Class::GetClass(ObjectKind kind) {
   ObjectStore* object_store = Isolate::Current()->object_store();
@@ skipping 195 matching lines @@
     const Function& fun = Function::Handle(signature_function());
     const Function& other_fun = Function::Handle(other.signature_function());
     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());
-    Type& interface = Type::Handle();
+    AbstractType& interface = AbstractType::Handle();
     Class& interface_class = Class::Handle();
     TypeArguments& interface_args = TypeArguments::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
@@ skipping 316 matching lines @@
     return ident();
   }
 }
 
 
 const char* UnresolvedClass::ToCString() const {
   return "UnresolvedClass";
 }
 
 
-bool Type::IsResolved() const {
-  // Type is an abstract class.
+bool AbstractType::IsResolved() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool Type::HasResolvedTypeClass() const {
-  // Type is an abstract class.
+bool AbstractType::HasResolvedTypeClass() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-RawClass* Type::type_class() const {
-  // Type is an abstract class.
+RawClass* AbstractType::type_class() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return Class::null();
 }
 
 
-RawUnresolvedClass* Type::unresolved_class() const {
-  // Type is an abstract class.
+RawUnresolvedClass* AbstractType::unresolved_class() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return UnresolvedClass::null();
 }
 
 
-RawTypeArguments* Type::arguments() const  {
-  // Type is an abstract class.
+RawTypeArguments* AbstractType::arguments() const  {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-bool Type::IsInstantiated() const {
-  // Type is an abstract class.
+bool AbstractType::IsInstantiated() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool Type::IsFinalized() const {
-  // Type is an abstract class.
+bool AbstractType::IsFinalized() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool Type::IsBeingFinalized() const {
-  // Type is an abstract class.
+bool AbstractType::IsBeingFinalized() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool Type::Equals(const Type& other) const {
-  // Type is an abstract class.
+bool AbstractType::Equals(const AbstractType& other) const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-RawType* Type::InstantiateFrom(
+RawAbstractType* AbstractType::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
-  // Type is an abstract class.
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-RawType* Type::Canonicalize() const {
-  // Type is an abstract class.
+RawAbstractType* AbstractType::Canonicalize() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-RawString* Type::Name() const {
+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 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();
@@ skipping 30 matching lines @@
   String& type_name = String::Handle();
   if (num_type_params == 0) {
     type_name = class_name.raw();
   } else {
     const intptr_t num_strings = 2*num_type_params + 2;  // "C""<""T"", ""T"">".
     const Array& strings = Array::Handle(Array::New(num_strings));
     intptr_t s = 0;
     strings.SetAt(s++, class_name);
     strings.SetAt(s++, String::Handle(String::NewSymbol("<")));
     const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
-    Type& type = Type::Handle();
+    AbstractType& type = AbstractType::Handle();
     for (intptr_t i = 0; i < num_type_params; i++) {
       if (first_type_param_index + i >= num_args) {
-        type = DynamicType();
+        type = Type::DynamicType();
       } else {
         type = args.TypeAt(first_type_param_index + i);
       }
       type_name = type.Name();
       strings.SetAt(s++, type_name);
       if (i < num_type_params - 1) {
         strings.SetAt(s++, kCommaSpace);
       }
     }
     strings.SetAt(s++, String::Handle(String::NewSymbol(">")));
     ASSERT(s == num_strings);
     type_name = String::ConcatAll(strings);
   }
   // The name is only used for type checking and debugging purposes.
   // Unless profiling data shows otherwise, it is not worth caching the name in
   // the type.
   return String::NewSymbol(type_name);
 }
 
 
-intptr_t Type::Index() const {
-  // Type is an abstract class.
+intptr_t AbstractType::Index() const {
+  // AbstractType is an abstract class.
   UNREACHABLE();
   return -1;
 }
 
 
-RawString* Type::ClassName() const {
+RawString* AbstractType::ClassName() const {
   if (HasResolvedTypeClass()) {
     return Class::Handle(type_class()).Name();
   } else {
     return UnresolvedClass::Handle(unresolved_class()).Name();
   }
 }
 
 
-bool Type::IsBoolInterface() const {
+bool AbstractType::IsBoolInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::BoolInterface()).type_class());
 }
 
 
-bool Type::IsIntInterface() const {
+bool AbstractType::IsIntInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::IntInterface()).type_class());
 }
 
 
-bool Type::IsDoubleInterface() const {
+bool AbstractType::IsDoubleInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::DoubleInterface()).type_class());
 }
 
 
-bool Type::IsNumberInterface() const {
+bool AbstractType::IsNumberInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::NumberInterface()).type_class());
 }
 
 
-bool Type::IsStringInterface() const {
+bool AbstractType::IsStringInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::StringInterface()).type_class());
 }
 
 
-bool Type::IsFunctionInterface() const {
+bool AbstractType::IsFunctionInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::FunctionInterface()).type_class());
 }
 
 
-bool Type::IsListInterface() const {
+bool AbstractType::IsListInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::ListInterface()).type_class());
 }
 
 
-bool Type::IsMoreSpecificThan(const Type& other) const {
+bool AbstractType::IsMoreSpecificThan(const AbstractType& other) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
-  // Type parameters cannot be handled by Class::IsMoreSpecificThan().
+  // 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()));
 }
 
 
-bool Type::Test(TypeTestKind test, const Type& other) const {
+bool AbstractType::Test(TypeTestKind test, const AbstractType& other) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
-  // Type parameters cannot be handled by Class::TestType().
+  // 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()),
                             Class::Handle(other.type_class()),
                             TypeArguments::Handle(other.arguments()));
   } else {
     ASSERT(test == kIsAssignableTo);
     return cls.IsAssignableTo(TypeArguments::Handle(arguments()),
                               Class::Handle(other.type_class()),
                               TypeArguments::Handle(other.arguments()));
   }
 }
 
+RawAbstractType* AbstractType::NewTypeParameter(
+    intptr_t index, const String& name) {
+  return TypeParameter::New(index, name);
+}
 
-RawParameterizedType* Type::NullType() {
+
+RawAbstractType* AbstractType::NewInstantiatedType(
+    const AbstractType& uninstantiated_type,
+    const TypeArguments& instantiator_type_arguments) {
+  return InstantiatedType::New(uninstantiated_type,
+                               instantiator_type_arguments);
+}
+
+
+const char* AbstractType::ToCString() const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+  return "AbstractType";
+}
+
+
+RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
-RawParameterizedType* Type::DynamicType() {
+RawType* Type::DynamicType() {
   return Isolate::Current()->object_store()->dynamic_type();
 }
 
 
-RawParameterizedType* Type::VoidType() {
+RawType* Type::VoidType() {
   return Isolate::Current()->object_store()->void_type();
 }
 
 
-RawParameterizedType* Type::ObjectType() {
+RawType* Type::ObjectType() {
   return Isolate::Current()->object_store()->object_type();
 }
 
 
-RawParameterizedType* Type::BoolInterface() {
+RawType* Type::BoolInterface() {
   return Isolate::Current()->object_store()->bool_interface();
 }
 
 
-RawParameterizedType* Type::IntInterface() {
+RawType* Type::IntInterface() {
   return Isolate::Current()->object_store()->int_interface();
 }
 
 
-RawParameterizedType* Type::DoubleInterface() {
+RawType* Type::DoubleInterface() {
   return Isolate::Current()->object_store()->double_interface();
 }
 
 
-RawParameterizedType* Type::NumberInterface() {
+RawType* Type::NumberInterface() {
   return Isolate::Current()->object_store()->number_interface();
 }
 
 
-RawParameterizedType* Type::StringInterface() {
+RawType* Type::StringInterface() {
   return Isolate::Current()->object_store()->string_interface();
 }
 
 
-RawParameterizedType* Type::FunctionInterface() {
+RawType* Type::FunctionInterface() {
   return Isolate::Current()->object_store()->function_interface();
 }
 
 
-RawParameterizedType* Type::ListInterface() {
+RawType* Type::ListInterface() {
   return Isolate::Current()->object_store()->list_interface();
 }
 
 
-RawParameterizedType* Type::NewRawType(const Class& type_class) {
+RawType* Type::NewRawType(const Class& type_class) {
   const TypeArguments& type_arguments =
       TypeArguments::Handle(type_class.type_parameter_extends());
   return NewParameterizedType(Object::Handle(type_class.raw()), type_arguments);
 }
 
 
-RawParameterizedType* Type::NewNonParameterizedType(const Class& type_class) {
+RawType* Type::NewNonParameterizedType(
+    const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
-  ParameterizedType& type = ParameterizedType::Handle();
-  type ^= ParameterizedType::New(
+  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();
 }
 
 
-RawParameterizedType* Type::NewParameterizedType(const Object& clazz,
+RawType* Type::NewParameterizedType(const Object& clazz,
                                     const TypeArguments& arguments) {
-  return ParameterizedType::New(clazz, arguments);
+  return Type::New(clazz, arguments);
 }
 
 
-RawType* Type::NewTypeParameter(intptr_t index, const String& name) {
-  return TypeParameter::New(index, name);
+void Type::set_is_finalized() const {
+  ASSERT(!IsFinalized());
+  set_type_state(RawType::kFinalized);
 }
 
 
-RawType* Type::NewInstantiatedType(
-    const Type& uninstantiated_type,
-    const TypeArguments& instantiator_type_arguments) {
-  return InstantiatedType::New(uninstantiated_type,
-                               instantiator_type_arguments);
+void Type::set_is_being_finalized() const {
+  ASSERT(!IsFinalized() && !IsBeingFinalized());
+  set_type_state(RawType::kBeingFinalized);
 }
 
 
-const char* Type::ToCString() const {
-  // Type is an abstract class.
-  UNREACHABLE();
-  return "Type";
-}
-
-
-void ParameterizedType::set_is_finalized() const {
-  ASSERT(!IsFinalized());
-  set_type_state(RawParameterizedType::kFinalized);
-}
-
-
-void ParameterizedType::set_is_being_finalized() const {
-  ASSERT(!IsFinalized() && !IsBeingFinalized());
-  set_type_state(RawParameterizedType::kBeingFinalized);
-}
-
-
-bool ParameterizedType::IsResolved() const {
+bool Type::IsResolved() const {
   if (IsFinalized()) {
     return true;
   }
   if (!HasResolvedTypeClass()) {
     return false;
   }
   const TypeArguments& args = TypeArguments::Handle(arguments());
   return args.IsNull() || args.IsResolved();
 }
 
 
-bool ParameterizedType::HasResolvedTypeClass() const {
+bool Type::HasResolvedTypeClass() const {
   const Object& type_class = Object::Handle(raw_ptr()->type_class_);
   return !type_class.IsNull() && type_class.IsClass();
 }
 
 
-RawClass* ParameterizedType::type_class() const {
+RawClass* Type::type_class() const {
   ASSERT(HasResolvedTypeClass());
   Class& type_class = Class::Handle();
   type_class ^= raw_ptr()->type_class_;
   return type_class.raw();
 }
 
 
-RawUnresolvedClass* ParameterizedType::unresolved_class() const {
+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* ParameterizedType::arguments() const {
+RawTypeArguments* Type::arguments() const {
   return raw_ptr()->arguments_;
 }
 
 
-bool ParameterizedType::IsInstantiated() const {
+bool Type::IsInstantiated() const {
   const TypeArguments& args = TypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
 
 
-RawType* ParameterizedType::InstantiateFrom(
+RawAbstractType* Type::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   TypeArguments& type_arguments = TypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
                                                   offset);
   const Class& cls = Class::Handle(type_class());
   ASSERT(cls.is_finalized());
-  ParameterizedType& instantiated_type = ParameterizedType::Handle(
-      ParameterizedType::New(cls, type_arguments));
+  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 ParameterizedType::Equals(const Type& other) const {
+bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
-  if (!other.IsParameterizedType()) {
+  if (!other.IsType()) {
     return false;
   }
-  ParameterizedType& other_parameterized_type = ParameterizedType::Handle();
+  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()));
 }
 
 
-RawType* ParameterizedType::Canonicalize() const {
+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
     // the object store, remove all types from the object store, and replace
     // the test above by an assert?
     return this->raw();
   }
   const intptr_t canonical_types_len = canonical_types.Length();
   // Linear search to see whether this type is already present in the
   // list of canonicalized types.
-  Type& type = Type::Handle();
+  AbstractType& type = AbstractType::Handle();
   intptr_t index = 0;
   while (index < canonical_types_len) {
     type ^= canonical_types.At(index);
     if (type.IsNull()) {
       break;
     }
     if (!type.IsFinalized()) {
       ASSERT((index == 0) && cls.IsSignatureClass());
       index++;
       continue;
@@ skipping 11 matching lines @@
         Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
     cls.set_canonical_types(new_canonical_types);
     new_canonical_types.SetAt(index, *this);
   } else {
     canonical_types.SetAt(index, *this);
   }
   return this->raw();
 }
 
 
-void ParameterizedType::set_type_class(const Object& value) const {
+void Type::set_type_class(const Object& value) const {
   ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
 
-void ParameterizedType::set_arguments(const TypeArguments& value) const {
+void Type::set_arguments(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
-RawParameterizedType* ParameterizedType::New() {
-  const Class& parameterized_type_class =
-      Class::Handle(Object::parameterized_type_class());
-  RawObject* raw = Object::Allocate(parameterized_type_class,
-                                    ParameterizedType::InstanceSize(),
+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<RawParameterizedType*>(raw);
+  return reinterpret_cast<RawType*>(raw);
 }
 
 
-RawParameterizedType* ParameterizedType::New(const Object& clazz,
+RawType* Type::New(const Object& clazz,
                                              const TypeArguments& arguments) {
-  const ParameterizedType& result =
-      ParameterizedType::Handle(ParameterizedType::New());
+  const Type& result = Type::Handle(Type::New());
   result.set_type_class(clazz);
   result.set_arguments(arguments);
-  result.raw_ptr()->type_state_ = RawParameterizedType::kAllocated;
+  result.raw_ptr()->type_state_ = RawType::kAllocated;
   return result.raw();
 }
 
 
-void ParameterizedType::set_type_state(int8_t state) const {
-  ASSERT(state == RawParameterizedType::kAllocated ||
-         state == RawParameterizedType::kBeingFinalized ||
-         state == RawParameterizedType::kFinalized);
+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* ParameterizedType::ToCString() const {
+const char* Type::ToCString() const {
   if (IsResolved()) {
     const TypeArguments& type_arguments = TypeArguments::Handle(arguments());
     if (type_arguments.IsNull()) {
-      const char* format = "ParameterizedType: class '%s'";
+      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 = "ParameterizedType: class '%s', args:[%s]";
+      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();
       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 ParameterizedType";
+    return "Unresolved Type";
   }
 }
 
 
-bool TypeParameter::Equals(const Type& other) const {
+bool TypeParameter::Equals(const AbstractType& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   TypeParameter& other_type_parameter = TypeParameter::Handle();
   other_type_parameter ^= other.raw();
   return Index() == other_type_parameter.Index();
 }
 
 
 void TypeParameter::set_index(intptr_t value) const {
   ASSERT(value >= 0);
   raw_ptr()->index_ = value;
 }
 
 
 void TypeParameter::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
-RawType* TypeParameter::InstantiateFrom(
+RawAbstractType* TypeParameter::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   if (instantiator_type_arguments.IsNull()) {
-    return DynamicType();
+    return Type::DynamicType();
   }
   return instantiator_type_arguments.TypeAt(Index() + offset);
 }
 
 
 RawTypeParameter* TypeParameter::New() {
   const Class& type_parameter_class =
       Class::Handle(Object::type_parameter_class());
   RawObject* raw = Object::Allocate(type_parameter_class,
                                     TypeParameter::InstanceSize(),
@@ skipping 15 matching lines @@
   const char* name_cstr = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, Index()) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, format, name_cstr, Index());
   return chars;
 }
 
 
 RawClass* InstantiatedType::type_class() const {
-  return Type::Handle(uninstantiated_type()).type_class();
+  return AbstractType::Handle(uninstantiated_type()).type_class();
 }
 
 
 RawTypeArguments* InstantiatedType::arguments() const {
   return TypeArguments::NewInstantiatedTypeArguments(
-      TypeArguments::Handle(Type::Handle(uninstantiated_type()).arguments()),
+      TypeArguments::Handle(AbstractType::Handle(
+          uninstantiated_type()).arguments()),
       TypeArguments::Handle(instantiator_type_arguments()));
 }
 
 
-void InstantiatedType::set_uninstantiated_type(const Type& value) const {
+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 {
   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 Type& uninstantiated_type,
+    const AbstractType& uninstantiated_type,
     const TypeArguments& 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.
   UNREACHABLE();
   return -1;
 }
 
 
-RawType* TypeArguments::TypeAt(intptr_t index) const {
+RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-void TypeArguments::SetTypeAt(intptr_t index, const Type& value) const {
+void TypeArguments::SetTypeAt(intptr_t index, const AbstractType& value) const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
 }
 
 
 bool TypeArguments::IsResolved() const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
@@ skipping 39 matching lines @@
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 bool TypeArguments::IsDynamicTypes(intptr_t len) const {
   ASSERT(Length() >= len);
-  Type& type = Type::Handle();
+  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 {
   ASSERT(Length() >= len);
   ASSERT(!other.IsNull());
   ASSERT(other.Length() >= len);
-  Type& type = Type::Handle();
-  Type& other_type = Type::Handle();
+  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;
@@ skipping 19 matching lines @@
   return "TypeArguments";
 }
 
 
 intptr_t TypeArray::Length() const {
   ASSERT(!IsNull());
   return Smi::Value(raw_ptr()->length_);
 }
 
 
-RawType* TypeArray::TypeAt(intptr_t index) const {
+RawAbstractType* TypeArray::TypeAt(intptr_t index) const {
   return *TypeAddr(index);
 }
 
 
-void TypeArray::SetTypeAt(intptr_t index, const Type& value) const {
+void TypeArray::SetTypeAt(intptr_t index, const AbstractType& value) const {
   // TODO(iposva): Add storing NoGCScope.
   *TypeAddr(index) = value.raw();
 }
 
 
 bool TypeArray::IsResolved() const {
-  Type& type = Type::Handle();
+  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 {
-  Type& type = Type::Handle();
+  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 {
   ASSERT(!IsInstantiated());
-  Type& type = Type::Handle();
+  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 {
   intptr_t num_types = Length();
   if (num_types != other.Length()) {
     return false;
   }
-  Type& type = Type::Handle();
-  Type& other_type = Type::Handle();
+  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,
     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));
-  Type& type = Type::Handle();
+  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) {
   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();
   {
     RawObject* raw = Object::Allocate(type_array_class,
                                       TypeArray::InstanceSize(len),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     for (intptr_t i = 0; i < len; i++) {
-      *result.TypeAddr(i) = ParameterizedType::null();
+      *result.TypeAddr(i) = Type::null();
     }
   }
   return result.raw();
 }
 
 
-RawType** TypeArray::TypeAddr(intptr_t index) const {
+RawAbstractType** TypeArray::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) {
   // 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 {
   if (IsNull()) {
     return "NULL TypeArray";
   }
   const char* format = "%s [%s]";
   const char* prev_cstr = "TypeArray:";
   for (int i = 0; i < Length(); i++) {
-    const char* type_cstr = Type::Handle(TypeAt(i)).ToCString();
+    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();
 }
 
 
-RawType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
-  const Type& type = Type::Handle(
+RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
+  const AbstractType& type = AbstractType::Handle(
       TypeArguments::Handle(uninstantiated_type_arguments()).TypeAt(index));
   if (type.IsTypeParameter()) {
     TypeArguments& instantiator =
         TypeArguments::Handle(instantiator_type_arguments());
     return instantiator.TypeAt(type.Index());
   }
   if (!type.IsInstantiated()) {
     return InstantiatedType::New(
         type, TypeArguments::Handle(instantiator_type_arguments()));
   }
   return type.raw();
 }
 
 
 void InstantiatedTypeArguments::SetTypeAt(intptr_t index,
-                                          const Type& value) const {
+                                          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 {
   StorePointer(&raw_ptr()->uninstantiated_type_arguments_, value.raw());
 }
@@ skipping 100 matching lines @@
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void Function::set_owner(const Class& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->owner_, value.raw());
 }
 
 
-void Function::set_result_type(const Type& value) const {
+void Function::set_result_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->result_type_, value.raw());
 }
 
 
-RawType* Function::ParameterTypeAt(intptr_t index) const {
+RawAbstractType* Function::ParameterTypeAt(intptr_t index) const {
   const Array& parameter_types = Array::Handle(raw_ptr()->parameter_types_);
-  Type& parameter_type = Type::Handle();
+  AbstractType& parameter_type = AbstractType::Handle();
   parameter_type ^= parameter_types.At(index);
   return parameter_type.raw();
 }
 
 
-void Function::SetParameterTypeAt(intptr_t index, const Type& value) const {
+void Function::SetParameterTypeAt(
+    intptr_t index, const AbstractType& value) const {
   ASSERT(!value.IsNull());
   const Array& parameter_types = Array::Handle(raw_ptr()->parameter_types_);
   parameter_types.SetAt(index, value);
 }
 
 
 void Function::set_parameter_types(const Array& value) const {
   StorePointer(&raw_ptr()->parameter_types_, value.raw());
 }
 
@@ skipping 186 matching lines @@
   }
   return true;
 }
 
 
 bool Function::TestParameterType(
     intptr_t parameter_position,
     const TypeArguments& type_arguments,
     const Function& other,
     const TypeArguments& other_type_arguments) const {
-  Type& param_type = Type::Handle(ParameterTypeAt(parameter_position));
+  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;
   }
-  Type& other_param_type =
-      Type::Handle(other.ParameterTypeAt(parameter_position));
+  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 {
   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 == Type::kIsSubtypeOf) &&
+      ((test == AbstractType::kIsSubtypeOf) &&
        (num_opt_params < other_num_opt_params))) {
     return false;
   }
   // Check the result type.
-  Type& other_res_type = Type::Handle(other.result_type());
+  AbstractType& other_res_type = AbstractType::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
     other_res_type = other_res_type.InstantiateFrom(other_type_arguments, 0);
   }
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
-    Type& res_type = Type::Handle(result_type());
+    AbstractType& res_type = AbstractType::Handle(result_type());
     if (!res_type.IsInstantiated()) {
       res_type = res_type.InstantiateFrom(type_arguments, 0);
     }
     if (!res_type.IsDynamicType() &&
         (res_type.IsVoidType() ||
          !(res_type.IsSubtypeOf(other_res_type) ||
            other_res_type.IsSubtypeOf(res_type)))) {
       return false;
     }
   }
   // Check the types of fixed parameters.
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     if (!TestParameterType(i, type_arguments, other, other_type_arguments)) {
       return false;
     }
   }
   // Check the names and types of optional parameters.
   if (num_opt_params >= other_num_opt_params) {
     // Check that for each optional named parameter of type T of the other
     // function type, there is a corresponding optional named parameter of this
-    // function at the same position with an identical name and with a Type S
+    // function at the same position with an identical name and with a type S
     // that is a subtype or supertype of T.
     // Note that SetParameterNameAt() guarantees that names are symbols, so we
     // can compare their raw pointers.
     const intptr_t other_num_params =
         other_num_fixed_params + other_num_opt_params;
     String& other_param_name = String::Handle();
     for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
       other_param_name = other.ParameterNameAt(i);
       if ((ParameterNameAt(i) != other_param_name.raw()) ||
           !TestParameterType(i, type_arguments, other, other_type_arguments)) {
         return false;
       }
     }
     return true;
   }
-  ASSERT((test == Type::kIsAssignableTo) &&
+  ASSERT((test == AbstractType::kIsAssignableTo) &&
          (num_opt_params < other_num_opt_params));
   // To verify that this function type is assignable to the other function type,
   // check that for each optional named parameter of type T of this function
   // type, there is a corresponding optional named parameter of the other
-  // function at the same position with an identical name and with a Type S that
+  // function at the same position with an identical name and with a type S that
   // is a subtype or supertype of T.
   // Note that SetParameterNameAt() guarantees that names are symbols, so we
   // can compare their raw pointers.
   const intptr_t num_params = num_fixed_params + num_opt_params;
   String& other_param_name = String::Handle();
   for (intptr_t i = num_fixed_params; i < num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     if ((ParameterNameAt(i) != other_param_name.raw()) ||
         !TestParameterType(i, type_arguments, other, other_type_arguments)) {
       return false;
@@ skipping 75 matching lines @@
   // Set closure function's context scope.
   ContextScope& context_scope = ContextScope::Handle();
   if (is_static()) {
     context_scope ^= ContextScope::New(0);
   } else {
     context_scope ^= LocalScope::CreateImplicitClosureScope(*this);
   }
   closure_function.set_context_scope(context_scope);
 
   // Set closure function's result type to this result type.
-  closure_function.set_result_type(Type::Handle(result_type()));
+  closure_function.set_result_type(AbstractType::Handle(result_type()));
 
   // Set closure function's formal parameters to this formal parameters,
   // removing the receiver if this is an instance method.
   const int has_receiver = is_static() ? 0 : 1;
   const int num_fixed_params = num_fixed_parameters() - has_receiver;
   const int num_optional_params = num_optional_parameters();
   const int num_params = num_fixed_params + num_optional_params;
   closure_function.set_num_fixed_parameters(num_fixed_params);
   closure_function.set_num_optional_parameters(num_optional_params);
   closure_function.set_parameter_types(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
   closure_function.set_parameter_names(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
-  Type& param_type = Type::Handle();
+  AbstractType& param_type = AbstractType::Handle();
   String& param_name = String::Handle();
   for (int i = 0; i < num_params; i++) {
     param_type = ParameterTypeAt(i + has_receiver);
     closure_function.SetParameterTypeAt(i, param_type);
     param_name = ParameterNameAt(i + has_receiver);
     closure_function.SetParameterNameAt(i, param_name);
   }
 
   // Lookup or create a new signature class for the closure function in the
   // library of the owner class.
   const Class& owner_class = Class::Handle(owner());
   ASSERT(!owner_class.IsNull() && (owner() == closure_function.owner()));
   const Library& library = Library::Handle(owner_class.library());
   ASSERT(!library.IsNull());
   const String& signature = String::Handle(closure_function.Signature());
   Class& signature_class = Class::ZoneHandle(
       library.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     const Script& script = Script::Handle(owner_class.script());
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script);
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
-  const Type& signature_type = Type::Handle(signature_class.SignatureType());
+  const AbstractType& signature_type =
+      AbstractType::Handle(signature_class.SignatureType());
   if (!signature_type.IsFinalized()) {
     String& errmsg = String::Handle();
     ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
     ASSERT(errmsg.IsNull());
   }
   ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
@@ skipping 26 matching lines @@
     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(
           function_class.type_parameter_extends());
-      Type& parameter_extends = Type::Handle();
+      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()));
         }
         if (i < num_type_parameters - 1) {
           pieces.Add(&kCommaSpace);
         }
       }
       pieces.Add(&kRAngleBracket);
     }
   }
-  Type& param_type = Type::Handle();
+  AbstractType& param_type = AbstractType::Handle();
   const intptr_t num_params = NumberOfParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   pieces.Add(&kLParen);
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
     if (instantiate && !param_type.IsInstantiated()) {
       param_type = param_type.InstantiateFrom(instantiator, offset);
@@ skipping 14 matching lines @@
       }
       ASSERT(!param_type.IsNull());
       pieces.Add(&String::ZoneHandle(param_type.Name()));
       if (i != (num_params - 1)) {
         pieces.Add(&kCommaSpace);
       }
     }
     pieces.Add(&kRBracket);
   }
   pieces.Add(&kRParen);
-  Type& res_type = Type::Handle(result_type());
+  AbstractType& res_type = AbstractType::Handle(result_type());
   if (instantiate && !res_type.IsInstantiated()) {
     res_type = res_type.InstantiateFrom(instantiator, offset);
   }
   pieces.Add(&String::Handle(res_type.Name()));
   const Array& strings = Array::Handle(NewArray<const String>(pieces));
   return String::NewSymbol(String::Handle(String::ConcatAll(strings)));
 }
 
 
 bool Function::HasInstantiatedSignature() const {
-  Type& type = Type::Handle(result_type());
+  AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated()) {
     return false;
   }
   const intptr_t num_parameters = NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = ParameterTypeAt(i);
     if (!type.IsInstantiated()) {
       return false;
     }
   }
@@ skipping 86 matching lines @@
   return raw_ptr()->value_;
 }
 
 
 void Field::set_value(const Instance& value) const {
   ASSERT(is_static());  // Valid only for static dart fields.
   StorePointer(&raw_ptr()->value_, value.raw());
 }
 
 
-void Field::set_type(const Type& value) const {
+void Field::set_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 
 RawField* Field::New() {
   const Class& field_class = Class::Handle(Object::field_class());
   RawObject* raw = Object::Allocate(field_class,
                                     Field::InstanceSize(),
                                     Heap::kOld);
@@ skipping 1356 matching lines @@
 bool ContextScope::IsFinalAt(intptr_t scope_index) const {
   return Bool::Handle(VariableDescAddr(scope_index)->is_final).value();
 }
 
 
 void ContextScope::SetIsFinalAt(intptr_t scope_index, bool is_final) const {
   VariableDescAddr(scope_index)->is_final = Bool::Get(is_final);
 }
 
 
-RawType* ContextScope::TypeAt(intptr_t scope_index) const {
+RawAbstractType* ContextScope::TypeAt(intptr_t scope_index) const {
   return VariableDescAddr(scope_index)->type;
 }
 
 
-void ContextScope::SetTypeAt(intptr_t scope_index, const Type& type) const {
+void ContextScope::SetTypeAt(
+    intptr_t scope_index, const AbstractType& type) const {
   VariableDescAddr(scope_index)->type = type.raw();
 }
 
 
 intptr_t ContextScope::ContextIndexAt(intptr_t scope_index) const {
   return Smi::Value(VariableDescAddr(scope_index)->context_index);
 }
 
 
 void ContextScope::SetContextIndexAt(intptr_t scope_index,
@@ skipping 151 matching lines @@
         Array::Handle(Array::Grow(constants, new_length, Heap::kOld));
     cls.set_constants(new_constants);
     new_constants.SetAt(index, *this);
   } else {
     constants.SetAt(index, *this);
   }
   return this->raw();
 }
 
 
-RawParameterizedType* Instance::GetType() const {
+RawType* Instance::GetType() const {
   if (IsNull()) {
-    return ParameterizedType::NullType();
+    return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (cls.HasTypeArguments()) {
     type_arguments = GetTypeArguments();
   }
-  const ParameterizedType& type = ParameterizedType::Handle(
-      ParameterizedType::New(cls, type_arguments));
+  const Type& type = Type::Handle(Type::New(cls, type_arguments));
   type.set_is_finalized();
   return type.raw();
 }
 
 
 RawTypeArguments* 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();
   type_arguments ^= *FieldAddrAtOffset(field_offset);
   return type_arguments.raw();
 }
 
 
 void Instance::SetTypeArguments(const TypeArguments& 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 Type& other,
+                        const AbstractType& other,
                         const TypeArguments& other_instantiator) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsVoidType());
   if (IsNull()) {
-    if (test == Type::kIsSubtypeOf) {
+    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 Type& instantiated_other =
-            Type::Handle(other_instantiator.TypeAt(other.Index()));
+        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 == Type::kIsAssignableTo);
+      ASSERT(test == AbstractType::kIsAssignableTo);
       return true;
     }
   }
   const Class& cls = Class::Handle(clazz());
   TypeArguments& type_arguments = TypeArguments::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();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator, 0), however, we can save the
-  // allocation of a new Type by inlining the code.
+  // allocation of a new AbstractType by inlining the code.
   if (other.IsTypeParameter()) {
-    Type& instantiated_other = Type::Handle();
+    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();
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
@@ skipping 2180 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