Make all objects print at least their type in PrintToJSONStream.

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 3987 matching lines @@
   const char* format = "unresolved class '%s'";
   const char* cname =  String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, cname) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, cname);
   return chars;
 }
 
 
 void UnresolvedClass::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 static intptr_t FinalizeHash(uword hash) {
   hash += hash << 3;
   hash ^= hash >> 11;
   hash += hash << 15;
   return hash;
 }
 
@@ skipping 689 matching lines @@
   const Class& cls = Class::Handle(patched_class());
   const char* cls_name = cls.ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, cls_name) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name);
   return chars;
 }
 
 
 void PatchClass::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawPatchClass* PatchClass::New(const Class& patched_class,
                                const Class& source_class) {
   const PatchClass& result = PatchClass::Handle(PatchClass::New());
   result.set_patched_class(patched_class);
   result.set_source_class(source_class);
   return result.raw();
 }
@@ skipping 1663 matching lines @@
   return reinterpret_cast<RawClosureData*>(raw);
 }
 
 
 const char* ClosureData::ToCString() const {
   return "ClosureData class";
 }
 
 
 void ClosureData::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 void RedirectionData::set_type(const Type& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 
 void RedirectionData::set_identifier(const String& value) const {
@@ skipping 14 matching lines @@
   return reinterpret_cast<RawRedirectionData*>(raw);
 }
 
 
 const char* RedirectionData::ToCString() const {
   return "RedirectionData class";
 }
 
 
 void RedirectionData::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawString* Field::GetterName(const String& field_name) {
   CompilerStats::make_accessor_name++;
   return String::Concat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
@@ skipping 451 matching lines @@
 }
 
 
 const char* LiteralToken::ToCString() const {
   const String& token = String::Handle(literal());
   return token.ToCString();
 }
 
 
 void LiteralToken::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawArray* TokenStream::TokenObjects() const {
   return raw_ptr()->token_objects_;
 }
 
 
 void TokenStream::SetTokenObjects(const Array& value) const {
   StorePointer(&raw_ptr()->token_objects_, value.raw());
@@ skipping 424 matching lines @@
   return result.raw();
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
 
 
 void TokenStream::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 TokenStream::Iterator::Iterator(const TokenStream& tokens,
                                 intptr_t token_pos,
                                 Iterator::StreamType stream_type)
     : tokens_(TokenStream::Handle(tokens.raw())),
       data_(ExternalTypedData::Handle(tokens.GetStream())),
       stream_(reinterpret_cast<uint8_t*>(data_.DataAddr(0)), data_.Length()),
       token_objects_(Array::Handle(tokens.TokenObjects())),
@@ skipping 1843 matching lines @@
   const char* kFormat = "LibraryPrefix:'%s'";
   const String& prefix = String::Handle(name());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, prefix.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, prefix.ToCString());
   return chars;
 }
 
 
 void LibraryPrefix::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 void Namespace::set_metadata_field(const Field& value) const {
   StorePointer(&raw_ptr()->metadata_field_, value.raw());
 }
 
 
 void Namespace::AddMetadata(intptr_t token_pos, const Class& owner_class) {
   ASSERT(Field::Handle(metadata_field()).IsNull());
@@ skipping 33 matching lines @@
   const char* kFormat = "Namespace for library '%s'";
   const Library& lib = Library::Handle(library());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, lib.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, lib.ToCString());
   return chars;
 }
 
 
 void Namespace::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 bool Namespace::HidesName(const String& name) const {
   // Quick check for common case with no combinators.
   if (hide_names() == show_names()) {
     ASSERT(hide_names() == Array::null());
     return false;
   }
   const String* plain_name = &name;
@@ skipping 245 matching lines @@
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
 
 
 void Instructions::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 intptr_t PcDescriptors::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 void PcDescriptors::SetLength(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
@@ skipping 133 matching lines @@
                          KindAsStr(i),
                          DeoptId(i),
                          TokenPos(i),
                          TryIndex(i));
   }
   return buffer;
 }
 
 
 void PcDescriptors::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same deoptimization id.
 // - No two ic-call descriptors have the same deoptimization id (type feedback).
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
 void PcDescriptors::Verify(const Function& function) const {
 #if defined(DEBUG)
@@ skipping 134 matching lines @@
     for (intptr_t i = 0; i < Length(); i++) {
       chars[index++] = IsObject(i) ? '1' : '0';
     }
     chars[index] = '\0';
     return chars;
   }
 }
 
 
 void Stackmap::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
   ASSERT(var_index < Length());
   const Array& names = Array::Handle(raw_ptr()->names_);
   ASSERT(Length() == names.Length());
   String& name = String::Handle();
   name ^= names.At(var_index);
   return name.raw();
@@ skipping 49 matching lines @@
                              info.begin_pos,
                              info.end_pos,
                              var_name.ToCString());
   }
   return buffer;
 }
 
 
 void LocalVarDescriptors::PrintToJSONStream(JSONStream* stream,
                                             bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
   ASSERT(Object::var_descriptors_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in LocalVarDescriptors::New: "
            "invalid num_variables %" Pd "\n", num_variables);
   }
@@ skipping 163 matching lines @@
                                (len - num_chars),
                                kFormat2, k, type.ToCString());
     }
   }
   return buffer;
 }
 
 
 void ExceptionHandlers::PrintToJSONStream(JSONStream* stream,
                                           bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 intptr_t DeoptInfo::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 intptr_t DeoptInfo::FromIndex(intptr_t index) const {
   return *(EntryAddr(index, kFromIndex));
@@ skipping 96 matching lines @@
   ToInstructions(deopt_table, &unpacked);
   ASSERT(unpacked.length() == original.length());
   for (intptr_t i = 0; i < unpacked.length(); ++i) {
     ASSERT(unpacked[i]->Equals(*original[i]));
   }
   return true;
 }
 
 
 void DeoptInfo::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawDeoptInfo* DeoptInfo::New(intptr_t num_commands) {
   ASSERT(Object::deopt_info_class() != Class::null());
   if ((num_commands < 0) || (num_commands > kMaxElements)) {
     FATAL1("Fatal error in DeoptInfo::New(): invalid num_commands %" Pd "\n",
            num_commands);
   }
   DeoptInfo& result = DeoptInfo::Handle();
@@ skipping 677 matching lines @@
     intptr_t len = OS::SNPrint(NULL, 0, kFormat,
                                num_variables(), parent_str) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, kFormat, num_variables(), parent_str);
     return chars;
   }
 }
 
 
 void Context::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawContextScope* ContextScope::New(intptr_t num_variables) {
   ASSERT(Object::context_scope_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ContextScope::New: invalid num_variables %" Pd "\n",
            num_variables);
   }
@@ skipping 98 matching lines @@
   VariableDescAddr(scope_index)->context_level = Smi::New(context_level);
 }
 
 
 const char* ContextScope::ToCString() const {
   return "ContextScope";
 }
 
 
 void ContextScope::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 const char* ICData::ToCString() const {
   const char* kFormat = "ICData target:'%s' num-args: %" Pd
                         " num-checks: %" Pd "";
   const String& name = String::Handle(target_name());
   const intptr_t num_args = num_args_tested();
   const intptr_t num_checks = NumberOfChecks();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString(),
@@ skipping 453 matching lines @@
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   result.WriteSentinel(ic_data);
   return result.raw();
 }
 
 
 void ICData::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawArray* MegamorphicCache::buckets() const {
   return raw_ptr()->buckets_;
 }
 
 
 void MegamorphicCache::set_buckets(const Array& buckets) const {
   StorePointer(&raw_ptr()->buckets_, buckets.raw());
@@ skipping 95 matching lines @@
   UNREACHABLE();
 }
 
 
 const char* MegamorphicCache::ToCString() const {
   return "";
 }
 
 
 void MegamorphicCache::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 RawSubtypeTestCache* SubtypeTestCache::New() {
   ASSERT(Object::subtypetestcache_class() != Class::null());
   SubtypeTestCache& result = SubtypeTestCache::Handle();
   {
     // SubtypeTestCache objects are long living objects, allocate them in the
     // old generation.
     RawObject* raw = Object::Allocate(SubtypeTestCache::kClassId,
@@ skipping 55 matching lines @@
   *test_result ^= data.At(data_pos + kTestResult);
 }
 
 
 const char* SubtypeTestCache::ToCString() const {
   return "SubtypeTestCache";
 }
 
 
 void SubtypeTestCache::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  Object::PrintToJSONStream(stream, ref);
 }
 
 
 const char* Error::ToErrorCString() const {
   UNREACHABLE();
   return "Internal Error";
 }
 
 
 const char* Error::ToCString() const {
@@ skipping 6249 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart