Use ParametrizedType instead of Type where appropriate. Expand ToCString of type related classes.

runtime/vm/object.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 699 matching lines @@
   // 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;
 
-  // Check if this type represents the 'null' type.
-  bool IsNullType() const {
-    return HasResolvedTypeClass() && (type_class() == Object::null_class());
-  }
-
   // Check if this type represents the 'Dynamic' type.
   bool IsDynamicType() const {
     return HasResolvedTypeClass() && (type_class() == Object::dynamic_class());
   }
 
   // Check if this type represents the 'void' type.
   bool IsVoidType() const {
     return HasResolvedTypeClass() && (type_class() == Object::void_class());
   }
 
@@ skipping 39 matching lines @@
   bool IsSubtypeOf(const Type& other) const {
     return Test(kIsSubtypeOf, other);
   }
 
   // Check the assignability relationship.
   bool IsAssignableTo(const Type& dst) const {
     return Test(kIsAssignableTo, dst);
   }
 
   // The type of the literal 'null'.
-  static RawType* NullType();
+  static RawParameterizedType* NullType();
 
   // The 'Dynamic' type.
-  static RawType* DynamicType();
+  static RawParameterizedType* DynamicType();
 
   // The 'void' type.
-  static RawType* VoidType();
+  static RawParameterizedType* VoidType();
 
   // The 'Object' type.
-  static RawType* ObjectType();
+  static RawParameterizedType* ObjectType();
 
   // The 'bool' interface type.
-  static RawType* BoolInterface();
+  static RawParameterizedType* BoolInterface();
 
   // The 'int' interface type.
-  static RawType* IntInterface();
+  static RawParameterizedType* IntInterface();
 
   // The 'double' interface type.
-  static RawType* DoubleInterface();
+  static RawParameterizedType* DoubleInterface();
 
   // The 'num' interface type.
-  static RawType* NumberInterface();
+  static RawParameterizedType* NumberInterface();
 
   // The 'String' interface type.
-  static RawType* StringInterface();
+  static RawParameterizedType* StringInterface();
 
   // The 'Function' interface type.
-  static RawType* FunctionInterface();
+  static RawParameterizedType* FunctionInterface();
 
   // The 'List' interface type.
-  static RawType* ListInterface();
+  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 RawType* NewRawType(const Class& type_class);
+  static RawParameterizedType* NewRawType(const Class& type_class);
 
   // The finalized type of the given non-parameterized class.
-  static RawType* NewNonParameterizedType(const Class& type_class);
+  static RawParameterizedType* NewNonParameterizedType(const Class& type_class);
 
-  static RawType* NewParameterizedType(const Object& type_class,
-                                       const TypeArguments& arguments);
+  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,
       const TypeArguments& instantiator_type_arguments);
 
  protected:
   // Check the subtype or assignability relationship.
   bool Test(TypeTestKind test, const Type& other) const;
@@ skipping 124 matching lines @@
 
   HEAP_OBJECT_IMPLEMENTATION(InstantiatedType, Type);
   friend class Class;
 };
 
 
 // TypeArguments is an abstract superclass.
 // Subclasses of TypeArguments are TypeArray and InstantiatedTypes.
 class TypeArguments : public Object {
  public:
-  virtual intptr_t Length() const;
-  virtual RawType* TypeAt(intptr_t index) const;
-  virtual void SetTypeAt(intptr_t index, const Type& value) const;
-  virtual bool IsResolved() const;
-  virtual bool IsInstantiated() const;
-  virtual bool IsUninstantiatedIdentity() const;
-  virtual bool Equals(const TypeArguments& other) const;
   static bool AreEqual(const TypeArguments& arguments,
                        const TypeArguments& other_arguments);
 
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
   // type of the instantiator type argument vector starting at the given offset.
   virtual RawTypeArguments* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
   // Check if this type argument vector consists solely of DynamicType,
   // considering only a prefix of length 'len'.
   bool IsDynamicTypes(intptr_t len) const;
 
   // Check the "more specific than" relationship, considering only a prefix of
   // length 'len'.
   bool IsMoreSpecificThan(const TypeArguments& other, intptr_t len) const;
 
   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 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;
@@ skipping 1123 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();
   }
 
-  RawType* GetType() const;
+  RawParameterizedType* 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,
                     const TypeArguments& type_instantiator) const {
     return TestType(kIsSubtypeOf, type, type_instantiator);
   }
 
@@ skipping 1081 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_