JSONStream Print Dart Objects

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 2673 matching lines @@
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, library_name, class_name) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, library_name, class_name);
   return chars;
 }
 
 
+void Class::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 void Class::InsertCanonicalConstant(intptr_t index,
                                     const Instance& constant) const {
   // The constant needs to be added to the list. Grow the list if it is full.
   Array& canonical_list = Array::Handle(constants());
   const intptr_t list_len = canonical_list.Length();
   if (index >= list_len) {
     const intptr_t new_length = (list_len == 0) ? 4 : list_len + 4;
     const Array& new_canonical_list =
         Array::Handle(Array::Grow(canonical_list, new_length, Heap::kOld));
     set_constants(new_canonical_list);
@@ skipping 59 matching lines @@
 const char* UnresolvedClass::ToCString() const {
   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 {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 intptr_t AbstractTypeArguments::Length() const  {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return -1;
 }
 
 
 RawAbstractType* AbstractTypeArguments::TypeAt(intptr_t index) const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
@@ skipping 212 matching lines @@
   // AbstractTypeArguments is an abstract class, valid only for representing
   // null.
   if (IsNull()) {
     return "NULL AbstractTypeArguments";
   }
   UNREACHABLE();
   return "AbstractTypeArguments";
 }
 
 
+void AbstractTypeArguments::PrintToJSONStream(JSONStream* stream,
+                                              bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 intptr_t TypeArguments::Length() const {
   ASSERT(!IsNull());
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
   return *TypeAddr(index);
 }
 
@@ skipping 315 matching lines @@
     const char* type_cstr = type_at.IsNull() ? "null" : type_at.ToCString();
     intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, prev_cstr, type_cstr);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
+void TypeArguments::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 intptr_t InstantiatedTypeArguments::Length() const {
   return AbstractTypeArguments::Handle(
       uninstantiated_type_arguments()).Length();
 }
 
 
 RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
   AbstractType& type = AbstractType::Handle(AbstractTypeArguments::Handle(
       uninstantiated_type_arguments()).TypeAt(index));
   if (!type.IsInstantiated()) {
@@ skipping 62 matching lines @@
   const char* instantiator_cstr =
       AbstractTypeArguments::Handle(instantiator_type_arguments()).ToCString();
   intptr_t len =
       OS::SNPrint(NULL, 0, format, arg_cstr, instantiator_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, arg_cstr, instantiator_cstr);
   return chars;
 }
 
 
+void InstantiatedTypeArguments::PrintToJSONStream(JSONStream* stream,
+                                                  bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 const char* PatchClass::ToCString() const {
   const char* kFormat = "PatchClass for %s";
   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 {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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();
 }
 
 
 RawPatchClass* PatchClass::New() {
@@ skipping 1293 matching lines @@
   const char* function_name = String::Handle(name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name,
                              static_str, abstract_str, kind_str, const_str) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name,
               static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
+void Function::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 void ClosureData::set_context_scope(const ContextScope& value) const {
   StorePointer(&raw_ptr()->context_scope_, value.raw());
 }
 
 
 void ClosureData::set_implicit_static_closure(const Instance& closure) const {
   ASSERT(!closure.IsNull());
   ASSERT(raw_ptr()->closure_ == Instance::null());
   StorePointer(&raw_ptr()->closure_, closure.raw());
 }
@@ skipping 23 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawClosureData*>(raw);
 }
 
 
 const char* ClosureData::ToCString() const {
   return "ClosureData class";
 }
 
 
+void ClosureData::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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 {
   StorePointer(&raw_ptr()->identifier_, value.raw());
 }
 
@@ skipping 10 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawRedirectionData*>(raw);
 }
 
 
 const char* RedirectionData::ToCString() const {
   return "RedirectionData class";
 }
 
 
+void RedirectionData::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawString* Field::GetterName(const String& field_name) {
   return String::Concat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   const String& str = String::Handle(Field::GetterName(field_name));
   return Symbols::New(str);
 }
 
@@ skipping 143 matching lines @@
   const Class& cls = Class::Handle(owner());
   const char* cls_name = String::Handle(cls.Name()).ToCString();
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, cls_name, field_name, kF0, kF1, kF2) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name, field_name, kF0, kF1, kF2);
   return chars;
 }
 
 
+void Field::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawArray* Field::dependent_code() const {
   return raw_ptr()->dependent_code_;
 }
 
 
 void Field::set_dependent_code(const Array& array) const {
   raw_ptr()->dependent_code_ = array.raw();
 }
 
 
@@ skipping 155 matching lines @@
   return result.raw();
 }
 
 
 const char* LiteralToken::ToCString() const {
   const String& token = String::Handle(literal());
   return token.ToCString();
 }
 
 
+void LiteralToken::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawArray* TokenStream::TokenObjects() const {
   return raw_ptr()->token_objects_;
 }
 
 
 void TokenStream::SetTokenObjects(const Array& value) const {
   StorePointer(&raw_ptr()->token_objects_, value.raw());
 }
 
 
@@ skipping 390 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
 
 
+void TokenStream::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 TokenStream::Iterator::Iterator(const TokenStream& tokens, intptr_t token_pos)
     : 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())),
       obj_(Object::Handle()),
       cur_token_pos_(token_pos),
       cur_token_kind_(Token::kILLEGAL),
       cur_token_obj_index_(-1) {
   SetCurrentPosition(token_pos);
@@ skipping 326 matching lines @@
   result.SetLocationOffset(0, 0);
   return result.raw();
 }
 
 
 const char* Script::ToCString() const {
   return "Script";
 }
 
 
+void Script::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 DictionaryIterator::DictionaryIterator(const Library& library)
     : array_(Array::Handle(library.dictionary())),
       // Last element in array is a Smi.
       size_(Array::Handle(library.dictionary()).Length() - 1),
       next_ix_(0) {
   MoveToNextObject();
 }
 
 
 RawObject* DictionaryIterator::GetNext() {
@@ skipping 970 matching lines @@
 const char* Library::ToCString() const {
   const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
+void Library::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
   if ((index >= 0) || (index < num_imports())) {
     const Array& imports = Array::Handle(this->imports());
     Namespace& import = Namespace::Handle();
     import ^= imports.At(index);
     return import.library();
   }
   return Library::null();
 }
 
@@ skipping 89 matching lines @@
 const char* LibraryPrefix::ToCString() const {
   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 {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 const char* Namespace::ToCString() const {
   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 {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 bool Namespace::HidesName(const String& name) const {
   // Check whether the name is in the list of explicitly hidden names.
   if (hide_names() != Array::null()) {
     const Array& names = Array::Handle(hide_names());
     String& hidden = String::Handle();
     intptr_t num_names = names.Length();
     for (intptr_t i = 0; i < num_names; i++) {
       hidden ^= names.At(i);
       if (name.Equals(hidden)) {
         return true;
@@ skipping 189 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
 
 
+void Instructions::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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
   // heap allocation.
   raw_ptr()->length_ = Smi::New(value);
 }
@@ skipping 129 matching lines @@
                          PC(i),
                          KindAsStr(i),
                          DeoptId(i),
                          TokenPos(i),
                          TryIndex(i));
   }
   return buffer;
 }
 
 
+void PcDescriptors::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 // 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)
   // TODO(srdjan): Implement a more efficient way to check, currently drop
   // the check for too large number of descriptors.
   if (Length() > 3000) {
@@ skipping 131 matching lines @@
     intptr_t index = OS::SNPrint(chars, alloc_size, kFormat, PC());
     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 {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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 44 matching lines @@
                              info.kind,
                              info.scope_id,
                              info.begin_pos,
                              info.end_pos,
                              var_name.ToCString());
   }
   return buffer;
 }
 
 
+void LocalVarDescriptors::PrintToJSONStream(JSONStream* stream,
+                                            bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
@@ skipping 143 matching lines @@
       type ^= handled_types.At(k);
       num_chars += OS::SNPrint((buffer + num_chars),
                                (len - num_chars),
                                kFormat2, k, type.ToCString());
     }
   }
   return buffer;
 }
 
 
+void ExceptionHandlers::PrintToJSONStream(JSONStream* stream,
+                                          bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 intptr_t DeoptInfo::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 intptr_t DeoptInfo::FromIndex(intptr_t index) const {
   return *(EntryAddr(index, kFromIndex));
 }
 
 
@@ skipping 73 matching lines @@
   for (intptr_t i = 0; i < Length(); i++) {
     index += OS::SNPrint((buffer + index),
                          (len - index),
                          "[%s]",
                          deopt_instrs[i]->ToCString());
   }
   return buffer;
 }
 
 
+void DeoptInfo::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawDeoptInfo* DeoptInfo::New(intptr_t num_commands) {
   ASSERT(Object::deopt_info_class() != Class::null());
   DeoptInfo& result = DeoptInfo::Handle();
   {
     uword size = DeoptInfo::InstanceSize(num_commands);
     RawObject* raw = Object::Allocate(DeoptInfo::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
@@ skipping 343 matching lines @@
 
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:%p";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, EntryPoint()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, EntryPoint());
   return chars;
 }
 
 
+void Code::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 uword Code::GetPatchCodePc() const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   return descriptors.GetPcForKind(PcDescriptors::kPatchCode);
 }
 
 
 uword Code::GetLazyDeoptPc() const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   return descriptors.GetPcForKind(PcDescriptors::kLazyDeoptJump);
 }
@@ skipping 106 matching lines @@
   result.set_isolate(Isolate::Current());
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   return "Context";
 }
 
 
+void Context::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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);
   }
   intptr_t size = ContextScope::InstanceSize(num_variables);
   ContextScope& result = ContextScope::Handle();
   {
@@ skipping 94 matching lines @@
                                      intptr_t context_level) const {
   VariableDescAddr(scope_index)->context_level = Smi::New(context_level);
 }
 
 
 const char* ContextScope::ToCString() const {
   return "ContextScope";
 }
 
 
+void ContextScope::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 const char* ICData::ToCString() const {
   const char* kFormat = "ICData target:'%s' num-checks: %"Pd"";
   const String& name = String::Handle(target_name());
   const intptr_t num = NumberOfChecks();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString(), num) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString(), num);
   return chars;
 }
 
@@ skipping 393 matching lines @@
   // Number of array elements in one test entry.
   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 {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawArray* MegamorphicCache::buckets() const {
   return raw_ptr()->buckets_;
 }
 
 
 void MegamorphicCache::set_buckets(const Array& buckets) const {
   StorePointer(&raw_ptr()->buckets_, buckets.raw());
 }
 
 
@@ skipping 91 matching lines @@
   } while (i != index);
   UNREACHABLE();
 }
 
 
 const char* MegamorphicCache::ToCString() const {
   return "";
 }
 
 
+void MegamorphicCache::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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,
                                       SubtypeTestCache::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
@@ skipping 51 matching lines @@
       data.At(data_pos + kInstantiatorTypeArguments);
   *test_result ^= data.At(data_pos + kTestResult);
 }
 
 
 const char* SubtypeTestCache::ToCString() const {
   return "SubtypeTestCache";
 }
 
 
+void SubtypeTestCache::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 const char* Error::ToErrorCString() const {
   UNREACHABLE();
   return "Internal Error";
 }
 
 
 const char* Error::ToCString() const {
   // Error is an abstract class.  We should never reach here.
   UNREACHABLE();
   return "Error";
 }
 
 
+void Error::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawApiError* ApiError::New() {
   ASSERT(Object::api_error_class() != Class::null());
   RawObject* raw = Object::Allocate(ApiError::kClassId,
                                     ApiError::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawApiError*>(raw);
 }
 
 
 RawApiError* ApiError::New(const String& message, Heap::Space space) {
@@ skipping 20 matching lines @@
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* ApiError::ToCString() const {
   return "ApiError";
 }
 
 
+void ApiError::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawLanguageError* LanguageError::New() {
   ASSERT(Object::language_error_class() != Class::null());
   RawObject* raw = Object::Allocate(LanguageError::kClassId,
                                     LanguageError::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLanguageError*>(raw);
 }
 
 
 RawLanguageError* LanguageError::New(const String& message, Heap::Space space) {
@@ skipping 20 matching lines @@
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* LanguageError::ToCString() const {
   return "LanguageError";
 }
 
 
+void LanguageError::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
     RawObject* raw = Object::Allocate(UnhandledException::kClassId,
                                       UnhandledException::InstanceSize(),
                                       space);
     NoGCScope no_gc;
@@ skipping 48 matching lines @@
   OS::SNPrint(chars, len, format, exc_str, stack_str);
   return chars;
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
+void UnhandledException::PrintToJSONStream(JSONStream* stream,
+                                           bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawUnwindError* UnwindError::New(const String& message, Heap::Space space) {
   ASSERT(Object::unwind_error_class() != Class::null());
   UnwindError& result = UnwindError::Handle();
   {
     RawObject* raw = Object::Allocate(UnwindError::kClassId,
                                       UnwindError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
@@ skipping 11 matching lines @@
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* UnwindError::ToCString() const {
   return "UnwindError";
 }
 
 
+void UnwindError::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 bool Instance::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
 
   if (other.IsNull() || (this->clazz() != other.clazz())) {
     return false;
   }
 
   {
@@ skipping 300 matching lines @@
     const String& type_name = String::Handle(type.Name());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
 
+void Instance::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 bool AbstractType::IsResolved() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 bool AbstractType::HasResolvedTypeClass() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
@@ skipping 319 matching lines @@
 }
 
 
 const char* AbstractType::ToCString() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return "AbstractType";
 }
 
 
+void AbstractType::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
 RawType* Type::DynamicType() {
   return Isolate::Current()->object_store()->dynamic_type();
 }
 
 
@@ skipping 371 matching lines @@
       char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
       OS::SNPrint(chars, len, format, class_name, args_cstr);
       return chars;
     }
   } else {
     return "Unresolved Type";
   }
 }
 
 
+void Type::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 void TypeParameter::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
 bool TypeParameter::Equals(const Instance& other) const {
   if (raw() == other.raw()) {
     return true;
   }
@@ skipping 158 matching lines @@
   const Class& cls = Class::Handle(parameterized_class());
   const char* cls_cstr =
       cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, index(), cls_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr);
   return chars;
 }
 
 
+void TypeParameter::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 bool BoundedType::IsMalformed() const {
   return FLAG_enable_type_checks && AbstractType::Handle(bound()).IsMalformed();
 }
 
 
 RawError* BoundedType::malformed_error() const {
   ASSERT(FLAG_enable_type_checks);
   return AbstractType::Handle(bound()).malformed_error();
 }
 
@@ skipping 128 matching lines @@
   const char* cls_cstr =
       cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, type_cstr, bound_cstr, cls_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, type_cstr, bound_cstr, cls_cstr);
   return chars;
 }
 
 
+void BoundedType::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
 
 RawString* MixinAppType::Name() const {
   return String::New("MixinApplication");
 }
 
 
 const char* MixinAppType::ToCString() const {
   return "MixinAppType";
 }
 
 
+void MixinAppType::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 void MixinAppType::set_super_type(const AbstractType& value) const {
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
 void MixinAppType::set_mixin_types(const Array& value) const {
   StorePointer(&raw_ptr()->mixin_types_, value.raw());
 }
 
 
@@ skipping 18 matching lines @@
 }
 
 
 const char* Number::ToCString() const {
   // Number is an interface. No instances of Number should exist.
   UNREACHABLE();
   return "Number";
 }
 
 
+void Number::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 const char* Integer::ToCString() const {
   // Integer is an interface. No instances of Integer should exist.
   UNREACHABLE();
   return "Integer";
 }
 
 
+void Integer::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 // Throw FiftyThreeBitOverflow exception.
 static void ThrowFiftyThreeBitOverflow(const Integer& i) {
   const Array& exc_args = Array::Handle(Array::New(1));
   const String& i_str = String::Handle(String::New(i.ToCString()));
   exc_args.SetAt(0, i_str);
   Exceptions::ThrowByType(Exceptions::kFiftyThreeBitOverflowError, exc_args);
 }
 
 
 RawInteger* Integer::New(const String& str, Heap::Space space) {
@@ skipping 380 matching lines @@
 const char* Smi::ToCString() const {
   const char* kFormat = "%ld";
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, Value()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, Value());
   return chars;
 }
 
 
+void Smi::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawClass* Smi::Class() {
   return Isolate::Current()->object_store()->smi_class();
 }
 
 
 void Mint::set_value(int64_t value) const {
   raw_ptr()->value_ = value;
 }
 
 
@@ skipping 94 matching lines @@
 const char* Mint::ToCString() const {
   const char* kFormat = "%lld";
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, value()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, value());
   return chars;
 }
 
 
+void Mint::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 void Double::set_value(double value) const {
   raw_ptr()->value_ = value;
 }
 
 
 bool Double::EqualsToDouble(double value) const {
   intptr_t value_offset = Double::value_offset();
   void* this_addr = reinterpret_cast<void*>(
       reinterpret_cast<uword>(this->raw_ptr()) + value_offset);
   void* other_addr = reinterpret_cast<void*>(&value);
@@ skipping 81 matching lines @@
     return value() < 0 ? "-Infinity" : "Infinity";
   }
   const int kBufferSize = 128;
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(kBufferSize);
   buffer[kBufferSize - 1] = '\0';
   DoubleToCString(value(), buffer, kBufferSize);
   return buffer;
 }
 
 
+void Double::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawBigint* Integer::AsBigint() const {
   ASSERT(!IsNull());
   if (IsSmi()) {
     Smi& smi = Smi::Handle();
     smi ^= raw();
     return BigintOperations::NewFromSmi(smi);
   } else if (IsMint()) {
     Mint& mint = Mint::Handle();
     mint ^= raw();
     return BigintOperations::NewFromInt64(mint.value());
@@ skipping 146 matching lines @@
   Zone* zone = Isolate::Current()->current_zone();
   return zone->AllocUnsafe(size);
 }
 
 
 const char* Bigint::ToCString() const {
   return BigintOperations::ToDecimalCString(*this, &BigintAllocator);
 }
 
 
+void Bigint::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 // Synchronize with implementation in compiler (intrinsifier).
 class StringHasher : ValueObject {
  public:
   StringHasher() : hash_(0) {}
   void Add(int32_t ch) {
     hash_ += ch;
     hash_ += hash_ << 10;
     hash_ ^= hash_ >> 6;
   }
   // Return a non-zero hash of at most 'bits' bits.
@@ skipping 578 matching lines @@
   }
   const intptr_t len = Utf8::Length(*this);
   Zone* zone = Isolate::Current()->current_zone();
   uint8_t* result = zone->Alloc<uint8_t>(len + 1);
   ToUTF8(result, len);
   result[len] = 0;
   return reinterpret_cast<const char*>(result);
 }
 
 
+void String::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 void String::ToUTF8(uint8_t* utf8_array, intptr_t array_len) const {
   ASSERT(array_len >= Utf8::Length(*this));
   Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
 }
 
 
 static FinalizablePersistentHandle* AddFinalizer(
     const Object& referent,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
@@ skipping 660 matching lines @@
   result.SetCanonical();
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
   return value() ? "true" : "false";
 }
 
 
+void Bool::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 bool Array::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsArray() || other.IsNull()) {
     return false;
   }
 
@@ skipping 58 matching lines @@
   }
   const char* format = !IsImmutable() ? "Array len:%"Pd"" :
       "Immutable 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;
 }
 
 
+void Array::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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()));
   }
   ASSERT(new_length >= len);  // Cannot copy 'source' into new array.
   ASSERT(new_length != len);  // Unnecessary copying of array.
@@ skipping 185 matching lines @@
     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;
 }
 
 
+void GrowableObjectArray::PrintToJSONStream(JSONStream* stream,
+                                            bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 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,
                                       Float32x4::InstanceSize(),
                                       space);
     NoGCScope no_gc;
@@ skipping 80 matching lines @@
   float _z = z();
   float _w = w();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
+void Float32x4::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawUint32x4* Uint32x4::New(uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3,
                            Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->uint32x4_class() !=
          Class::null());
   Uint32x4& result = Uint32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Uint32x4::kClassId,
                                       Uint32x4::InstanceSize(),
                                       space);
     NoGCScope no_gc;
@@ skipping 80 matching lines @@
   uint32_t _z = z();
   uint32_t _w = w();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
+void Uint32x4::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 const intptr_t TypedData::element_size[] = {
   1,   // kTypedDataInt8ArrayCid.
   1,   // kTypedDataUint8ArrayCid.
   1,   // kTypedDataUint8ClampedArrayCid.
   2,   // kTypedDataInt16ArrayCid.
   2,   // kTypedDataUint16ArrayCid.
   4,   // kTypedDataInt32ArrayCid.
   4,   // kTypedDataUint32ArrayCid.
   8,   // kTypedDataInt64ArrayCid.
   8,   // kTypedDataUint64ArrayCid.
@@ skipping 26 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* TypedData::ToCString() const {
   return "TypedData";
 }
 
 
+void TypedData::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 FinalizablePersistentHandle* ExternalTypedData::AddFinalizer(
     void* peer, Dart_WeakPersistentHandleFinalizer callback) const {
   SetPeer(peer);
   return dart::AddFinalizer(*this, peer, callback);
 }
 
 
 RawExternalTypedData* ExternalTypedData::New(intptr_t class_id,
                                              uint8_t* data,
                                              intptr_t len,
@@ skipping 10 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* ExternalTypedData::ToCString() const {
   return "ExternalTypedData";
 }
 
 
+void ExternalTypedData::PrintToJSONStream(JSONStream* stream,
+                                          bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
+
 const char* Closure::ToCString(const Instance& closure) {
   const Function& fun = Function::Handle(Closure::function(closure));
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.UserVisibleSignature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
   const char* format = "Closure: %s%s%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, fun_sig, from, fun_desc);
@@ skipping 19 matching lines @@
   Closure::set_context(result, context);
   return result.raw();
 }
 
 
 const char* DartFunction::ToCString() const {
   return "Function type class";
 }
 
 
+void DartFunction::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 intptr_t Stacktrace::Length() const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return code_array.Length();
 }
 
 
 RawFunction* Stacktrace::FunctionAtFrame(intptr_t frame_index) const {
   const Array& function_array = Array::Handle(raw_ptr()->function_array_);
   return reinterpret_cast<RawFunction*>(function_array.At(frame_index));
 }
@@ skipping 146 matching lines @@
   return String::New(ToCStringInternal(0));
 }
 
 
 const char* Stacktrace::ToCString() const {
   const String& trace = String::Handle(FullStacktrace());
   return trace.ToCString();
 }
 
 
+void Stacktrace::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 const char* Stacktrace::ToCStringInternal(intptr_t frame_index) const {
   Isolate* isolate = Isolate::Current();
   Function& function = Function::Handle();
   Code& code = Code::Handle();
   Script& script = Script::Handle();
   String& function_name = String::Handle();
   String& url = String::Handle();
 
   // Iterate through the stack frames and create C string description
   // for each frame.
@@ skipping 146 matching lines @@
 const char* JSRegExp::ToCString() const {
   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 = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 
+void JSRegExp::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 RawWeakProperty* WeakProperty::New(Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->weak_property_class()
          != Class::null());
   RawObject* raw = Object::Allocate(WeakProperty::kClassId,
                                     WeakProperty::InstanceSize(),
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 
+void WeakProperty::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
 RawMirrorReference* MirrorReference::New(Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->mirror_reference_class()
          != Class::null());
   RawObject* raw = Object::Allocate(MirrorReference::kClassId,
                                     MirrorReference::InstanceSize(),
                                     space);
   return reinterpret_cast<RawMirrorReference*>(raw);
 }
 
 
 const char* MirrorReference::ToCString() const {
   return "_MirrorReference";
 }
 
 
+void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  stream->OpenObject();
+  stream->CloseObject();
+}
+
+
 }  // namespace dart