- Base JSON stream printing on stack 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 46 matching lines @@
     "Throw an exception when the result of an integer calculation will not "
     "fit into a javascript integer.");
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, error_on_bad_override);
 DECLARE_FLAG(bool, error_on_bad_type);
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, trace_deoptimization);
 DECLARE_FLAG(bool, trace_deoptimization_verbose);
 DECLARE_FLAG(bool, verbose_stacktrace);
+DECLARE_FLAG(bool, print_coverage);
 
 static const char* kGetterPrefix = "get:";
 static const intptr_t kGetterPrefixLength = strlen(kGetterPrefix);
 static const char* kSetterPrefix = "set:";
 static const intptr_t kSetterPrefixLength = strlen(kSetterPrefix);
 
 cpp_vtable Object::handle_vtable_ = 0;
 cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = { 0 };
 cpp_vtable Smi::handle_vtable_ = 0;
 
@@ skipping 2834 matching lines @@
   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 {
   const char* class_name = String::Handle(UserVisibleName()).ToCString();
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   intptr_t id = ring->GetIdForObject(raw());
-  if (ref) {
-    stream->OpenObject();
-    stream->PrintProperty("type", "@Class");
-    stream->PrintProperty("id", id);
-    stream->PrintProperty("name", class_name);
-    stream->CloseObject();
-    return;
+  JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(ref));
+  jsobj.AddProperty("id", id);
+  jsobj.AddProperty("name", class_name);
+  if (!ref) {
+    jsobj.AddProperty("library", Object::Handle(library()));
   }
-  stream->OpenObject();
-  stream->PrintProperty("type", "Class");
-  stream->PrintProperty("id", id);
-  stream->PrintProperty("name", class_name);
-  stream->PrintProperty("library", Object::Handle(library()));
-  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;
@@ skipping 63 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 intptr_t AbstractTypeArguments::Length() const  {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return -1;
 }
 
 
@@ skipping 202 matching lines @@
   if (IsNull()) {
     return "NULL AbstractTypeArguments";
   }
   UNREACHABLE();
   return "AbstractTypeArguments";
 }
 
 
 void AbstractTypeArguments::PrintToJSONStream(JSONStream* stream,
                                               bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 intptr_t TypeArguments::Length() const {
   ASSERT(!IsNull());
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
@@ skipping 319 matching lines @@
     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();
+  JSONObject jsobj(stream);
 }
 
 
 intptr_t InstantiatedTypeArguments::Length() const {
   return AbstractTypeArguments::Handle(
       uninstantiated_type_arguments()).Length();
 }
 
 
 RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
@@ skipping 67 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 
 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 426 matching lines @@
 void Function::SetNumOptionalParameters(intptr_t num_optional_parameters,
                                         bool are_optional_positional) const {
   ASSERT(num_optional_parameters >= 0);
   set_num_optional_parameters(are_optional_positional ?
                               num_optional_parameters :
                               -num_optional_parameters);
 }
 
 
 bool Function::is_optimizable() const {
+  if (FLAG_print_coverage) {
+    return false;
+  }
   if (OptimizableBit::decode(raw_ptr()->kind_tag_) &&
       (script() != Script::null()) &&
       ((end_token_pos() - token_pos()) < FLAG_huge_method_cutoff_in_tokens)) {
     // Additional check needed for implicit getters.
     if (HasCode() &&
        (Code::Handle(unoptimized_code()).Size() >=
         FLAG_huge_method_cutoff_in_code_size)) {
       return false;
     } else {
       return true;
@@ skipping 938 matching lines @@
               static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
 void Function::PrintToJSONStream(JSONStream* stream, bool ref) const {
   const char* function_name =
       String::Handle(QualifiedUserVisibleName()).ToCString();
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   intptr_t id = ring->GetIdForObject(raw());
-  if (ref) {
-    stream->OpenObject();
-    stream->PrintProperty("type", "@Function");
-    stream->PrintProperty("id", id);
-    stream->PrintProperty("name", function_name);
-    stream->CloseObject();
-    return;
-  }
-  stream->OpenObject();
-  stream->PrintProperty("type", "Function");
-  stream->PrintProperty("name", function_name);
-  stream->PrintProperty("id", id);
-  stream->PrintPropertyBool("is_static", is_static());
-  stream->PrintPropertyBool("is_const", is_const());
-  stream->PrintPropertyBool("is_optimizable", is_optimizable());
-  stream->PrintPropertyBool("is_inlinable", IsInlineable());
+  JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(ref));
+  jsobj.AddProperty("id", id);
+  jsobj.AddProperty("name", function_name);
+  if (ref) return;
+  jsobj.AddProperty("is_static", is_static());
+  jsobj.AddProperty("is_const", is_const());
+  jsobj.AddProperty("is_optimizable", is_optimizable());
+  jsobj.AddProperty("is_inlinable", IsInlineable());
   const char* kind_string = NULL;
   switch (kind()) {
       case RawFunction::kRegularFunction:
         kind_string = "regular";
         break;
       case RawFunction::kGetterFunction:
         kind_string = "getter";
         break;
       case RawFunction::kSetterFunction:
         kind_string = "setter";
@@ skipping 15 matching lines @@
         break;
       case RawFunction::kConstructor:
         kind_string = "constructor";
         break;
       case RawFunction::kImplicitStaticFinalGetter:
         kind_string = "static final getter";
         break;
       default:
         UNREACHABLE();
   }
-  stream->PrintProperty("kind", kind_string);
-  stream->PrintProperty("unoptimized_code", Object::Handle(unoptimized_code()));
-  stream->PrintProperty("usage_counter", usage_counter());
-  stream->PrintProperty("optimized_call_site_count",
-                        optimized_call_site_count());
-  stream->PrintProperty("code", Object::Handle(CurrentCode()));
-  stream->PrintProperty("deoptimizations",
-                        static_cast<intptr_t>(deoptimization_counter()));
-  stream->CloseObject();
+  jsobj.AddProperty("kind", kind_string);
+  jsobj.AddProperty("unoptimized_code", Object::Handle(unoptimized_code()));
+  jsobj.AddProperty("usage_counter", usage_counter());
+  jsobj.AddProperty("optimized_call_site_count", optimized_call_site_count());
+  jsobj.AddProperty("code", Object::Handle(CurrentCode()));
+  jsobj.AddProperty("deoptimizations",
+                    static_cast<intptr_t>(deoptimization_counter()));
 }
 
 
 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());
@@ skipping 27 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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));
@@ skipping 163 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 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 201 matching lines @@
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 
 RawArray* TokenStream::TokenObjects() const {
   return raw_ptr()->token_objects_;
 }
 
 
 void TokenStream::SetTokenObjects(const Array& value) const {
   StorePointer(&raw_ptr()->token_objects_, value.raw());
@@ skipping 394 matching lines @@
   return result.raw();
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
 
 
 void TokenStream::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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),
@@ skipping 330 matching lines @@
   return result.raw();
 }
 
 
 const char* Script::ToCString() const {
   return "Script";
 }
 
 
 void Script::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 DictionaryIterator::DictionaryIterator(const Library& library)
     : array_(Array::Handle(library.dictionary())),
       // Last element in array is a Smi indicating the number of entries used.
       size_(Array::Handle(library.dictionary()).Length() - 1),
       next_ix_(0) {
   MoveToNextObject();
 }
@@ skipping 1015 matching lines @@
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
 void Library::PrintToJSONStream(JSONStream* stream, bool ref) const {
   const char* library_name = String::Handle(name()).ToCString();
   const char* library_url = String::Handle(url()).ToCString();
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   intptr_t id = ring->GetIdForObject(raw());
-  if (ref) {
-    // Print a reference
-    stream->OpenObject();
-    stream->PrintProperty("type", "@Library");
-    stream->PrintProperty("id", id);
-    stream->PrintProperty("name", library_name);
-    stream->CloseObject();
-    return;
+  JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(ref));
+  jsobj.AddProperty("id", id);
+  jsobj.AddProperty("name", library_name);
+  if (ref) return;
+  jsobj.AddProperty("url", library_url);
+  {
+    JSONArray jsarr(jsobj, "classes");
+    ClassDictionaryIterator class_iter(*this);
+    Class& klass = Class::Handle();
+    while (class_iter.HasNext()) {
+      klass = class_iter.GetNextClass();
+      jsarr.AddValue(klass);
+    }
   }
-  stream->OpenObject();
-  stream->PrintProperty("type", "Library");
-  stream->PrintProperty("id", id);
-  stream->PrintProperty("name", library_name);
-  stream->PrintProperty("url", library_url);
-  ClassDictionaryIterator class_iter(*this);
-  stream->OpenArray("classes");
-  Class& klass = Class::Handle();
-  while (class_iter.HasNext()) {
-    klass = class_iter.GetNextClass();
-    stream->PrintValue(klass);
+  {
+    JSONArray jsarr(jsobj, "libraries");
+    Library& lib = Library::Handle();
+    for (intptr_t i = 0; i < num_imports(); i++) {
+      lib = ImportLibraryAt(i);
+      jsarr.AddValue(lib);
+    }
   }
-  stream->CloseArray();
-  stream->OpenArray("libraries");
-  Library& lib = Library::Handle();
-  for (intptr_t i = 0; i < num_imports(); i++) {
-    lib = ImportLibraryAt(i);
-    stream->PrintValue(lib);
-  }
-  stream->CloseArray();
-  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();
   }
@@ skipping 124 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 
 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 243 matching lines @@
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
 
 
 void Instructions::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 // 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 intptr_t DeoptInfo::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 intptr_t DeoptInfo::FromIndex(intptr_t index) const {
   return *(EntryAddr(index, kFromIndex));
@@ skipping 77 matching lines @@
     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();
+  JSONObject jsobj(stream);
 }
 
 
 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 374 matching lines @@
   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 {
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   intptr_t id = ring->GetIdForObject(raw());
+  JSONObject jsobj(stream);
   if (ref) {
-    stream->OpenObject();
-    stream->PrintProperty("type", "@Code");
-    stream->PrintProperty("id", id);
-    stream->CloseObject();
+    jsobj.AddProperty("type", "@Code");
+    jsobj.AddProperty("id", id);
     return;
   }
-  stream->OpenObject();
-  stream->PrintProperty("type", "Code");
-  stream->PrintProperty("id", id);
-  stream->PrintPropertyBool("is_optimized", is_optimized());
-  stream->PrintPropertyBool("is_alive", is_alive());
-  stream->PrintProperty("function", Object::Handle(function()));
-  stream->OpenArray("disassembly");
-  DisassembleToJSONStream formatter(stream);
+  jsobj.AddProperty("type", "Code");
+  jsobj.AddProperty("id", id);
+  jsobj.AddProperty("is_optimized", is_optimized());
+  jsobj.AddProperty("is_alive", is_alive());
+  jsobj.AddProperty("function", Object::Handle(function()));
+  JSONArray jsarr(jsobj, "disassembly");
+  DisassembleToJSONStream formatter(jsarr);
   const Instructions& instr = Instructions::Handle(instructions());
   uword start = instr.EntryPoint();
   Disassembler::Disassemble(start, start + instr.size(), &formatter,
                             comments());
-  stream->CloseArray();
-  stream->CloseObject();
 }
 
 
 uword Code::GetPatchCodePc() const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   return descriptors.GetPcForKind(PcDescriptors::kPatchCode);
 }
 
 
 uword Code::GetLazyDeoptPc() const {
@@ skipping 110 matching lines @@
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   return "Context";
 }
 
 
 void Context::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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 451 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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 {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 
 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);
 }
@@ skipping 24 matching lines @@
   return msg_str.ToCString();
 }
 
 
 const char* ApiError::ToCString() const {
   return "ApiError";
 }
 
 
 void ApiError::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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);
 }
@@ skipping 24 matching lines @@
   return msg_str.ToCString();
 }
 
 
 const char* LanguageError::ToCString() const {
   return "LanguageError";
 }
 
 
 void LanguageError::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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,
@@ skipping 53 matching lines @@
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
 void UnhandledException::PrintToJSONStream(JSONStream* stream,
                                            bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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);
@@ skipping 15 matching lines @@
   return msg_str.ToCString();
 }
 
 
 const char* UnwindError::ToCString() const {
   return "UnwindError";
 }
 
 
 void UnwindError::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 RawObject* Instance::Evaluate(const String& expr) const {
   const Class& cls = Class::Handle(clazz());
   const PatchClass& temp_class =
       PatchClass::Handle(MakeTempPatchClass(cls, expr));
   const String& eval_func_name = String::Handle(Symbols::New(":eval"));
   const Function& eval_func =
       Function::Handle(Function::New(eval_func_name,
@@ skipping 333 matching lines @@
     // 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();
+  JSONObject jsobj(stream);
 }
 
 
 bool AbstractType::IsResolved() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
@@ skipping 337 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();
+  JSONObject jsobj(stream);
 }
 
 
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
 RawType* Type::DynamicType() {
   return Object::dynamic_type();
@@ skipping 426 matching lines @@
       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();
+  JSONObject jsobj(stream);
 }
 
 
 void TypeParameter::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
 bool TypeParameter::Equals(const Instance& other) const {
@@ skipping 166 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 bool BoundedType::IsMalformed() const {
   return AbstractType::Handle(type()).IsMalformed();
 }
 
 
 bool BoundedType::IsMalboundedWithError(Error* bound_error) const {
   if (!FLAG_enable_type_checks && !FLAG_error_on_bad_type) {
@@ skipping 147 matching lines @@
       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();
+  JSONObject jsobj(stream);
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 
 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 22 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();
+  JSONObject jsobj(stream);
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 
 // Throw JavascriptIntegerOverflow exception.
 static void ThrowJavascriptIntegerOverflow(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::kJavascriptIntegerOverflowError,
       exc_args);
@@ skipping 397 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 RawClass* Smi::Class() {
   return Isolate::Current()->object_store()->smi_class();
 }
 
 
 void Mint::set_value(int64_t value) const {
   raw_ptr()->value_ = value;
@@ skipping 98 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 void Double::set_value(double value) const {
   raw_ptr()->value_ = value;
 }
 
 
 bool Double::EqualsToDouble(double value) const {
   intptr_t value_offset = Double::value_offset();
@@ skipping 85 matching lines @@
   }
   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();
+  JSONObject jsobj(stream);
 }
 
 
 RawBigint* Integer::AsBigint() const {
   ASSERT(!IsNull());
   if (IsSmi()) {
     Smi& smi = Smi::Handle();
     smi ^= raw();
     return BigintOperations::NewFromSmi(smi);
   } else if (IsMint()) {
@@ skipping 150 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 // Synchronize with implementation in compiler (intrinsifier).
 class StringHasher : ValueObject {
  public:
   StringHasher() : hash_(0) {}
   void Add(int32_t ch) {
     hash_ += ch;
     hash_ += hash_ << 10;
@@ skipping 582 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();
+  JSONObject jsobj(stream);
 }
 
 
 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(
@@ skipping 700 matching lines @@
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
   return value() ? "true" : "false";
 }
 
 
 void Bool::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 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()) {
@@ skipping 62 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();
+  JSONObject jsobj(stream);
 }
 
 
 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 190 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 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 84 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 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,
@@ skipping 84 matching lines @@
   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();
+  JSONObject jsobj(stream);
 }
 
 
 const intptr_t TypedData::element_size[] = {
   1,   // kTypedDataInt8ArrayCid.
   1,   // kTypedDataUint8ArrayCid.
   1,   // kTypedDataUint8ClampedArrayCid.
   2,   // kTypedDataInt16ArrayCid.
   2,   // kTypedDataUint16ArrayCid.
   4,   // kTypedDataInt32ArrayCid.
@@ skipping 28 matching lines @@
   return result.raw();
 }
 
 
 const char* TypedData::ToCString() const {
   return "TypedData";
 }
 
 
 void TypedData::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 FinalizablePersistentHandle* ExternalTypedData::AddFinalizer(
     void* peer, Dart_WeakPersistentHandleFinalizer callback) const {
   SetPeer(peer);
   return dart::AddFinalizer(*this, peer, callback);
 }
 
 
@@ skipping 15 matching lines @@
 }
 
 
 const char* ExternalTypedData::ToCString() const {
   return "ExternalTypedData";
 }
 
 
 void ExternalTypedData::PrintToJSONStream(JSONStream* stream,
                                           bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 
 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() : "";
@@ skipping 166 matching lines @@
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 
 static intptr_t PrintOneStacktrace(Isolate* isolate,
                                    GrowableArray<char*>* frame_strings,
                                    uword pc,
                                    const Function& function,
                                    const Code& code,
                                    intptr_t frame_index) {
   const char* kFormat = "#%-6d %s (%s:%d:%d)\n";
@@ skipping 176 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 = 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();
+  JSONObject jsobj(stream);
 }
 
 
 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();
+  JSONObject jsobj(stream);
 }
 
 RawAbstractType* MirrorReference::GetAbstractTypeReferent() const {
   ASSERT(Object::Handle(referent()).IsAbstractType());
   return AbstractType::Cast(Object::Handle(referent())).raw();
 }
 
 
 RawClass* MirrorReference::GetClassReferent() const {
   ASSERT(Object::Handle(referent()).IsClass());
@@ skipping 41 matching lines @@
   return result.raw();
 }
 
 
 const char* MirrorReference::ToCString() const {
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  stream->OpenObject();
-  stream->CloseObject();
+  JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart