Renaming type classes as discussed:

runtime/vm/object.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 103 matching lines @@
   // Index for Singleton internal VM classes,
   // this index is used in snapshots to refer to these classes directly.
   enum {
     kNullObject = 0,
     kSentinelObject,
     kClassClass,
     kNullClass,
     kDynamicClass,
     kVoidClass,
     kUnresolvedClassClass,
-    kParameterizedTypeClass,
+    kTypeClass,
     kTypeParameterClass,
     kInstantiatedTypeClass,
     kTypeArgumentsClass,
     kTypeArrayClass,
     kInstantiatedTypeArgumentsClass,
     kFunctionClass,
     kFieldClass,
     kTokenStreamClass,
     kScriptClass,
     kLibraryClass,
@@ skipping 71 matching lines @@
   static RawInstance* sentinel() { return sentinel_; }
   // Value marking that we are transitioning from sentinel, e.g., computing
   // a field value. Used to detect circular initialization.
   static RawInstance* transition_sentinel() { return transition_sentinel_; }
 
   static RawClass* class_class() { return class_class_; }
   static RawClass* null_class() { return null_class_; }
   static RawClass* dynamic_class() { return dynamic_class_; }
   static RawClass* void_class() { return void_class_; }
   static RawClass* unresolved_class_class() { return unresolved_class_class_; }
-  static RawClass* parameterized_type_class() {
-      return parameterized_type_class_;
+  static RawClass* type_class() {
+      return type_class_;
   }
   static RawClass* type_parameter_class() { return type_parameter_class_; }
   static RawClass* instantiated_type_class() {
       return instantiated_type_class_;
   }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
   static RawClass* type_array_class() { return type_array_class_; }
   static RawClass* instantiated_type_arguments_class() {
       return instantiated_type_arguments_class_;
   }
@@ skipping 87 matching lines @@
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
   static RawInstance* sentinel_;
   static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
   static RawClass* dynamic_class_;  // Class of the 'Dynamic' type.
   static RawClass* void_class_;  // Class of the 'void' type.
   static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
-  static RawClass* parameterized_type_class_;  // Class of ParameterizedType.
+  static RawClass* type_class_;  // Class of Type.
   static RawClass* type_parameter_class_;  // Class of TypeParameter vm object.
   static RawClass* instantiated_type_class_;  // Class of InstantiatedType.
   static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
   static RawClass* type_array_class_;  // Class of the TypeArray vm object.
   static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
   static RawClass* function_class_;  // Class of the Function vm object.
   static RawClass* field_class_;  // Class of the Field vm object.
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
   static RawClass* script_class_;  // Class of the Script vm object.
   static RawClass* library_class_;  // Class of the Library vm object.
@@ skipping 65 matching lines @@
   }
   static intptr_t signature_function_offset() {
     return OFFSET_OF(RawClass, signature_function_);
   }
 
   // Return the signature type of this signature class.
   // For example, if this class represents a signature of the form
   // '<T, R>(T, [b: B, c: C]) => R', then its signature type is a parameterized
   // type with this class as the type class and type parameters 'T' and 'R'
   // as its type argument vector.
-  RawType* SignatureType() const;
+  RawAbstractType* SignatureType() const;

[regis, 2011/12/01 04:24:07]

A signature type is always a Type based on a signature class known at compile
time. You could change it here or in a later cl.

[srdjan, 2011/12/01 17:48:42]

Done in next CL.

 
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
   // The type parameters are specified as an array of Strings.
   RawArray* type_parameters() const { return raw_ptr()->type_parameters_; }
   void set_type_parameters(const Array& value) const;
   intptr_t NumTypeParameters() const;
 
   // Type parameters may optionally extend a Type (Dynamic if no extends).
@@ skipping 16 matching lines @@
   static const intptr_t kNoTypeArguments = -1;
   intptr_t type_arguments_instance_field_offset() const {
     ASSERT(is_finalized() || is_prefinalized());
     return raw_ptr()->type_arguments_instance_field_offset_;
   }
   void set_type_arguments_instance_field_offset(intptr_t value) const {
     raw_ptr()->type_arguments_instance_field_offset_ = value;
   }
 
   // The super type of this class, Object type if not explicitly specified.
-  RawType* super_type() const { return raw_ptr()->super_type_; }
-  void set_super_type(const Type& value) const;
+  RawAbstractType* super_type() const { return raw_ptr()->super_type_; }
+  void set_super_type(const AbstractType& value) const;

[regis, 2011/12/01 04:24:07]

A super type is always a Type based on a class known at compile time. You could
change it here or in a later cl.

[srdjan, 2011/12/01 17:48:42]

Done in next CL.

 
   // Asserts that the class of the super type has been resolved.
   RawClass* SuperClass() const;
 
   // Return true if this interface has a factory class.
   bool HasFactoryClass() const;
 
   // Return true if the factory class of this interface is resolved.
   bool HasResolvedFactoryClass() const;
 
   // Return the resolved factory class of this interface.
   RawClass* FactoryClass() const;
 
   // Return the unresolved factory class of this interface.
   RawUnresolvedClass* UnresolvedFactoryClass() const;
 
   // Set the resolved or unresolved factory class of this interface.
   void set_factory_class(const Object& value) const;
 
   // Interfaces is an array of Types.
   RawArray* interfaces() const { return raw_ptr()->interfaces_; }

[regis, 2011/12/01 04:24:07]

We could maybe change this to return a TypeArguments. Later cl.

[srdjan, 2011/12/01 17:48:42]

Added TODO

   void set_interfaces(const Array& value) const;
 
   RawArray* functions_cache() const { return raw_ptr()->functions_cache_; }
   void set_functions_cache(const Array& value) const;
 
   static intptr_t functions_cache_offset() {
     return OFFSET_OF(RawClass, functions_cache_);
   }
 
   // Check if this class represents the class of null.
@@ skipping 129 matching lines @@
 
   // Return a class object corresponding to the specified kind. If
   // a canonicalized version of it exists then that object is returned
   // otherwise a new object is allocated and returned.
   static RawClass* GetClass(ObjectKind kind);
 
  private:
   void set_name(const String& value) const;
   void set_script(const Script& value) const;
   void set_signature_function(const Function& value) const;
-  void set_signature_type(const Type& value) const;
+  void set_signature_type(const AbstractType& value) const;
   void set_class_state(int8_t state) const;
 
   void set_constants(const Array& value) const;
   RawArray* constants() const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
 
   void CalculateFieldOffsets() const;
 
   // Check the subtype or assignability relationship.
   bool TestType(TypeTestKind test,
                 const TypeArguments& type_arguments,
                 const Class& other,
                 const TypeArguments& other_type_arguments) const;
 
   // Assigns empty array to all raw class array fields.
   void InitEmptyFields();
 
   HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class Object;
   friend class Instance;
-  friend class ParameterizedType;
+  friend class Type;
 };
 
 
 // Unresolved class is used for storing unresolved names which will be resolved
 // to a class after all classes have been loaded and finalized.
 class UnresolvedClass : public Object {
  public:
   RawString* qualifier() const { return raw_ptr()->qualifier_; }
   RawString* ident() const { return raw_ptr()->ident_; }
   intptr_t token_index() const { return raw_ptr()->token_index_; }
@@ skipping 17 matching lines @@
   void set_ident(const String& ident) const;
   void set_qualifier(const String& qualifier) const;
 
   static RawUnresolvedClass* New();
 
   HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
-// Type is an abstract superclass.
-// Subclasses of Type are ParameterizedType, TypeParameter, and
+// AbstractType is an abstract superclass.
+// Subclasses of AbstractType are Type, TypeParameter, and
 // InstantiatedType.
 //
-// Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type,
-// as opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does
-// not relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
-class Type : public Object {
+// Caution: 'RawAbstractType*' denotes a 'raw' pointer to a VM object of class
+// AbstractType, as opposed to 'AbstractType' denoting a 'handle' to the same
+// object. 'RawAbstractType' does not relate to a 'raw type', as opposed to a
+// 'cooked type' or 'rare type'.
+class AbstractType : public Object {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsBeingFinalized() const;
   virtual bool IsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual bool IsInstantiated() const;
-  virtual bool Equals(const Type& other) const;
+  virtual bool Equals(const AbstractType& other) const;
 
   // Instantiate this type using the given type argument vector starting at the
   // given offset.
   // Return a new type, or return 'this' if it is already instantiated.
-  virtual RawType* InstantiateFrom(
+  virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
   // Return the canonical version of this type.
-  virtual RawType* Canonicalize() const;
+  virtual RawAbstractType* Canonicalize() const;
 
   // The name of this type, including the names of its type arguments, if any.
   virtual RawString* Name() const;
 
   // The index of this type parameter. Fail if not a type parameter.
   virtual intptr_t Index() const;
 
   // The name of this type's class, i.e. without the type argument names of this
   // type.
   RawString* ClassName() const;
@@ skipping 37 matching lines @@
   // Check if this type is an interface type.
   bool IsInterfaceType() const {
     if (!HasResolvedTypeClass()) {
       return false;
     }
     const Class& cls = Class::Handle(type_class());
     return !cls.IsNull() && cls.is_interface();
   }
 
   // Check the "more specific than" relationship.
-  bool IsMoreSpecificThan(const Type& other) const;
+  bool IsMoreSpecificThan(const AbstractType& other) const;
 
   // Check the subtype relationship.
-  bool IsSubtypeOf(const Type& other) const {
+  bool IsSubtypeOf(const AbstractType& other) const {
     return Test(kIsSubtypeOf, other);
   }
 
   // Check the assignability relationship.
-  bool IsAssignableTo(const Type& dst) const {
+  bool IsAssignableTo(const AbstractType& dst) const {
     return Test(kIsAssignableTo, dst);
   }
 
-  // The type of the literal 'null'.
-  static RawParameterizedType* NullType();
+  static RawAbstractType* NewTypeParameter(intptr_t index, const String& name);
 
-  // The 'Dynamic' type.
-  static RawParameterizedType* DynamicType();
-
-  // The 'void' type.
-  static RawParameterizedType* VoidType();
-
-  // The 'Object' type.
-  static RawParameterizedType* ObjectType();
-
-  // The 'bool' interface type.
-  static RawParameterizedType* BoolInterface();
-
-  // The 'int' interface type.
-  static RawParameterizedType* IntInterface();
-
-  // The 'double' interface type.
-  static RawParameterizedType* DoubleInterface();
-
-  // The 'num' interface type.
-  static RawParameterizedType* NumberInterface();
-
-  // The 'String' interface type.
-  static RawParameterizedType* StringInterface();
-
-  // The 'Function' interface type.
-  static RawParameterizedType* FunctionInterface();
-
-  // The 'List' interface type.
-  static RawParameterizedType* ListInterface();
-
-  // The least specific valid raw type of the given class.
-  // For example, type A<Dynamic> would be returned for class A<T>, and type
-  // B<Dynamic, A<Dynamic>> would be returned for B<U, V extends A>.
-  static RawParameterizedType* NewRawType(const Class& type_class);
-
-  // The finalized type of the given non-parameterized class.
-  static RawParameterizedType* NewNonParameterizedType(const Class& type_class);
-
-  static RawParameterizedType* NewParameterizedType(
-      const Object& type_class, const TypeArguments& arguments);
-
-  static RawType* NewTypeParameter(intptr_t index, const String& name);
-
-  static RawType* NewInstantiatedType(
-      const Type& uninstantiated_type,
+  static RawAbstractType* NewInstantiatedType(
+      const AbstractType& uninstantiated_type,
       const TypeArguments& instantiator_type_arguments);
 
  protected:
   // Check the subtype or assignability relationship.
-  bool Test(TypeTestKind test, const Type& other) const;
+  bool Test(TypeTestKind test, const AbstractType& other) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Type, Object);
+  HEAP_OBJECT_IMPLEMENTATION(AbstractType, Object);
   friend class Class;
 };
 
 
-// A ParameterizedType consists of a class, possibly parameterized with type
+// A Type consists of a class, possibly parameterized with type
 // arguments. Example: C<T1, T2>.
 // An unresolved class is a String specifying the class name.
-class ParameterizedType : public Type {
+class Type : public AbstractType {
  public:
   virtual bool IsFinalized() const {
-    return raw_ptr()->type_state_ == RawParameterizedType::kFinalized;
+    return raw_ptr()->type_state_ == RawType::kFinalized;
   }
   void set_is_finalized() const;
   virtual bool IsBeingFinalized() const {
-    return raw_ptr()->type_state_ == RawParameterizedType::kBeingFinalized;
+    return raw_ptr()->type_state_ == RawType::kBeingFinalized;
   }
   void set_is_being_finalized() const;
   virtual bool IsResolved() const;  // Class and all arguments classes resolved.
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
   void set_type_class(const Object& value) const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   void set_arguments(const TypeArguments& value) const;
   virtual bool IsInstantiated() const;
-  virtual bool Equals(const Type& other) const;
-  virtual RawType* InstantiateFrom(
+  virtual bool Equals(const AbstractType& other) const;
+  virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
-  virtual RawType* Canonicalize() const;
+  virtual RawAbstractType* Canonicalize() const;
 
   static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawParameterizedType));
+    return RoundedAllocationSize(sizeof(RawType));
   }
 
-  static RawParameterizedType* New(const Object& clazz,
+  // The type of the literal 'null'.
+  static RawType* NullType();
+
+  // The 'Dynamic' type.
+  static RawType* DynamicType();
+
+  // The 'void' type.
+  static RawType* VoidType();
+
+  // The 'Object' type.
+  static RawType* ObjectType();
+
+  // The 'bool' interface type.
+  static RawType* BoolInterface();
+
+  // The 'int' interface type.
+  static RawType* IntInterface();
+
+  // The 'double' interface type.
+  static RawType* DoubleInterface();
+
+  // The 'num' interface type.
+  static RawType* NumberInterface();
+
+  // The 'String' interface type.
+  static RawType* StringInterface();
+
+  // The 'Function' interface type.
+  static RawType* FunctionInterface();
+
+  // The 'List' interface type.
+  static RawType* ListInterface();
+
+  // The least specific valid raw type of the given class.
+  // For example, type A<Dynamic> would be returned for class A<T>, and type
+  // B<Dynamic, A<Dynamic>> would be returned for B<U, V extends A>.
+  static RawType* NewRawType(const Class& type_class);
+
+  // The finalized type of the given non-parameterized class.
+  static RawType* NewNonParameterizedType(const Class& type_class);
+
+  static RawType* NewParameterizedType(
+      const Object& type_class, const TypeArguments& arguments);
+
+  static RawType* New(const Object& clazz,
                                    const TypeArguments& arguments);
 
  private:
   void set_type_state(int8_t state) const;
 
-  static RawParameterizedType* New();
+  static RawType* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(ParameterizedType, Type);
+  HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
 };
 
 
 // A TypeParameter, in the context of a parameterized class, references a type
 // parameter of a class by its index (and by its name for debugging purposes).
 // For example, the type parameter 'V' is specified as index 1 in the context of
 // the class HashMap<K, V>. At compile time, the TypeParameter is not
 // instantiated yet, i.e. it is only a place holder.
-class TypeParameter : public Type {
+class TypeParameter : public AbstractType {
  public:
   virtual bool IsFinalized() const { return true; }
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return false; }
   virtual RawString* Name() const { return raw_ptr()->name_; }
   virtual intptr_t Index() const { return raw_ptr()->index_; }
   virtual bool IsInstantiated() const { return false; }
-  virtual bool Equals(const Type& other) const;
-  virtual RawType* InstantiateFrom(
+  virtual bool Equals(const AbstractType& other) const;
+  virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
-  virtual RawType* Canonicalize() const { return raw(); }
+  virtual RawAbstractType* Canonicalize() const { return raw(); }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTypeParameter));
   }
 
   static RawTypeParameter* New(intptr_t index, const String& name);
 
  private:
   void set_index(intptr_t value) const;
   void set_name(const String& value) const;
   static RawTypeParameter* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(TypeParameter, Type);
+  HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // An instance of InstantiatedType is never encountered at compile time, but
 // only at run time, when type parameters can be matched to actual types.
-// An instance of InstantiatedType consists of an uninstantiated Type object
-// and of a TypeArguments object. The type is uninstantiated, because it
+// An instance of InstantiatedType consists of an uninstantiated AbstractType
+// object and of a TypeArguments object. The type is uninstantiated, because it
 // refers to at least one TypeParameter object, i.e. to a type that is not known
 // at compile time.
 // The type argument vector is the instantiator, because each type parameter
 // with index i in the uninstantiated type can be substituted (or
 // "instantiated") with the type at index i in the type argument vector.
-class InstantiatedType : public Type {
+class InstantiatedType : public AbstractType {
  public:
   virtual bool IsFinalized() const { return true; }
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return true; }
   virtual RawClass* type_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual bool IsInstantiated() const { return true; }
 
-  RawType* uninstantiated_type() const {
+  RawAbstractType* uninstantiated_type() const {
     return raw_ptr()->uninstantiated_type_;
   }
   RawTypeArguments* instantiator_type_arguments() const {
     return raw_ptr()->instantiator_type_arguments_;
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawInstantiatedType));
   }
 
   static RawInstantiatedType* New(
-      const Type& uninstantiated_type,
+      const AbstractType& uninstantiated_type,
       const TypeArguments& instantiator_type_arguments);
 
  private:
-  void set_uninstantiated_type(const Type& value) const;
+  void set_uninstantiated_type(const AbstractType& value) const;
   void set_instantiator_type_arguments(const TypeArguments& value) const;
   static RawInstantiatedType* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(InstantiatedType, Type);
+  HEAP_OBJECT_IMPLEMENTATION(InstantiatedType, AbstractType);
   friend class Class;
 };
 
 
 // TypeArguments is an abstract superclass.
 // Subclasses of TypeArguments are TypeArray and InstantiatedTypes.
 class TypeArguments : public Object {
  public:
   static bool AreEqual(const TypeArguments& arguments,
                        const TypeArguments& other_arguments);
@@ skipping 15 matching lines @@
   bool IsMoreSpecificThan(const TypeArguments& other, intptr_t len) const;
 
   static RawTypeArguments* NewTypeArray(intptr_t len);
 
   static RawTypeArguments* NewInstantiatedTypeArguments(
       const TypeArguments& uninstantiated_type_arguments,
       const TypeArguments& instantiator_type_arguments);
 
   // UNREACHABLEs as TypeArguments is an abstract class.
   virtual intptr_t Length() const;
-  virtual RawType* TypeAt(intptr_t index) const;
-  virtual void SetTypeAt(intptr_t index, const Type& value) const;
+  virtual RawAbstractType* TypeAt(intptr_t index) const;
+  virtual void SetTypeAt(intptr_t index, const AbstractType& value) const;
   virtual bool IsResolved() const;
   virtual bool IsInstantiated() const;
   virtual bool IsUninstantiatedIdentity() const;
   virtual bool Equals(const TypeArguments& other) const;
 
  protected:
   HEAP_OBJECT_IMPLEMENTATION(TypeArguments, Object);
   friend class Class;
 };
 
 
 // A TypeArray is simply an array of Types.
 class TypeArray : public TypeArguments {
  public:
   virtual intptr_t Length() const;
-  virtual RawType* TypeAt(intptr_t index) const;
-  virtual void SetTypeAt(intptr_t index, const Type& value) const;
+  virtual RawAbstractType* TypeAt(intptr_t index) const;
+  virtual void SetTypeAt(intptr_t index, const AbstractType& value) const;
   virtual bool IsResolved() const;
   virtual bool IsInstantiated() const;
   virtual bool IsUninstantiatedIdentity() const;
   virtual bool Equals(const TypeArguments& other) const;
 
   virtual RawTypeArguments* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
   static intptr_t length_offset() { return OFFSET_OF(RawTypeArray, length_); }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTypeArray) == OFFSET_OF(RawTypeArray, types_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     // Ensure that the types_ is not adding to the object length.
     ASSERT(sizeof(RawTypeArray) == 2 * kWordSize);
     return RoundedAllocationSize(sizeof(RawTypeArray) + (len * kWordSize));
   }
 
   static RawTypeArray* New(intptr_t len);
 
  private:
   // Make sure that the array size cannot wrap around.
   static const intptr_t kMaxTypes = 512 * 1024 * 1024;
-  RawType** TypeAddr(intptr_t index) const;
+  RawAbstractType** TypeAddr(intptr_t index) const;
   void SetLength(intptr_t value);
 
   HEAP_OBJECT_IMPLEMENTATION(TypeArray, TypeArguments);
   friend class Class;
 };
 
 
 // An instance of InstantiatedTypeArguments is never encountered at compile
 // time, but only at run time, when type parameters can be matched to actual
 // types.
 // An instance of InstantiatedTypeArguments consists of a pair of TypeArguments
 // objects. The first type argument vector is uninstantiated, because it
 // contains type expressions referring to at least one TypeParameter object,
 // i.e. to a type that is not known at compile time.
 // The second type argument vector is the instantiator, because each type
 // parameter with index i in the first vector can be substituted (or
 // "instantiated") with the type at index i in the second type argument vector.
 class InstantiatedTypeArguments : public TypeArguments {
  public:
   virtual intptr_t Length() const;
-  virtual RawType* TypeAt(intptr_t index) const;
-  virtual void SetTypeAt(intptr_t index, const Type& value) const;
+  virtual RawAbstractType* TypeAt(intptr_t index) const;
+  virtual void SetTypeAt(intptr_t index, const AbstractType& value) const;
   virtual bool IsResolved() const { return true; }
   virtual bool IsInstantiated() const { return true; }
   virtual bool IsUninstantiatedIdentity() const  { return false; }
 
   RawTypeArguments* uninstantiated_type_arguments() const {
     return raw_ptr()->uninstantiated_type_arguments_;
   }
   static intptr_t uninstantiated_type_arguments_offset() {
     return OFFSET_OF(RawInstantiatedTypeArguments,
                      uninstantiated_type_arguments_);
@@ skipping 44 matching lines @@
     return BuildSignature(true, instantiator, offset);
   }
 
   // Returns true if the signature of this function is instantiated, i.e. if it
   // does not involve generic parameter types or generic result type.
   bool HasInstantiatedSignature() const;
 
   RawClass* owner() const { return raw_ptr()->owner_; }
   void set_owner(const Class& value) const;
 
-  RawType* result_type() const { return raw_ptr()->result_type_; }
-  void set_result_type(const Type& value) const;
+  RawAbstractType* result_type() const { return raw_ptr()->result_type_; }
+  void set_result_type(const AbstractType& value) const;
 
-  RawType* ParameterTypeAt(intptr_t index) const;
-  void SetParameterTypeAt(intptr_t index, const Type& value) const;
+  RawAbstractType* ParameterTypeAt(intptr_t index) const;
+  void SetParameterTypeAt(intptr_t index, const AbstractType& value) const;
   void set_parameter_types(const Array& value) const;
 
   // Parameter names are valid for all valid parameter indices, and are not
   // limited to named optional parameters.
   RawString* ParameterNameAt(intptr_t index) const;
   void SetParameterNameAt(intptr_t index, const String& value) const;
   void set_parameter_names(const Array& value) const;
 
   RawCode* code() const { return raw_ptr()->code_; }
   // Sets function's code and code's function.
@@ skipping 216 matching lines @@
   inline void SetOffset(intptr_t value) const;
 
   RawInstance* value() const;
   void set_value(const Instance& value) const;
 
   RawClass* owner() const { return raw_ptr()->owner_; }
   void set_owner(const Class& value) const {
     StorePointer(&raw_ptr()->owner_, value.raw());
   }
 
-  RawType* type() const  { return raw_ptr()->type_; }
-  void set_type(const Type& value) const;
+  RawAbstractType* type() const  { return raw_ptr()->type_; }
+  void set_type(const AbstractType& value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawField));
   }
 
   static RawField* New(const String& name,
                        bool is_static,
                        bool is_final,
                        intptr_t token_index);
 
@@ skipping 646 matching lines @@
 
   intptr_t TokenIndexAt(intptr_t scope_index) const;
   void SetTokenIndexAt(intptr_t scope_index, intptr_t token_index) const;
 
   RawString* NameAt(intptr_t scope_index) const;
   void SetNameAt(intptr_t scope_index, const String& name) const;
 
   bool IsFinalAt(intptr_t scope_index) const;
   void SetIsFinalAt(intptr_t scope_index, bool is_const) const;
 
-  RawType* TypeAt(intptr_t scope_index) const;
-  void SetTypeAt(intptr_t scope_index, const Type& type) const;
+  RawAbstractType* TypeAt(intptr_t scope_index) const;
+  void SetTypeAt(intptr_t scope_index, const AbstractType& type) const;
 
   intptr_t ContextIndexAt(intptr_t scope_index) const;
   void SetContextIndexAt(intptr_t scope_index, intptr_t context_index) const;
 
   intptr_t ContextLevelAt(intptr_t scope_index) const;
   void SetContextLevelAt(intptr_t scope_index, intptr_t context_level) const;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawContextScope) == OFFSET_OF(RawContextScope, data_));
     return 0;
@@ skipping 86 matching lines @@
   virtual RawInstance* Canonicalize() const;
 
   RawObject* GetField(const Field& field) const {
     return *FieldAddr(field);
   }
 
   void SetField(const Field& field, const Object& value) const {
     *FieldAddr(field) = value.raw();
   }
 
-  RawParameterizedType* GetType() const;
+  RawType* GetType() const;
 
   virtual RawTypeArguments* GetTypeArguments() const;
   virtual void SetTypeArguments(const TypeArguments& value) const;
 
   // Check if this instance is an instance of the given type.
-  bool IsInstanceOf(const Type& type,
+  bool IsInstanceOf(const AbstractType& type,
                     const TypeArguments& type_instantiator) const {
     return TestType(kIsSubtypeOf, type, type_instantiator);
   }
 
   // Check if this instance is assignable to the given type.
-  bool IsAssignableTo(const Type& type,
+  bool IsAssignableTo(const AbstractType& type,
                       const TypeArguments& type_instantiator) const {
     return TestType(kIsAssignableTo, type, type_instantiator);
   }
 
   bool IsValidNativeIndex(int index) const;
 
   intptr_t GetNativeField(int index) const {
     return *NativeFieldAddr(index);
   }
 
@@ skipping 22 matching lines @@
                                        + sizeof(RawObject));
   }
   void SetFieldAtOffset(intptr_t offset, const Object& value) const {
     *FieldAddrAtOffset(offset) = value.raw();
   }
   bool IsValidFieldOffset(int offset) const;
 
   // Check the subtype or assignability relationship between the type of this
   // instance and the given type.
   bool TestType(TypeTestKind test,
-                const Type& type,
+                const AbstractType& type,
                 const TypeArguments& type_instantiator) const;
 
   // TODO(iposva): Determine if this gets in the way of Smi.
   HEAP_OBJECT_IMPLEMENTATION(Instance, Object);
   friend class Class;
 };
 
 
 class Number : public Instance {
  public:
@@ skipping 889 matching lines @@
                        const GrowableArray<uword>& stack_frame_pcs) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Stacktrace, Instance);
   friend class Class;
 };
 
 
 // Internal JavaScript regular expression object.
 class JSRegExp : public Instance {
  public:
-  // Meaning of Type:
+  // Meaning of RegExType:
   // kUninitialized: the type of th regexp has not been initialized yet.
   // kSimple: A simple pattern to match against, using string indexOf operation.
   // kComplex: A complex pattern to match.
-  enum Type {
+  enum RegExType {
     kUnitialized = 0,
     kSimple,
     kComplex,
   };
 
   // Flags are passed to a regex object as follows:
   // 'i': ignore case, 'g': do global matches, 'm': pattern is multi line.
   enum Flags {
     kNone = 0,
     kGlobal = 1,
@@ skipping 33 matching lines @@
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(sizeof(RawJSRegExp) + len);
   }
 
   static RawJSRegExp* New(intptr_t length, Heap::Space space = Heap::kNew);
 
  private:
-  void set_type(Type type) const { raw_ptr()->type_ = type; }
+  void set_type(RegExType type) const { raw_ptr()->type_ = type; }
   void set_flags(intptr_t value) const { raw_ptr()->flags_ = value; }
 
   void SetLength(intptr_t value) {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->data_length_ = Smi::New(value);
   }
 
   HEAP_OBJECT_IMPLEMENTATION(JSRegExp, Instance);
   friend class Class;
@@ skipping 58 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_