Always use the same json for null in the vm service.

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 1468 matching lines @@
 
   cls = Class::New<UserTag>();
 }
 
 
 void Object::Print() const {
   OS::Print("%s\n", ToCString());
 }
 
 
+void Object::PrintJSON(JSONStream* stream, bool ref) const {
+  if (IsNull()) {
+    JSONObject jsobj(stream);
+    jsobj.AddProperty("type", ref ? "@Null" : "Null");
+    jsobj.AddProperty("id", "objects/null");
+    jsobj.AddProperty("valueAsString", "null");
+  } else {
+    PrintJSONImpl(stream, ref);
+  }
+}
+
+
 RawString* Object::DictionaryName() const {
   return String::null();
 }
 
 
 void Object::InitializeObject(uword address, intptr_t class_id, intptr_t size) {
   // TODO(iposva): Get a proper halt instruction from the assembler which
   // would be needed here for code objects.
   uword initial_value = reinterpret_cast<uword>(null_);
   uword cur = address;
@@ skipping 2383 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 {
+void Class::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   if ((raw() == Class::null()) || (id() == kFreeListElement)) {
     jsobj.AddProperty("type", "Null");
     return;
   }
   const char* internal_class_name = String::Handle(Name()).ToCString();
   const char* user_visible_class_name =
       String::Handle(UserVisibleName()).ToCString();
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "classes/%" Pd "", id());
@@ skipping 160 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 {
-  Object::PrintToJSONStream(stream, ref);
+void UnresolvedClass::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(stream, ref);
 }
 
 
 static uint32_t CombineHashes(uint32_t hash, uint32_t other_hash) {
   hash += other_hash;
   hash += hash << 10;
   hash ^= hash >> 6;  // Logical shift, unsigned hash.
   return hash;
 }
 
@@ skipping 133 matching lines @@
     other_type = other.TypeAt(from_index + i);
     ASSERT(!other_type.IsNull());
     if (!type.TypeTest(test_kind, other_type, bound_error)) {
       return false;
     }
   }
   return true;
 }
 
 
-void TypeArguments::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void TypeArguments::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
-  if (IsNull()) {
-    jsobj.AddProperty("type", ref ? "@Null" : "Null");
-    jsobj.AddProperty("id", "objects/null");
-    return;
-  }
   // The index in the canonical_type_arguments table cannot be used as part of
   // the object id (as in typearguments/id), because the indices are not
   // preserved when the table grows and the entries get rehashed. Use the ring.
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
   const Array& table = Array::Handle(object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddProperty("type", JSONType(ref));
@@ skipping 573 matching lines @@
   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 {
-  Object::PrintToJSONStream(stream, ref);
+void PatchClass::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 1579 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 {
+void Function::PrintJSONImpl(JSONStream* stream, bool ref) const {
   const char* internal_name = String::Handle(name()).ToCString();
   const char* user_name =
       String::Handle(UserVisibleName()).ToCString();
   Class& cls = Class::Handle(Owner());
   ASSERT(!cls.IsNull());
   Error& err = Error::Handle();
   err ^= cls.EnsureIsFinalized(Isolate::Current());
   ASSERT(err.IsNull());
   intptr_t id = -1;
   const char* selector = NULL;
@@ skipping 89 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 {
-  Object::PrintToJSONStream(stream, ref);
+void ClosureData::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 13 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 {
-  Object::PrintToJSONStream(stream, ref);
+void RedirectionData::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 183 matching lines @@
   const char* field_name = String::Handle(name()).ToCString();
   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 {
+void Field::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   const char* internal_field_name = String::Handle(name()).ToCString();
   const char* field_name = String::Handle(UserVisibleName()).ToCString();
   Class& cls = Class::Handle(owner());
   intptr_t id = cls.FindFieldIndex(*this);
   ASSERT(id >= 0);
   intptr_t cid = cls.id();
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "classes/%" Pd "/fields/%" Pd "", cid, id);
   jsobj.AddProperty("name", internal_field_name);
@@ skipping 251 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 {
-  Object::PrintToJSONStream(stream, ref);
+void LiteralToken::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 423 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
 
 
-void TokenStream::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Object::PrintToJSONStream(stream, ref);
+void TokenStream::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 482 matching lines @@
   return result.raw();
 }
 
 
 const char* Script::ToCString() const {
   return "Script";
 }
 
 
 // See also Dart_ScriptGetTokenInfo.
-void Script::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void Script::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   const String& name = String::Handle(url());
   ASSERT(!name.IsNull());
   const String& encoded_url = String::Handle(String::EncodeURI(name));
   ASSERT(!encoded_url.IsNull());
   jsobj.AddPropertyF("id", "scripts/%s", encoded_url.ToCString());
   jsobj.AddProperty("name", name.ToCString());
   jsobj.AddProperty("user_name", name.ToCString());
   jsobj.AddProperty("kind", GetKindAsCString());
@@ skipping 1247 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 {
+void Library::PrintJSONImpl(JSONStream* stream, bool ref) const {
   const char* library_name = String::Handle(name()).ToCString();
   intptr_t id = index();
   ASSERT(id >= 0);
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "libraries/%" Pd "", id);
   jsobj.AddProperty("user_name", library_name);
   jsobj.AddProperty("name", library_name);
   if (ref) {
     return;
@@ skipping 276 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 {
-  Object::PrintToJSONStream(stream, ref);
+void LibraryPrefix::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 32 matching lines @@
 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 {
-  Object::PrintToJSONStream(stream, ref);
+void Namespace::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 244 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
 
 
-void Instructions::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Object::PrintToJSONStream(stream, ref);
+void Instructions::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(stream, ref);
 }
 
 
 intptr_t PcDescriptors::Length() const {
   return raw_ptr()->length_;
 }
 
 
 void PcDescriptors::SetLength(intptr_t value) const {
   raw_ptr()->length_ = value;
@@ skipping 130 matching lines @@
                          PC(i),
                          KindAsStr(i),
                          DeoptId(i),
                          TokenPos(i),
                          TryIndex(i));
   }
   return buffer;
 }
 
 
-void PcDescriptors::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Object::PrintToJSONStream(stream, ref);
+void PcDescriptors::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 128 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 {
-  Object::PrintToJSONStream(stream, ref);
+void Stackmap::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 53 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 {
-  Object::PrintToJSONStream(stream, ref);
+void LocalVarDescriptors::PrintJSONImpl(JSONStream* stream,
+                                        bool ref) const {
+  Object::PrintJSONImpl(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 161 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 {
-  Object::PrintToJSONStream(stream, ref);
+void ExceptionHandlers::PrintJSONImpl(JSONStream* stream,
+                                      bool ref) const {
+  Object::PrintJSONImpl(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 95 matching lines @@
   GrowableArray<DeoptInstr*> unpacked(length);
   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 {
-  Object::PrintToJSONStream(stream, ref);
+void DeoptInfo::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 533 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 {
-  Object::PrintToJSONStream(stream, ref);
+void ICData::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(stream, ref);
 }
 
 
 Code::Comments& Code::Comments::New(intptr_t count) {
   Comments* comments;
   if (count < 0 || count > (kIntptrMax / kNumberOfEntries)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Code::Comments::New: invalid count %" Pd "\n",
            count);
   }
@@ skipping 462 matching lines @@
     ASSERT(!cls_name.IsNull());
     return String::Concat(Symbols::AllocationStubFor(), cls_name);
   } else {
     ASSERT(obj.IsFunction());
     // Dart function.
     return Function::Cast(obj).QualifiedUserVisibleName();
   }
 }
 
 
-void Code::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void Code::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "code/%" Px64"-%" Px "", compile_timestamp(),
                      EntryPoint());
   jsobj.AddPropertyF("start", "%" Px "", EntryPoint());
   jsobj.AddPropertyF("end", "%" Px "", EntryPoint() + Size());
   jsobj.AddProperty("is_optimized", is_optimized());
   jsobj.AddProperty("is_alive", is_alive());
   jsobj.AddProperty("kind", "Dart");
   const String& name = String::Handle(Name());
@@ skipping 191 matching lines @@
 
   const Context& parent_ctx = Context::Handle(parent());
   if (!parent_ctx.IsNull()) {
     parent_ctx.Dump(indent + 2);
   }
   IndentN(indent);
   OS::PrintErr("}\n");
 }
 
 
-void Context::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Object::PrintToJSONStream(stream, ref);
+void Context::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 97 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 {
-  Object::PrintToJSONStream(stream, ref);
+void ContextScope::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 94 matching lines @@
   } while (i != index);
   UNREACHABLE();
 }
 
 
 const char* MegamorphicCache::ToCString() const {
   return "";
 }
 
 
-void MegamorphicCache::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Object::PrintToJSONStream(stream, ref);
+void MegamorphicCache::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(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 54 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 {
-  Object::PrintToJSONStream(stream, ref);
+void SubtypeTestCache::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Object::PrintJSONImpl(stream, ref);
 }
 
 
 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 {
+void Error::PrintJSONImpl(JSONStream* stream, bool ref) const {
   UNREACHABLE();
 }
 
 
 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 @@
   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 {
+void ApiError::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Error");
   jsobj.AddProperty("id", "");
   jsobj.AddProperty("kind", JSONType(false));
   jsobj.AddProperty("message", ToErrorCString());
 }
 
 
 RawLanguageError* LanguageError::New() {
   ASSERT(Object::language_error_class() != Class::null());
@@ skipping 167 matching lines @@
   const String& msg_str = String::Handle(FormatMessage());
   return msg_str.ToCString();
 }
 
 
 const char* LanguageError::ToCString() const {
   return "LanguageError";
 }
 
 
-void LanguageError::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void LanguageError::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Error");
   jsobj.AddProperty("id", "");
   jsobj.AddProperty("kind", JSONType(false));
   jsobj.AddProperty("message", ToErrorCString());
 }
 
 
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
@@ skipping 57 matching lines @@
   return chars;
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
 
-void UnhandledException::PrintToJSONStream(JSONStream* stream,
-                                           bool ref) const {
+void UnhandledException::PrintJSONImpl(JSONStream* stream,
+                                       bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Error");
   jsobj.AddProperty("id", "");
   jsobj.AddProperty("kind", JSONType(false));
   jsobj.AddProperty("message", ToErrorCString());
 
   Instance& instance = Instance::Handle();
   instance = exception();
   jsobj.AddProperty("exception", instance);
   instance = stacktrace();
@@ skipping 25 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 {
+void UnwindError::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Error");
   jsobj.AddProperty("id", "");
   jsobj.AddProperty("kind", JSONType(false));
   jsobj.AddProperty("message", ToErrorCString());
 }
 
 
 RawObject* Instance::Evaluate(const String& expr,
                               const Array& param_names,
@@ skipping 424 matching lines @@
     for (intptr_t i = 0; i < NumNativeFields(); i++) {
       intptr_t value = GetNativeField(i);
       JSONObject jsfield(&jsarr);
       jsfield.AddProperty("index", i);
       jsfield.AddProperty("value", value);
     }
   }
 }
 
 
-void Instance::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void Instance::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 
   // Handle certain special instance values.
-  if (IsNull()) {
-    jsobj.AddProperty("type", ref ? "@Null" : "Null");
-    jsobj.AddProperty("id", "objects/null");
-    jsobj.AddProperty("valueAsString", "null");
-    return;
-  } else if (raw() == Object::sentinel().raw()) {
+  if (raw() == Object::sentinel().raw()) {
     jsobj.AddProperty("type", ref ? "@Null" : "Null");
     jsobj.AddProperty("id", "objects/not-initialized");
     jsobj.AddProperty("valueAsString", "<not initialized>");
     return;
   } else if (raw() == Object::transition_sentinel().raw()) {
     jsobj.AddProperty("type", ref ? "@Null" : "Null");
     jsobj.AddProperty("id", "objects/being-initialized");
     jsobj.AddProperty("valueAsString", "<being initialized>");
     return;
   }
@@ skipping 444 matching lines @@
 }
 
 
 const char* AbstractType::ToCString() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return "AbstractType";
 }
 
 
-void AbstractType::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void AbstractType::PrintJSONImpl(JSONStream* stream, bool ref) const {
   UNREACHABLE();
 }
 
 
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
 RawType* Type::DynamicType() {
@@ skipping 583 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 {
+void Type::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   if (IsCanonical()) {
     const Class& type_cls = Class::Handle(type_class());
     intptr_t id = type_cls.FindCanonicalTypeIndex(*this);
     ASSERT(id >= 0);
     intptr_t cid = type_cls.id();
     jsobj.AddPropertyF("id", "classes/%" Pd "/types/%" Pd "", cid, id);
     jsobj.AddProperty("type_class", type_cls);
   } else {
@@ skipping 152 matching lines @@
   } else {
     const char* format = "TypeRef: %s<...>";
     const intptr_t len = OS::SNPrint(NULL, 0, format, type_cstr) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, type_cstr);
     return chars;
   }
 }
 
 
-void TypeRef::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void TypeRef::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   const char* name = String::Handle(Name()).ToCString();
   const char* user_name = String::Handle(UserVisibleName()).ToCString();
   jsobj.AddProperty("name", name);
   jsobj.AddProperty("user_name", user_name);
   if (ref) {
@@ skipping 196 matching lines @@
   const AbstractType& upper_bound = AbstractType::Handle(bound());
   const char* bound_cstr = String::Handle(upper_bound.Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr, bound_cstr);
   return chars;
 }
 
 
-void TypeParameter::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void TypeParameter::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   const char* name = String::Handle(Name()).ToCString();
   const char* user_name = String::Handle(UserVisibleName()).ToCString();
   jsobj.AddProperty("name", name);
   jsobj.AddProperty("user_name", user_name);
   const Class& param_cls = Class::Handle(parameterized_class());
@@ skipping 183 matching lines @@
   const char* cls_cstr = String::Handle(cls.Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(
       chars, len, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr);
   return chars;
 }
 
 
-void BoundedType::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void BoundedType::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   const char* name = String::Handle(Name()).ToCString();
   const char* user_name = String::Handle(UserVisibleName()).ToCString();
   jsobj.AddProperty("name", name);
   jsobj.AddProperty("user_name", user_name);
   if (ref) {
@@ skipping 26 matching lines @@
   const char* first_mixin_type_cstr = String::Handle(AbstractType::Handle(
       MixinTypeAt(0)).Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, super_type_cstr, first_mixin_type_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
   return chars;
 }
 
 
-void MixinAppType::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void MixinAppType::PrintJSONImpl(JSONStream* stream, bool ref) const {
   UNREACHABLE();
 }
 
 
 RawAbstractType* MixinAppType::MixinTypeAt(intptr_t depth) const {
   return AbstractType::RawCast(Array::Handle(mixin_types()).At(depth));
 }
 
 
 void MixinAppType::set_super_type(const AbstractType& value) const {
@@ skipping 27 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 {
+void Number::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   jsobj.AddProperty("valueAsString", ToCString());
 }
 
 
 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 {
-  Number::PrintToJSONStream(stream, ref);
+void Integer::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Number::PrintJSONImpl(stream, ref);
 }
 
 
 // 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 407 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 {
+void Smi::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddPropertyF("id", "objects/int-%" Pd "", Value());
   jsobj.AddPropertyF("valueAsString", "%" Pd "", Value());
 }
 
 
 RawClass* Smi::Class() {
   return Isolate::Current()->object_store()->smi_class();
 }
@@ skipping 106 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 {
-  Number::PrintToJSONStream(stream, ref);
+void Mint::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Number::PrintJSONImpl(stream, ref);
 }
 
 
 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 84 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 {
-  Number::PrintToJSONStream(stream, ref);
+void Double::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Number::PrintJSONImpl(stream, ref);
 }
 
 
 RawBigint* Integer::AsBigint() const {
   ASSERT(!IsNull());
   if (IsSmi()) {
     Smi& smi = Smi::Handle();
     smi ^= raw();
     return BigintOperations::NewFromSmi(smi);
   } else if (IsMint()) {
@@ skipping 154 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 {
-  Number::PrintToJSONStream(stream, ref);
+void Bigint::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Number::PrintJSONImpl(stream, ref);
 }
 
 
 // Synchronize with implementation in compiler (intrinsifier).
 class StringHasher : ValueObject {
  public:
   StringHasher() : hash_(0) {}
   void Add(int32_t ch) {
     hash_ = CombineHashes(hash_, ch);
   }
@@ skipping 833 matching lines @@
     buffer[pos++] = '.';
     buffer[pos++] = '.';
   }
   ASSERT(pos <= buffer_len);
   buffer[pos++] = '\0';
 
   return buffer;
 }
 
 
-void String::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void String::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   if (raw() == Symbols::OptimizedOut().raw()) {
     // TODO(turnidge): This is a hack.  The user could have this
     // special string in their program.  Fixing this involves updating
     // the debugging api a bit.
     jsobj.AddProperty("type", ref ? "@Null" : "Null");
     jsobj.AddProperty("id", "objects/optimized-out");
     jsobj.AddProperty("valueAsString", "<optimized out>");
     return;
   }
@@ skipping 800 matching lines @@
   result.SetCanonical();
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
   return value() ? "true" : "false";
 }
 
 
-void Bool::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void Bool::PrintJSONImpl(JSONStream* stream, bool ref) const {
   const char* str = ToCString();
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "objects/bool-%s", str);
   class Class& cls = Class::Handle(this->clazz());
   jsobj.AddProperty("class", cls);
   jsobj.AddPropertyF("valueAsString", "%s", str);
 }
 
 
@@ skipping 69 matching lines @@
   }
   const char* format = IsImmutable() ?
       "_ImmutableList len:%" Pd : "_List 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 {
+void Array::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   jsobj.AddProperty("length", Length());
   if (ref) {
     return;
   }
   {
@@ skipping 215 matching lines @@
     return "_GrowableList NULL";
   }
   const char* format = "Instance(length:%" Pd ") of '_GrowableList'";
   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 {
+void GrowableObjectArray::PrintJSONImpl(JSONStream* stream,
+                                        bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   jsobj.AddProperty("length", Length());
   if (ref) {
     return;
   }
   {
@@ skipping 102 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 {
-  Instance::PrintToJSONStream(stream, ref);
+void Float32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawInt32x4* Int32x4::New(int32_t v0, int32_t v1, int32_t v2, int32_t v3,
                          Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->int32x4_class() !=
          Class::null());
   Int32x4& result = Int32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Int32x4::kClassId,
@@ skipping 83 matching lines @@
   int32_t _z = z();
   int32_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 Int32x4::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void Int32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawFloat64x2* Float64x2::New(double value0, double value1, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float64x2_class() !=
          Class::null());
   Float64x2& result = Float64x2::Handle();
   {
     RawObject* raw = Object::Allocate(Float64x2::kClassId,
                                       Float64x2::InstanceSize(),
@@ skipping 58 matching lines @@
   double _x = x();
   double _y = y();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y);
   return chars;
 }
 
 
-void Float64x2::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void Float64x2::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 const intptr_t TypedData::element_size[] = {
   1,   // kTypedDataInt8ArrayCid.
   1,   // kTypedDataUint8ArrayCid.
   1,   // kTypedDataUint8ClampedArrayCid.
   2,   // kTypedDataInt16ArrayCid.
   2,   // kTypedDataUint16ArrayCid.
   4,   // kTypedDataInt32ArrayCid.
@@ skipping 29 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* TypedData::ToCString() const {
   return "TypedData";
 }
 
 
-void TypedData::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void TypedData::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 FinalizablePersistentHandle* ExternalTypedData::AddFinalizer(
     void* peer, Dart_WeakPersistentHandleFinalizer callback) const {
   return dart::AddFinalizer(*this, peer, callback);
 }
 
 
 RawExternalTypedData* ExternalTypedData::New(intptr_t class_id,
@@ skipping 12 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* ExternalTypedData::ToCString() const {
   return "ExternalTypedData";
 }
 
 
-void ExternalTypedData::PrintToJSONStream(JSONStream* stream,
-                                          bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void ExternalTypedData::PrintJSONImpl(JSONStream* stream,
+                                      bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawCapability* Capability::New(uint64_t id, Heap::Space space) {
   Capability& result = Capability::Handle();
   {
     RawObject* raw = Object::Allocate(Capability::kClassId,
                                       Capability::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->id_ = id;
   }
   return result.raw();
 }
 
 
 const char* Capability::ToCString() const {
   return "Capability";
 }
 
 
-void Capability::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void Capability::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawReceivePort* ReceivePort::New(Dart_Port id, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   const SendPort& send_port = SendPort::Handle(isolate, SendPort::New(id));
 
   ReceivePort& result = ReceivePort::Handle(isolate);
   {
     RawObject* raw = Object::Allocate(ReceivePort::kClassId,
                                       ReceivePort::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->send_port_ = send_port.raw();
   }
   PortMap::SetLive(id);
   return result.raw();
 }
 
 
 const char* ReceivePort::ToCString() const {
   return "ReceivePort";
 }
 
 
-void ReceivePort::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void ReceivePort::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawSendPort* SendPort::New(Dart_Port id, Heap::Space space) {
   SendPort& result = SendPort::Handle();
   {
     RawObject* raw = Object::Allocate(SendPort::kClassId,
                                       SendPort::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->id_ = id;
   }
   return result.raw();
 }
 
 
 const char* SendPort::ToCString() const {
   return "SendPort";
 }
 
 
-void SendPort::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void SendPort::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 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";
@@ skipping 164 matching lines @@
   return String::New(ToCStringInternal(&idx));
 }
 
 
 const char* Stacktrace::ToCString() const {
   const String& trace = String::Handle(FullStacktrace());
   return trace.ToCString();
 }
 
 
-void Stacktrace::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void Stacktrace::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 static intptr_t PrintOneStacktrace(Isolate* isolate,
                                    GrowableArray<char*>* frame_strings,
                                    uword pc,
                                    const Function& function,
                                    const Code& code,
                                    intptr_t frame_index) {
   const char* kFormatWithCol = "#%-6d %s (%s:%d:%d)\n";
@@ skipping 190 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 {
-  Instance::PrintToJSONStream(stream, ref);
+void JSRegExp::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 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 {
-  Instance::PrintToJSONStream(stream, ref);
+void WeakProperty::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 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 38 matching lines @@
   result.set_referent(referent);
   return result.raw();
 }
 
 
 const char* MirrorReference::ToCString() const {
   return "_MirrorReference";
 }
 
 
-void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void MirrorReference::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 void UserTag::MakeActive() const {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   isolate->set_current_tag(*this);
 }
 
 
@@ skipping 102 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 
-void UserTag::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  Instance::PrintToJSONStream(stream, ref);
+void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
+  Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart