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

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 344 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();
-  Type& type = Type::Handle();
+  ParameterizedType& type = ParameterizedType::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 973 matching lines @@
       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
         // parameters of this type before performing the type test.
         if (type_arguments.IsNull()) {
           // This type is raw, so the uninstantiated type arguments of the
           // interface cannot be instantiated and we must check against a raw
           // interface.
-          interface_args = TypeArguments::null();
+          interface_args = TypeArray::null();
         } else {
           // The type arguments of this type that are referred to by the type
           // parameters of the interface are at the end of the type vector,
           // after the type arguments of the super type of this type.
           const intptr_t offset = NumTypeArguments() - NumTypeParameters();
           interface_args = interface_args.InstantiateFrom(type_arguments,
                                                           offset);
           // TODO(regis): Check the subtyping constraints if any, i.e. if
           // interface.type_parameter_extends() is not an array of DynamicType.
           // Should we pass the constraints to InstantiateFrom and it would
@@ skipping 331 matching lines @@
 RawUnresolvedClass* Type::unresolved_class() const {
   // Type is an abstract class.
   UNREACHABLE();
   return UnresolvedClass::null();
 }
 
 
 RawTypeArguments* Type::arguments() const  {
   // Type is an abstract class.
   UNREACHABLE();
-  return TypeArguments::null();
+  return NULL;
 }
 
 
 bool Type::IsInstantiated() const {
   // Type is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
@@ skipping 16 matching lines @@
   UNREACHABLE();
   return false;
 }
 
 
 RawType* Type::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   // Type is an abstract class.
   UNREACHABLE();
-  return Type::null();
+  return NULL;
 }
 
 
 RawType* Type::Canonicalize() const {
   // Type is an abstract class.
   UNREACHABLE();
-  return Type::null();
+  return NULL;
 }
 
 
 RawString* Type::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;
@@ skipping 153 matching lines @@
                             TypeArguments::Handle(other.arguments()));
   } else {
     ASSERT(test == kIsAssignableTo);
     return cls.IsAssignableTo(TypeArguments::Handle(arguments()),
                               Class::Handle(other.type_class()),
                               TypeArguments::Handle(other.arguments()));
   }
 }
 
 
-RawType* Type::NullType() {
+RawParameterizedType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
-RawType* Type::DynamicType() {
+RawParameterizedType* Type::DynamicType() {
   return Isolate::Current()->object_store()->dynamic_type();
 }
 
 
-RawType* Type::VoidType() {
+RawParameterizedType* Type::VoidType() {
   return Isolate::Current()->object_store()->void_type();
 }
 
 
-RawType* Type::ObjectType() {
+RawParameterizedType* Type::ObjectType() {
   return Isolate::Current()->object_store()->object_type();
 }
 
 
-RawType* Type::BoolInterface() {
+RawParameterizedType* Type::BoolInterface() {
   return Isolate::Current()->object_store()->bool_interface();
 }
 
 
-RawType* Type::IntInterface() {
+RawParameterizedType* Type::IntInterface() {
   return Isolate::Current()->object_store()->int_interface();
 }
 
 
-RawType* Type::DoubleInterface() {
+RawParameterizedType* Type::DoubleInterface() {
   return Isolate::Current()->object_store()->double_interface();
 }
 
 
-RawType* Type::NumberInterface() {
+RawParameterizedType* Type::NumberInterface() {
   return Isolate::Current()->object_store()->number_interface();
 }
 
 
-RawType* Type::StringInterface() {
+RawParameterizedType* Type::StringInterface() {
   return Isolate::Current()->object_store()->string_interface();
 }
 
 
-RawType* Type::FunctionInterface() {
+RawParameterizedType* Type::FunctionInterface() {
   return Isolate::Current()->object_store()->function_interface();
 }
 
 
-RawType* Type::ListInterface() {
+RawParameterizedType* Type::ListInterface() {
   return Isolate::Current()->object_store()->list_interface();
 }
 
 
-RawType* Type::NewRawType(const Class& type_class) {
+RawParameterizedType* 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);
 }
 
 
-RawType* Type::NewNonParameterizedType(const Class& type_class) {
+RawParameterizedType* Type::NewNonParameterizedType(const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   ParameterizedType& type = ParameterizedType::Handle();
   type ^= ParameterizedType::New(
       Object::Handle(type_class.raw()), no_type_arguments);
   type.set_is_finalized();
   type ^= type.Canonicalize();
   return type.raw();
 }
 
 
-RawType* Type::NewParameterizedType(const Object& clazz,
+RawParameterizedType* Type::NewParameterizedType(const Object& clazz,
                                     const TypeArguments& arguments) {
   return ParameterizedType::New(clazz, arguments);
 }
 
 
 RawType* Type::NewTypeParameter(intptr_t index, const String& name) {
   return TypeParameter::New(index, name);
 }
 
 
@@ skipping 187 matching lines @@
 
 void ParameterizedType::set_type_state(int8_t state) const {
   ASSERT(state == RawParameterizedType::kAllocated ||
          state == RawParameterizedType::kBeingFinalized ||
          state == RawParameterizedType::kFinalized);
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* ParameterizedType::ToCString() const {
-  return "ParameterizedType";
+  if (IsResolved()) {
+    const char* format = "ParameterizedType: 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";
+  }
 }
 
 
 bool TypeParameter::Equals(const Type& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
@@ skipping 37 matching lines @@
 
 RawTypeParameter* TypeParameter::New(intptr_t index, const String& name) {
   const TypeParameter& result = TypeParameter::Handle(TypeParameter::New());
   result.set_index(index);
   result.set_name(name);
   return result.raw();
 }
 
 
 const char* TypeParameter::ToCString() const {
-  return "TypeParameter";
+  const char* format = "TypeParameter: name %s; index: %d";
+  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();
 }
 
 
 RawTypeArguments* InstantiatedType::arguments() const {
   return TypeArguments::NewInstantiatedTypeArguments(
@@ skipping 42 matching lines @@
 intptr_t TypeArguments::Length() const  {
   // TypeArguments is an abstract class.
   UNREACHABLE();
   return -1;
 }
 
 
 RawType* TypeArguments::TypeAt(intptr_t index) const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
-  return Type::null();
+  return NULL;
 }
 
 
 void TypeArguments::SetTypeAt(intptr_t index, const Type& value) const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
 }
 
 
 bool TypeArguments::IsResolved() const {
@@ skipping 37 matching lines @@
   }
   return arguments.Equals(other_arguments);
 }
 
 
 RawTypeArguments* TypeArguments::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
-  return TypeArguments::null();
+  return NULL;
 }
 
 
 bool TypeArguments::IsDynamicTypes(intptr_t len) const {
   ASSERT(Length() >= len);
   Type& type = Type::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
@@ skipping 159 matching lines @@
   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) = Type::null();
+      *result.TypeAddr(i) = ParameterizedType::null();
     }
   }
   return result.raw();
 }
 
 
 RawType** 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 {
-  return "TypeArray";
+  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();
+    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(
@@ skipping 46 matching lines @@
     const TypeArguments& instantiator_type_arguments) {
   const InstantiatedTypeArguments& result =
       InstantiatedTypeArguments::Handle(InstantiatedTypeArguments::New());
   result.set_uninstantiated_type_arguments(uninstantiated_type_arguments);
   result.set_instantiator_type_arguments(instantiator_type_arguments);
   return result.raw();
 }
 
 
 const char* InstantiatedTypeArguments::ToCString() const {
-  return "InstantiatedTypeArguments";
+  if (IsNull()) {
+    return "NULL InstantiatedTypeArguments";
+  }
+  const char* format = "InstantiatedTypeArguments: [%s] instantiator: [%s]\n";
+  const char* arg_cstr =
+      TypeArguments::Handle(uninstantiated_type_arguments()).ToCString();
+  const char* instantiator_cstr =
+      TypeArguments::Handle(instantiator_type_arguments()).ToCString();
+  intptr_t len =
+      OS::SNPrint(NULL, 0, format, arg_cstr, instantiator_cstr) + 1;
+  char* chars = reinterpret_cast<char*>(
+      Isolate::Current()->current_zone()->Allocate(len));
+  OS::SNPrint(chars, len, format, arg_cstr, instantiator_cstr);
+  return chars;
 }
 
 
 void Function::SetCode(const Code& value) const {
   StorePointer(&raw_ptr()->code_, value.raw());
   ASSERT(Function::Handle(value.function()).IsNull() ||
     (value.function() == this->raw()));
   value.set_function(*this);
 }
 
@@ skipping 2260 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();
 }
 
 
-RawType* Instance::GetType() const {
+RawParameterizedType* Instance::GetType() const {
   if (IsNull()) {
-    return Type::NullType();
+    return ParameterizedType::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));
   type.set_is_finalized();
   return type.raw();
@@ skipping 2260 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