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

runtime/vm/object_store.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_STORE_H_
 #define VM_OBJECT_STORE_H_
 
 #include "vm/object.h"
 
 namespace dart {
@@ skipping 47 matching lines @@
   };
 
   ~ObjectStore();
 
   RawClass* object_class() const { return object_class_; }
   void set_object_class(const Class& value) { object_class_ = value.raw(); }
   static intptr_t object_class_offset() {
     return OFFSET_OF(ObjectStore, object_class_);
   }
 
-  RawType* object_type() const { return object_type_; }
-  void set_object_type(const Type& value) { object_type_ = value.raw(); }
+  RawParameterizedType* object_type() const { return object_type_; }
+  void set_object_type(const ParameterizedType& value) {
+    object_type_ = value.raw();
+  }
 
-  RawType* null_type() const { return null_type_; }
-  void set_null_type(const Type& value) { null_type_ = value.raw(); }
+  RawParameterizedType* null_type() const { return null_type_; }
+  void set_null_type(const ParameterizedType& value) {
+    null_type_ = value.raw();
+  }
 
-  RawType* dynamic_type() const { return dynamic_type_; }
-  void set_dynamic_type(const Type& value) { dynamic_type_ = value.raw(); }
+  RawParameterizedType* dynamic_type() const { return dynamic_type_; }
+  void set_dynamic_type(const ParameterizedType& value) {
+    dynamic_type_ = value.raw();
+  }
 
-  RawType* void_type() const { return void_type_; }
-  void set_void_type(const Type& value) { void_type_ = value.raw(); }
+  RawParameterizedType* void_type() const { return void_type_; }
+  void set_void_type(const ParameterizedType& value) {
+    void_type_ = value.raw();
+  }
 
-  RawType* function_interface() const { return function_interface_; }
-  void set_function_interface(const Type& value) {
+  RawParameterizedType* function_interface() const {
+    return function_interface_;
+  }
+  void set_function_interface(const ParameterizedType& value) {
     function_interface_ = value.raw();
   }
 
-  RawType* number_interface() const { return number_interface_; }
-  void set_number_interface(const Type& value) {
+  RawParameterizedType* number_interface() const { return number_interface_; }
+  void set_number_interface(const ParameterizedType& value) {
     number_interface_ = value.raw();
   }
 
-  RawType* int_interface() const { return int_interface_; }
-  void set_int_interface(const Type& value) { int_interface_ = value.raw(); }
+  RawParameterizedType* int_interface() const { return int_interface_; }
+  void set_int_interface(const ParameterizedType& value) {
+    int_interface_ = value.raw();
+  }
 
   RawClass* smi_class() const { return smi_class_; }
   void set_smi_class(const Class& value) { smi_class_ = value.raw(); }
   static intptr_t smi_class_offset() {
     return OFFSET_OF(ObjectStore, smi_class_);
   }
 
-  RawType* double_interface() const { return double_interface_; }
-  void set_double_interface(const Type& value) {
+  RawParameterizedType* double_interface() const { return double_interface_; }
+  void set_double_interface(const ParameterizedType& value) {
     double_interface_ = value.raw();
   }
 
   RawClass* double_class() const { return double_class_; }
   void set_double_class(const Class& value) { double_class_ = value.raw(); }
 
   RawClass* mint_class() const { return mint_class_; }
   void set_mint_class(const Class& value) { mint_class_ = value.raw(); }
 
   RawClass* bigint_class() const { return bigint_class_; }
   void set_bigint_class(const Class& value) { bigint_class_ = value.raw(); }
 
-  RawType* string_interface() const { return string_interface_; }
-  void set_string_interface(const Type& value) {
+  RawParameterizedType* string_interface() const { return string_interface_; }
+  void set_string_interface(const ParameterizedType& value) {
     string_interface_ = value.raw();
   }
 
   RawClass* one_byte_string_class() const { return one_byte_string_class_; }
   void set_one_byte_string_class(const Class& value) {
     one_byte_string_class_ = value.raw();
   }
 
   RawClass* two_byte_string_class() const { return two_byte_string_class_; }
   void set_two_byte_string_class(const Class& value) {
@@ skipping 19 matching lines @@
     external_two_byte_string_class_ = value.raw();
   }
 
   RawClass* external_four_byte_string_class() const {
     return external_four_byte_string_class_;
   }
   void set_external_four_byte_string_class(const Class& value) {
     external_four_byte_string_class_ = value.raw();
   }
 
-  RawType* bool_interface() const { return bool_interface_; }
-  void set_bool_interface(const Type& value) { bool_interface_ = value.raw(); }
+  RawParameterizedType* bool_interface() const { return bool_interface_; }
+  void set_bool_interface(const ParameterizedType& value) {
+    bool_interface_ = value.raw();
+  }
 
   RawClass* bool_class() const { return bool_class_; }
   void set_bool_class(const Class& value) { bool_class_ = value.raw(); }
 
-  RawType* list_interface() const { return list_interface_; }
-  void set_list_interface(const Type& value) {
+  RawParameterizedType* list_interface() const { return list_interface_; }
+  void set_list_interface(const ParameterizedType& value) {
     list_interface_ = value.raw();
   }
 
   RawClass* array_class() const { return array_class_; }
   void set_array_class(const Class& value) { array_class_ = value.raw(); }
   static intptr_t array_class_offset() {
     return OFFSET_OF(ObjectStore, array_class_);
   }
 
   RawClass* immutable_array_class() const { return immutable_array_class_; }
@@ skipping 91 matching lines @@
   RawContext* empty_context() const { return empty_context_; }
   void set_empty_context(const Context& value) {
     empty_context_ = value.raw();
   }
 
   // Visit all object pointers.
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   RawClass* GetClass(int index);
   int GetClassIndex(const RawClass* raw_class);
-  RawType* GetType(int index);
-  int GetTypeIndex(const RawType* raw_type);
+  RawParameterizedType* GetType(int index);
+  int GetTypeIndex(const RawParameterizedType* raw_type);
 
   static void Init(Isolate* isolate);
 
  private:
   ObjectStore();
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&object_class_); }
   RawClass* object_class_;
-  RawType* object_type_;
-  RawType* null_type_;
-  RawType* dynamic_type_;
-  RawType* void_type_;
-  RawType* function_interface_;
-  RawType* number_interface_;
-  RawType* int_interface_;
+  RawParameterizedType* object_type_;
+  RawParameterizedType* null_type_;
+  RawParameterizedType* dynamic_type_;
+  RawParameterizedType* void_type_;
+  RawParameterizedType* function_interface_;
+  RawParameterizedType* number_interface_;
+  RawParameterizedType* int_interface_;
   RawClass* smi_class_;
   RawClass* mint_class_;
   RawClass* bigint_class_;
-  RawType* double_interface_;
+  RawParameterizedType* double_interface_;
   RawClass* double_class_;
-  RawType* string_interface_;
+  RawParameterizedType* string_interface_;
   RawClass* one_byte_string_class_;
   RawClass* two_byte_string_class_;
   RawClass* four_byte_string_class_;
   RawClass* external_one_byte_string_class_;
   RawClass* external_two_byte_string_class_;
   RawClass* external_four_byte_string_class_;
-  RawType* bool_interface_;
+  RawParameterizedType* bool_interface_;
   RawClass* bool_class_;
-  RawType* list_interface_;
+  RawParameterizedType* list_interface_;
   RawClass* array_class_;
   RawClass* immutable_array_class_;
   RawClass* byte_buffer_class_;
   RawClass* unhandled_exception_class_;
   RawClass* stacktrace_class_;
   RawClass* jsregexp_class_;
   RawBool* true_value_;
   RawBool* false_value_;
   RawArray* empty_array_;
   RawArray* symbol_table_;
   RawLibrary* core_library_;
   RawLibrary* core_impl_library_;
   RawLibrary* native_wrappers_library_;
   RawLibrary* root_library_;
   RawLibrary* registered_libraries_;
   RawArray* pending_classes_;
   RawString* sticky_error_;
   RawContext* empty_context_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&empty_context_); }
 
   friend class SnapshotReader;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectStore);
 };
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_STORE_H_