Fix error reporting when calling static methods and closures withh mismatched arguments.

runtime/vm/object.cc

 // Copyright (c) 2012, 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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 12346 matching lines @@
 
 void Array::MakeImmutable() const {
   NoGCScope no_gc;
   uword tags = raw_ptr()->tags_;
   tags = RawObject::ClassIdTag::update(kImmutableArrayCid, tags);
   raw_ptr()->tags_ = tags;
 }
 
 
 const char* Array::ToCString() const {
-  return "Array";
+  if (IsNull()) {
+    return "Array NULL";
+  }
+  const char* format = "Array len:%"Pd"";
+  intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, format, Length());
+  return chars;
 }
 
 
 RawArray* Array::Grow(const Array& source, int new_length, Heap::Space space) {
   const Array& result = Array::Handle(Array::New(new_length, space));
   intptr_t len = 0;
   if (!source.IsNull()) {
     len = source.Length();
     result.SetTypeArguments(
         AbstractTypeArguments::Handle(source.GetTypeArguments()));
@@ skipping 44 matching lines @@
 
 RawImmutableArray* ImmutableArray::New(intptr_t len,
                                        Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->immutable_array_class() !=
          Class::null());
   return reinterpret_cast<RawImmutableArray*>(Array::New(kClassId, len, space));
 }
 
 
 const char* ImmutableArray::ToCString() const {
-  return "ImmutableArray";
+  if (IsNull()) {
+    return "ImmutableArray NULL";
+  }
+  const char* format = "ImmutableArray len:%"Pd"";
+  intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, format, Length());
+  return chars;
 }
 
 
 void GrowableObjectArray::Add(const Object& value, Heap::Space space) const {
   ASSERT(!IsNull());
   if (Length() == Capacity()) {
     // TODO(Issue 2500): Need a better growth strategy.
     intptr_t new_capacity = (Capacity() == 0) ? 4 : Capacity() * 2;
     if (new_capacity <= Capacity()) {
       // Use the preallocated out of memory exception to avoid calling
@@ skipping 90 matching lines @@
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(0);
     result.SetData(array);
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
-  return "GrowableObjectArray";
+  if (IsNull()) {
+    return "GrowableObjectArray NULL";
+  }
+  const char* format = "GrowableObjectArray len:%"Pd"";
+  intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, format, Length());
+  return chars;
 }
 
 
 RawFloat32x4* Float32x4::New(float v0, float v1, float v2, float v3,
                              Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
          Class::null());
   Float32x4& result = Float32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Float32x4::kClassId,
@@ skipping 650 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart