Cleanups.

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 1192 matching lines @@
   return raw() == Type::Handle(Type::ObjectType()).type_class();
 }
 
 
 bool Class::IsCanonicalSignatureClass() const {
   const Function& function = Function::Handle(signature_function());
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
 
-// TODO(regis): We can probably merge this function with IsSubtypeOf, but since
-// the spec is not definitive, we still follow it somewhat closely, to make it
-// easier to implement spec changes.
 bool Class::IsMoreSpecificThan(
     const TypeArguments& type_arguments,
     const Class& other,
     const TypeArguments& other_type_arguments) const {
   // Check for VarType.
   // The VarType on the lefthand side is replaced by the bottom type, which is
   // more specific than any type.
   // Any type is more specific than the VarType on the righthand side.
   if (IsVarClass() || other.IsVarClass()) {
     return true;
@@ skipping 108 matching lines @@
       return src_fun.IsAssignableTo(type_arguments,
                                     dst_fun,
                                     other_type_arguments);
     }
     // Continue with a subtype test.
     test = kIsSubtypeOf;
   }
   ASSERT(test == kIsSubtypeOf);
 
   // Check for "more specific" relation.
-  if (IsMoreSpecificThan(type_arguments, other, other_type_arguments)) {
-    return true;
-  }
-  // TODO(regis): Merge IsMoreSpecificThan here after type checks for
-  // function types are finalized and implemented.
-  // For now, keep the assert below.
-
-  // The optionality and dubious bliss rules described in the guide have
-  // already been checked in IsMoreSpecificThan call above.
-  if (raw() != other.raw()) {
-    return false;
-  }
-  ASSERT(HasTypeArguments());  // Otherwise, IsMoreSpecificThan would be true.
-  return false;
+  return IsMoreSpecificThan(type_arguments, other, other_type_arguments);
 }
 
 
 RawFunction* Class::LookupDynamicFunction(const String& name) const {
   Function& function = Function::Handle(LookupFunction(name));
   if (function.IsNull() || function.is_static()) {
     return Function::null();
   }
   switch (function.kind()) {
     case RawFunction::kFunction:
@@ skipping 3462 matching lines @@
 bool Instance::IsValidFieldOffset(int offset) const {
   const Class& cls = Class::Handle(clazz());
   return (offset >= 0 && offset <= (cls.instance_size() - kWordSize));
 }
 
 
 const char* Instance::ToCString() const {
   if (IsNull()) {
     return "null";
   } else {
-    // TODO(regis): Print type arguments if any.
     const char* kFormat = "Instance of '%s'";
     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();
+    }
+    const Type& type = Type::Handle(
+        Type::NewParameterizedType(cls, type_arguments));
+    const String& type_name = String::Handle(type.Name());
     // Calculate the size of the string.
-    intptr_t len = OS::SNPrint(NULL, 0, kFormat, cls.ToCString()) + 1;
+    intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = reinterpret_cast<char*>(
         Isolate::Current()->current_zone()->Allocate(len));
-    OS::SNPrint(chars, len, kFormat, cls.ToCString());
+    OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
 
 const char* Number::ToCString() const {
   // Number is an interface. No instances of Number should exist.
   UNREACHABLE();
   return "Number";
 }
@@ skipping 1942 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