Remove many features when building product mode

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 1706 matching lines @@
 
   return Error::null();
 }
 
 
 void Object::Print() const {
   THR_Print("%s\n", ToCString());
 }
 
 
-static void AddNameProperties(JSONObject* jsobj,
-                              const String& name,
-                              const String& vm_name) {
-  jsobj->AddProperty("name", name.ToCString());
-  if (!name.Equals(vm_name)) {
-    jsobj->AddProperty("_vmName", vm_name.ToCString());
-  }
-}
-
-
-void Object::AddCommonObjectProperties(JSONObject* jsobj,
-                                       const char* protocol_type,
-                                       bool ref) const {
-  const char* vm_type = JSONType();
-  bool same_type = (strcmp(protocol_type, vm_type) == 0);
-  if (ref) {
-    jsobj->AddPropertyF("type", "@%s", protocol_type);
-  } else {
-    jsobj->AddProperty("type", protocol_type);
-  }
-  if (!same_type) {
-    jsobj->AddProperty("_vmType", vm_type);
-  }
-  if (!ref || IsInstance() || IsNull()) {
-    // TODO(turnidge): Provide the type arguments here too?
-    const Class& cls = Class::Handle(this->clazz());
-    jsobj->AddProperty("class", cls);
-  }
-  if (!ref) {
-    if (raw()->IsHeapObject()) {
-      jsobj->AddProperty("size", raw()->Size());
-    } else {
-      jsobj->AddProperty("size", (intptr_t)0);
-    }
-  }
-}
-
-
-void Object::PrintJSON(JSONStream* stream, bool ref) const {
-  if (IsNull()) {
-    JSONObject jsobj(stream);
-    AddCommonObjectProperties(&jsobj, "Instance", ref);
-    jsobj.AddProperty("kind", "Null");
-    jsobj.AddFixedServiceId("objects/null");
-    jsobj.AddProperty("valueAsString", "null");
-  } else {
-    PrintJSONImpl(stream, ref);
-  }
-}
-
-
-void Object::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Object", ref);
-  jsobj.AddServiceId(*this);
-  if (ref) {
-    return;
-  }
-}
-
-
 RawString* Object::DictionaryName() const {
   return String::null();
 }
 
 
 void Object::InitializeObject(uword address,
                               intptr_t class_id,
                               intptr_t size,
                               bool is_vm_object) {
   uword initial_value = (class_id == kInstructionsCid)
@@ skipping 2329 matching lines @@
 const char* Class::ToCString() const {
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* patch_prefix = is_patch() ? "Patch " : "";
   const char* class_name = String::Handle(Name()).ToCString();
   return OS::SCreate(Thread::Current()->zone(),
       "%s %sClass: %s", library_name, patch_prefix, class_name);
 }
 
 
-void Class::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Isolate* isolate = Isolate::Current();
-  JSONObject jsobj(stream);
-  if ((raw() == Class::null()) || (id() == kFreeListElement)) {
-    // TODO(turnidge): This is weird and needs to be changed.
-    jsobj.AddProperty("type", "null");
-    return;
-  }
-  AddCommonObjectProperties(&jsobj, "Class", ref);
-  jsobj.AddFixedServiceId("classes/%" Pd "", id());
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  if (ref) {
-    return;
-  }
-
-  const Error& err = Error::Handle(EnsureIsFinalized(Thread::Current()));
-  if (!err.IsNull()) {
-    jsobj.AddProperty("error", err);
-  }
-  jsobj.AddProperty("abstract", is_abstract());
-  jsobj.AddProperty("const", is_const());
-  jsobj.AddProperty("_finalized", is_finalized());
-  jsobj.AddProperty("_implemented", is_implemented());
-  jsobj.AddProperty("_patch", is_patch());
-  jsobj.AddProperty("_traceAllocations", TraceAllocation(isolate));
-  const Class& superClass = Class::Handle(SuperClass());
-  if (!superClass.IsNull()) {
-    jsobj.AddProperty("super", superClass);
-  }
-  jsobj.AddProperty("library", Object::Handle(library()));
-  const Script& script = Script::Handle(this->script());
-  if (!script.IsNull()) {
-    jsobj.AddLocation(script, token_pos(), ComputeEndTokenPos());
-  }
-  {
-    JSONArray interfaces_array(&jsobj, "interfaces");
-    const Array& interface_array = Array::Handle(interfaces());
-    Type& interface_type = Type::Handle();
-    if (!interface_array.IsNull()) {
-      for (intptr_t i = 0; i < interface_array.Length(); ++i) {
-        interface_type ^= interface_array.At(i);
-        interfaces_array.AddValue(interface_type);
-      }
-    }
-  }
-  {
-    JSONArray fields_array(&jsobj, "fields");
-    const Array& field_array = Array::Handle(fields());
-    Field& field = Field::Handle();
-    if (!field_array.IsNull()) {
-      for (intptr_t i = 0; i < field_array.Length(); ++i) {
-        field ^= field_array.At(i);
-        fields_array.AddValue(field);
-      }
-    }
-  }
-  {
-    JSONArray functions_array(&jsobj, "functions");
-    const Array& function_array = Array::Handle(functions());
-    Function& function = Function::Handle();
-    if (!function_array.IsNull()) {
-      for (intptr_t i = 0; i < function_array.Length(); i++) {
-        function ^= function_array.At(i);
-        functions_array.AddValue(function);
-      }
-    }
-  }
-  {
-    JSONArray subclasses_array(&jsobj, "subclasses");
-    const GrowableObjectArray& subclasses =
-        GrowableObjectArray::Handle(direct_subclasses());
-    if (!subclasses.IsNull()) {
-      Class& subclass = Class::Handle();
-      for (intptr_t i = 0; i < subclasses.Length(); ++i) {
-        // TODO(turnidge): Use the Type directly once regis has added
-        // types to the vmservice.
-        subclass ^= subclasses.At(i);
-        subclasses_array.AddValue(subclass);
-      }
-    }
-  }
-  {
-    ClassTable* class_table = Isolate::Current()->class_table();
-    const ClassHeapStats* stats = class_table->StatsWithUpdatedSize(id());
-    if (stats != NULL) {
-      JSONObject allocation_stats(&jsobj, "_allocationStats");
-      stats->PrintToJSONObject(*this, &allocation_stats);
-    }
-  }
-}
-
-
 void Class::InsertCanonicalConstant(intptr_t index,
                                     const Instance& constant) const {
   // The constant needs to be added to the list. Grow the list if it is full.
   Array& canonical_list = Array::Handle(constants());
   const intptr_t list_len = canonical_list.Length();
   if (index >= list_len) {
     const intptr_t new_length = (list_len == 0) ? 4 : list_len + 4;
     const Array& new_canonical_list =
         Array::Handle(Array::Grow(canonical_list, new_length, Heap::kOld));
     set_constants(new_canonical_list);
@@ skipping 58 matching lines @@
 }
 
 
 const char* UnresolvedClass::ToCString() const {
   const char* cname =  String::Handle(Name()).ToCString();
   return OS::SCreate(Thread::Current()->zone(),
       "unresolved class '%s'", cname);
 }
 
 
-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;
 }
 
 
 static uint32_t FinalizeHash(uint32_t hash) {
   hash += hash << 3;
@@ skipping 130 matching lines @@
     other_type = other.TypeAt(from_index + i);
     ASSERT(!other_type.IsNull());
     if (!type.TypeTest(test_kind, other_type, bound_error, space)) {
       return false;
     }
   }
   return true;
 }
 
 
-void TypeArguments::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  // 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);
-  AddCommonObjectProperties(&jsobj, "TypeArguments", ref);
-  jsobj.AddServiceId(*this);
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  if (ref) {
-    return;
-  }
-  {
-    JSONArray jsarr(&jsobj, "types");
-    AbstractType& type_arg = AbstractType::Handle();
-    for (intptr_t i = 0; i < Length(); i++) {
-      type_arg = TypeAt(i);
-      jsarr.AddValue(type_arg);
-    }
-  }
-  if (!IsInstantiated()) {
-    JSONArray jsarr(&jsobj, "_instantiations");
-    Array& prior_instantiations = Array::Handle(instantiations());
-    ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
-    TypeArguments& type_args = TypeArguments::Handle();
-    intptr_t i = 0;
-    while (true) {
-      if (prior_instantiations.At(i) == Smi::New(StubCode::kNoInstantiator)) {
-        break;
-      }
-      JSONObject instantiation(&jsarr);
-      type_args ^= prior_instantiations.At(i);
-      instantiation.AddProperty("instantiator", type_args, true);
-      type_args ^= prior_instantiations.At(i + 1);
-      instantiation.AddProperty("instantiated", type_args, true);
-      i += 2;
-    }
-  }
-}
-
-
 bool TypeArguments::HasInstantiations() const {
   const Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
   return prior_instantiations.Length() > 1;
 }
 
 
 intptr_t TypeArguments::NumInstantiations() const {
   const Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
@@ skipping 547 matching lines @@
 
 
 const char* PatchClass::ToCString() const {
   const Class& cls = Class::Handle(patched_class());
   const char* cls_name = cls.ToCString();
   return OS::SCreate(Thread::Current()->zone(),
       "PatchClass for %s", cls_name);
 }
 
 
-void PatchClass::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
-}
-
-
 RawPatchClass* PatchClass::New(const Class& patched_class,
                                const Class& origin_class) {
   const PatchClass& result = PatchClass::Handle(PatchClass::New());
   result.set_patched_class(patched_class);
   result.set_origin_class(origin_class);
   result.set_script(Script::Handle(origin_class.script()));
   return result.raw();
 }
 
 
@@ skipping 25 matching lines @@
   StorePointer(&raw_ptr()->origin_class_, value.raw());
 }
 
 
 void PatchClass::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
 bool Function::HasBreakpoint() const {
+  if (!FLAG_support_debugger) {
+    return false;
+  }
   Thread* thread = Thread::Current();
   return thread->isolate()->debugger()->HasBreakpoint(*this, thread->zone());
 }
 
 
 void Function::InstallOptimizedCode(const Code& code, bool is_osr) const {
   DEBUG_ASSERT(IsMutatorOrAtSafepoint());
   // We may not have previous code if 'always_optimize' is set.
   if (!is_osr && HasCode()) {
     Code::Handle(CurrentCode()).DisableDartCode();
@@ skipping 640 matching lines @@
 void Function::SetIsNativeAutoSetupScope(bool value) const {
   ASSERT(is_native());
   set_is_optimizable(value);
 }
 
 
 bool Function::CanBeInlined() const {
   Thread* thread = Thread::Current();
   return is_inlinable() &&
          !is_generated_body() &&
-         !thread->isolate()->debugger()->HasBreakpoint(*this, thread->zone());
+         (!FLAG_support_debugger ||
+          !thread->isolate()->debugger()->HasBreakpoint(*this, thread->zone()));
 }
 
 
 intptr_t Function::NumParameters() const {
   return num_fixed_parameters() + NumOptionalParameters();
 }
 
 
 intptr_t Function::NumImplicitParameters() const {
   if (kind() == RawFunction::kConstructor) {
@@ skipping 1257 matching lines @@
     default:
       UNREACHABLE();
   }
   const char* function_name = String::Handle(name()).ToCString();
   return OS::SCreate(Thread::Current()->zone(),
       "Function '%s':%s%s%s%s.",
       function_name, static_str, abstract_str, kind_str, const_str);
 }
 
 
-static void AddFunctionServiceId(const JSONObject& jsobj,
-                                 const Function& f,
-                                 const Class& cls) {
-  // Special kinds of functions use indices in their respective lists.
-  intptr_t id = -1;
-  const char* selector = NULL;
-  if (f.IsNonImplicitClosureFunction()) {
-    id = Isolate::Current()->FindClosureIndex(f);
-    selector = "closures";
-  } else if (f.IsImplicitClosureFunction()) {
-    id = cls.FindImplicitClosureFunctionIndex(f);
-    selector = "implicit_closures";
-  } else if (f.IsNoSuchMethodDispatcher() || f.IsInvokeFieldDispatcher()) {
-    id = cls.FindInvocationDispatcherFunctionIndex(f);
-    selector = "dispatchers";
-  }
-  if (id != -1) {
-    ASSERT(selector != NULL);
-    jsobj.AddFixedServiceId("classes/%" Pd "/%s/%" Pd "",
-                            cls.id(), selector, id);
-    return;
-  }
-  // Regular functions known to their owner use their name (percent-encoded).
-  String& name = String::Handle(f.name());
-  if (cls.LookupFunction(name) == f.raw()) {
-    name = String::EncodeIRI(name);
-    jsobj.AddFixedServiceId("classes/%" Pd "/functions/%s",
-                            cls.id(), name.ToCString());
-    return;
-  }
-  // Oddball functions (not known to their owner) fall back to use the object
-  // id ring. Current known examples are signature functions of closures
-  // and stubs like 'megamorphic_miss'.
-  jsobj.AddServiceId(f);
-}
-
-
-void Function::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Class& cls = Class::Handle(Owner());
-  ASSERT(!cls.IsNull());
-  Error& err = Error::Handle();
-  err ^= cls.EnsureIsFinalized(Thread::Current());
-  ASSERT(err.IsNull());
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Function", ref);
-  AddFunctionServiceId(jsobj, *this, cls);
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  const Function& parent = Function::Handle(parent_function());
-  if (!parent.IsNull()) {
-    jsobj.AddProperty("owner", parent);
-  } else if (cls.IsTopLevel()) {
-    const Library& library = Library::Handle(cls.library());
-    jsobj.AddProperty("owner", library);
-  } else {
-    jsobj.AddProperty("owner", cls);
-  }
-
-  const char* kind_string = Function::KindToCString(kind());
-  jsobj.AddProperty("_kind", kind_string);
-  jsobj.AddProperty("static", is_static());
-  jsobj.AddProperty("const", is_const());
-  jsobj.AddProperty("_intrinsic", is_intrinsic());
-  jsobj.AddProperty("_native", is_native());
-  if (ref) {
-    return;
-  }
-  Code& code = Code::Handle(CurrentCode());
-  if (!code.IsNull()) {
-    jsobj.AddProperty("code", code);
-  }
-  Array& ics = Array::Handle(ic_data_array());
-  if (!ics.IsNull()) {
-    jsobj.AddProperty("_icDataArray", ics);
-  }
-  jsobj.AddProperty("_optimizable", is_optimizable());
-  jsobj.AddProperty("_inlinable", is_inlinable());
-  jsobj.AddProperty("_recognized", IsRecognized());
-  code = unoptimized_code();
-  if (!code.IsNull()) {
-    jsobj.AddProperty("_unoptimizedCode", code);
-  }
-  jsobj.AddProperty("_usageCounter", usage_counter());
-  jsobj.AddProperty("_optimizedCallSiteCount", optimized_call_site_count());
-  jsobj.AddProperty("_deoptimizations",
-                    static_cast<intptr_t>(deoptimization_counter()));
-  if ((kind() == RawFunction::kImplicitGetter) ||
-      (kind() == RawFunction::kImplicitSetter) ||
-      (kind() == RawFunction::kImplicitStaticFinalGetter)) {
-    const Field& field = Field::Handle(LookupImplicitGetterSetterField());
-    if (!field.IsNull()) {
-      jsobj.AddProperty("_field", field);
-    }
-  }
-
-  const Script& script = Script::Handle(this->script());
-  if (!script.IsNull()) {
-    jsobj.AddLocation(script, token_pos(), end_token_pos());
-  }
-}
-
-
 void ClosureData::set_context_scope(const ContextScope& value) const {
   StorePointer(&raw_ptr()->context_scope_, value.raw());
 }
 
 
 void ClosureData::set_implicit_static_closure(const Instance& closure) const {
   ASSERT(!closure.IsNull());
   ASSERT(raw_ptr()->closure_ == Instance::null());
   StorePointer(&raw_ptr()->closure_, closure.raw());
 }
@@ skipping 16 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawClosureData*>(raw);
 }
 
 
 const char* ClosureData::ToCString() const {
   return "ClosureData class";
 }
 
 
-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 {
   StorePointer(&raw_ptr()->identifier_, value.raw());
 }
 
@@ skipping 10 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawRedirectionData*>(raw);
 }
 
 
 const char* RedirectionData::ToCString() const {
   return "RedirectionData class";
 }
 
 
-void RedirectionData::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
-}
-
-
 RawString* Field::GetterName(const String& field_name) {
   return String::Concat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   return Symbols::FromConcat(Symbols::GetterPrefix(), field_name);
 }
 
 
@@ skipping 225 matching lines @@
   const char* kF1 = is_final() ? " final" : "";
   const char* kF2 = is_const() ? " const" : "";
   const char* field_name = String::Handle(name()).ToCString();
   const Class& cls = Class::Handle(owner());
   const char* cls_name = String::Handle(cls.Name()).ToCString();
   return OS::SCreate(Thread::Current()->zone(),
       "Field <%s.%s>:%s%s%s", cls_name, field_name, kF0, kF1, kF2);
 }
 
 
-void Field::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  Class& cls = Class::Handle(owner());
-  String& field_name = String::Handle(name());
-  field_name = String::EncodeIRI(field_name);
-  AddCommonObjectProperties(&jsobj, "Field", ref);
-  jsobj.AddFixedServiceId("classes/%" Pd "/fields/%s",
-                          cls.id(), field_name.ToCString());
-
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  if (cls.IsTopLevel()) {
-    const Library& library = Library::Handle(cls.library());
-    jsobj.AddProperty("owner", library);
-  } else {
-    jsobj.AddProperty("owner", cls);
-  }
-
-  AbstractType& declared_type = AbstractType::Handle(type());
-  jsobj.AddProperty("declaredType", declared_type);
-  jsobj.AddProperty("static", is_static());
-  jsobj.AddProperty("final", is_final());
-  jsobj.AddProperty("const", is_const());
-  if (ref) {
-    return;
-  }
-  if (is_static()) {
-    const Instance& valueObj = Instance::Handle(StaticValue());
-    jsobj.AddProperty("staticValue", valueObj);
-  }
-
-  jsobj.AddProperty("_guardNullable", is_nullable());
-  if (guarded_cid() == kIllegalCid) {
-    jsobj.AddProperty("_guardClass", "unknown");
-  } else if (guarded_cid() == kDynamicCid) {
-    jsobj.AddProperty("_guardClass", "dynamic");
-  } else {
-    ClassTable* table = Isolate::Current()->class_table();
-    ASSERT(table->IsValidIndex(guarded_cid()));
-    cls ^= table->At(guarded_cid());
-    jsobj.AddProperty("_guardClass", cls);
-  }
-  if (guarded_list_length() == kUnknownFixedLength) {
-    jsobj.AddProperty("_guardLength", "unknown");
-  } else if (guarded_list_length() == kNoFixedLength) {
-    jsobj.AddProperty("_guardLength", "variable");
-  } else {
-    jsobj.AddProperty("_guardLength", guarded_list_length());
-  }
-  const Class& origin_cls = Class::Handle(origin());
-  const Script& script = Script::Handle(origin_cls.script());
-  if (!script.IsNull()) {
-    jsobj.AddLocation(script, token_pos());
-  }
-}
-
-
 // Build a closure object that gets (or sets) the contents of a static
 // field f and cache the closure in a newly created static field
 // named #f (or #f= in case of a setter).
 RawInstance* Field::AccessorClosure(bool make_setter) const {
   ASSERT(is_static());
   const Class& field_owner = Class::Handle(owner());
 
   String& closure_name = String::Handle(this->name());
   closure_name = Symbols::FromConcat(Symbols::HashMark(), closure_name);
   if (make_setter) {
@@ skipping 381 matching lines @@
   return result.raw();
 }
 
 
 const char* LiteralToken::ToCString() const {
   const String& token = String::Handle(literal());
   return token.ToCString();
 }
 
 
-void LiteralToken::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
-}
-
-
 RawGrowableObjectArray* TokenStream::TokenObjects() const {
   return raw_ptr()->token_objects_;
 }
 
 
 void TokenStream::SetTokenObjects(const GrowableObjectArray& value) const {
   StorePointer(&raw_ptr()->token_objects_, value.raw());
 }
 
 
@@ skipping 460 matching lines @@
   isolate->object_store()->set_token_objects(GrowableObjectArray::Handle());
   isolate->object_store()->set_token_objects_map(Array::null_array());
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
 
 
-void TokenStream::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Object", ref);
-  // TODO(johnmccutchan): Generate a stable id. TokenStreams hang off
-  // a Script object but do not have a back reference to generate a stable id.
-  jsobj.AddServiceId(*this);
-  if (ref) {
-    return;
-  }
-  const String& private_key = String::Handle(PrivateKey());
-  jsobj.AddProperty("privateKey", private_key);
-  // TODO(johnmccutchan): Add support for printing LiteralTokens and add
-  // them to members array.
-  JSONArray members(&jsobj, "members");
-}
-
-
 TokenStream::Iterator::Iterator(const TokenStream& tokens,
                                 TokenPosition 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(
           GrowableObjectArray::Handle(tokens.TokenObjects()).data())),
       obj_(Object::Handle()),
       cur_token_pos_(token_pos.Pos()),
@@ skipping 538 matching lines @@
     for (intptr_t j = 0; j < scripts.Length(); j++) {
       if (scripts.At(j) == raw()) {
         return lib.raw();
       }
     }
   }
   return Library::null();
 }
 
 
-// See also Dart_ScriptGetTokenInfo.
-void Script::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Script", ref);
-  const String& uri = String::Handle(url());
-  ASSERT(!uri.IsNull());
-  const String& encoded_uri = String::Handle(String::EncodeIRI(uri));
-  ASSERT(!encoded_uri.IsNull());
-  const Library& lib = Library::Handle(FindLibrary());
-  if (kind() == RawScript::kEvaluateTag) {
-    jsobj.AddServiceId(*this);
-  } else {
-    ASSERT(!lib.IsNull());
-    jsobj.AddFixedServiceId("libraries/%" Pd "/scripts/%s",
-        lib.index(), encoded_uri.ToCString());
-  }
-  jsobj.AddPropertyStr("uri", uri);
-  jsobj.AddProperty("_kind", GetKindAsCString());
-  if (ref) {
-    return;
-  }
-  if (!lib.IsNull()) {
-    jsobj.AddProperty("library", lib);
-  }
-  const String& source = String::Handle(Source());
-  jsobj.AddProperty("lineOffset", line_offset());
-  jsobj.AddProperty("columnOffset", col_offset());
-  if (!source.IsNull()) {
-    jsobj.AddPropertyStr("source", source);
-  }
-
-  // Print the line number table
-  if (!source.IsNull()) {
-    JSONArray tokenPosTable(&jsobj, "tokenPosTable");
-
-    const GrowableObjectArray& lineNumberArray =
-        GrowableObjectArray::Handle(GenerateLineNumberArray());
-    Object& value = Object::Handle();
-    intptr_t pos = 0;
-
-    // Skip leading null.
-    ASSERT(lineNumberArray.Length() > 0);
-    value = lineNumberArray.At(pos);
-    ASSERT(value.IsNull());
-    pos++;
-
-    while (pos < lineNumberArray.Length()) {
-      JSONArray lineInfo(&tokenPosTable);
-      while (pos < lineNumberArray.Length()) {
-        value = lineNumberArray.At(pos);
-        pos++;
-        if (value.IsNull()) {
-          break;
-        }
-        const Smi& smi = Smi::Cast(value);
-        lineInfo.AddValue(smi.Value());
-      }
-    }
-  }
-}
-
-
 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();
 }
 
 
 RawObject* DictionaryIterator::GetNext() {
@@ skipping 1379 matching lines @@
 }
 
 
 const char* Library::ToCString() const {
   const String& name = String::Handle(url());
   return OS::SCreate(Thread::Current()->zone(),
       "Library:'%s'", name.ToCString());
 }
 
 
-void Library::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  intptr_t id = index();
-  ASSERT(id >= 0);
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Library", ref);
-  jsobj.AddFixedServiceId("libraries/%" Pd "", id);
-  const String& vm_name = String::Handle(name());
-  const String& user_name =
-      String::Handle(String::IdentifierPrettyName(vm_name));
-  AddNameProperties(&jsobj, user_name, vm_name);
-  const String& library_url = String::Handle(url());
-  jsobj.AddPropertyStr("uri", library_url);
-  if (ref) {
-    return;
-  }
-  jsobj.AddProperty("debuggable", IsDebuggable());
-  {
-    JSONArray jsarr(&jsobj, "classes");
-    ClassDictionaryIterator class_iter(*this);
-    Class& klass = Class::Handle();
-    while (class_iter.HasNext()) {
-      klass = class_iter.GetNextClass();
-      if (!klass.IsMixinApplication()) {
-        jsarr.AddValue(klass);
-      }
-    }
-  }
-  {
-    JSONArray jsarr(&jsobj, "dependencies");
-
-    Array& ports = Array::Handle();
-    Namespace& ns = Namespace::Handle();
-    Library& target = Library::Handle();
-
-    // Unprefixed imports.
-    ports = imports();
-    for (intptr_t i = 0; i < ports.Length(); i++) {
-      ns ^= ports.At(i);
-      if (ns.IsNull()) continue;
-
-      JSONObject jsdep(&jsarr);
-      jsdep.AddProperty("isDeferred", false);
-      jsdep.AddProperty("isExport", false);
-      jsdep.AddProperty("isImport", true);
-      target = ns.library();
-      jsdep.AddProperty("target", target);
-    }
-
-    // Exports.
-    ports = exports();
-    for (intptr_t i = 0; i < ports.Length(); i++) {
-      ns ^= ports.At(i);
-      if (ns.IsNull()) continue;
-
-      JSONObject jsdep(&jsarr);
-      jsdep.AddProperty("isDeferred", false);
-      jsdep.AddProperty("isExport", true);
-      jsdep.AddProperty("isImport", false);
-      target = ns.library();
-      jsdep.AddProperty("target", target);
-    }
-
-    // Prefixed imports.
-    DictionaryIterator entries(*this);
-    Object& entry = Object::Handle();
-    LibraryPrefix& prefix = LibraryPrefix::Handle();
-    String& prefixName = String::Handle();
-    while (entries.HasNext()) {
-      entry = entries.GetNext();
-      if (entry.IsLibraryPrefix()) {
-        prefix ^= entry.raw();
-        ports = prefix.imports();
-        for (intptr_t i = 0; i < ports.Length(); i++) {
-          ns ^= ports.At(i);
-          if (ns.IsNull()) continue;
-
-          JSONObject jsdep(&jsarr);
-          jsdep.AddProperty("isDeferred", prefix.is_deferred_load());
-          jsdep.AddProperty("isExport", false);
-          jsdep.AddProperty("isImport", true);
-          prefixName = prefix.name();
-          ASSERT(!prefixName.IsNull());
-          jsdep.AddProperty("prefix", prefixName.ToCString());
-          target = ns.library();
-          jsdep.AddProperty("target", target);
-        }
-      }
-    }
-  }
-  {
-    JSONArray jsarr(&jsobj, "variables");
-    DictionaryIterator entries(*this);
-    Object& entry = Object::Handle();
-    while (entries.HasNext()) {
-      entry = entries.GetNext();
-      if (entry.IsField()) {
-        jsarr.AddValue(entry);
-      }
-    }
-  }
-  {
-    JSONArray jsarr(&jsobj, "functions");
-    DictionaryIterator entries(*this);
-    Object& entry = Object::Handle();
-    while (entries.HasNext()) {
-      entry = entries.GetNext();
-      if (entry.IsFunction()) {
-        const Function& func = Function::Cast(entry);
-        if (func.kind() == RawFunction::kRegularFunction ||
-            func.kind() == RawFunction::kGetterFunction ||
-            func.kind() == RawFunction::kSetterFunction) {
-          jsarr.AddValue(func);
-        }
-      }
-    }
-  }
-  {
-    JSONArray jsarr(&jsobj, "scripts");
-    Array& scripts = Array::Handle(LoadedScripts());
-    Script& script = Script::Handle();
-    for (intptr_t i = 0; i < scripts.Length(); i++) {
-      script ^= scripts.At(i);
-      jsarr.AddValue(script);
-    }
-  }
-}
-
-
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
   if ((index >= 0) || (index < num_imports())) {
     const Array& imports = Array::Handle(this->imports());
     Namespace& import = Namespace::Handle();
     import ^= imports.At(index);
     return import.library();
   }
   return Library::null();
 }
 
@@ skipping 274 matching lines @@
 }
 
 
 const char* LibraryPrefix::ToCString() const {
   const String& prefix = String::Handle(name());
   return OS::SCreate(Thread::Current()->zone(),
       "LibraryPrefix:'%s'", prefix.ToCString());
 }
 
 
-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(const Object& owner, TokenPosition token_pos) {
   ASSERT(Field::Handle(metadata_field()).IsNull());
   Field& field = Field::Handle(Field::NewTopLevel(Symbols::TopLevel(),
                                           false,  // is_final
                                           false,  // is_const
@@ skipping 25 matching lines @@
 }
 
 
 const char* Namespace::ToCString() const {
   const Library& lib = Library::Handle(library());
   return OS::SCreate(Thread::Current()->zone(),
       "Namespace for library '%s'", lib.ToCString());
 }
 
 
-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;
   if (Field::IsGetterName(name)) {
     plain_name = &String::Handle(Field::NameFromGetter(name));
   } else if (Field::IsSetterName(name)) {
@@ skipping 251 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
 
 
-void Instructions::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Object", ref);
-  jsobj.AddServiceId(*this);
-  if (ref) {
-    return;
-  }
-}
-
-
 // Encode integer |value| in SLEB128 format and store into |data|.
 static void EncodeSLEB128(GrowableArray<uint8_t>* data,
                           intptr_t value) {
   bool is_last_part = false;
   while (!is_last_part) {
     uint8_t part = value & 0x7f;
     value >>= 7;
     if ((value == 0 && (part & 0x40) == 0) ||
         (value == static_cast<intptr_t>(-1) && (part & 0x40) != 0)) {
       is_last_part = true;
@@ skipping 77 matching lines @@
   return static_cast<EntryType>(array.GetInt8(index));
 }
 
 
 const char* ObjectPool::ToCString() const {
   Zone* zone = Thread::Current()->zone();
   return zone->PrintToString("ObjectPool len:%" Pd, Length());
 }
 
 
-void ObjectPool::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Object", ref);
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("length", Length());
-  if (ref) {
-    return;
-  }
-
-  {
-    JSONArray jsarr(&jsobj, "_entries");
-    uword imm;
-    Object& obj = Object::Handle();
-    for (intptr_t i = 0; i < Length(); i++) {
-      JSONObject jsentry(stream);
-      jsentry.AddProperty("offset", OffsetFromIndex(i));
-      switch (InfoAt(i)) {
-      case ObjectPool::kTaggedObject:
-        obj = ObjectAt(i);
-        jsentry.AddProperty("kind", "Object");
-        jsentry.AddProperty("value", obj);
-        break;
-      case ObjectPool::kImmediate:
-        imm = RawValueAt(i);
-        jsentry.AddProperty("kind", "Immediate");
-        jsentry.AddProperty64("value", imm);
-        break;
-      case ObjectPool::kNativeEntry:
-        imm = RawValueAt(i);
-        jsentry.AddProperty("kind", "NativeEntry");
-        jsentry.AddProperty64("value", imm);
-        break;
-      default:
-        UNREACHABLE();
-      }
-    }
-  }
-}
-
-
 void ObjectPool::DebugPrint() const {
   THR_Print("Object Pool: {\n");
   for (intptr_t i = 0; i < Length(); i++) {
     intptr_t offset = OffsetFromIndex(i);
     THR_Print("  %" Pd " PP+0x%" Px ": ", i, offset);
     if (InfoAt(i) == kTaggedObject) {
       RawObject* obj = ObjectAt(i);
       THR_Print("0x%" Px " %s (obj)\n",
           reinterpret_cast<uword>(obj),
           Object::Handle(obj).ToCString());
@@ skipping 123 matching lines @@
                          KindAsStr(iter.Kind()),
                          iter.DeoptId(),
                          iter.TokenPos().ToCString(),
                          iter.TryIndex());
   }
   return buffer;
 #undef FORMAT
 }
 
 
-void PcDescriptors::PrintToJSONObject(JSONObject* jsobj, bool ref) const {
-  AddCommonObjectProperties(jsobj, "Object", ref);
-  // TODO(johnmccutchan): Generate a stable id. PcDescriptors hang off a Code
-  // object but do not have a back reference to generate an ID.
-  jsobj->AddServiceId(*this);
-  if (ref) {
-    return;
-  }
-  JSONArray members(jsobj, "members");
-  Iterator iter(*this, RawPcDescriptors::kAnyKind);
-  while (iter.MoveNext()) {
-    JSONObject descriptor(&members);
-    descriptor.AddPropertyF("pcOffset", "%" Px "", iter.PcOffset());
-    descriptor.AddProperty("kind", KindAsStr(iter.Kind()));
-    descriptor.AddProperty("deoptId", iter.DeoptId());
-    // TODO(turnidge): Use AddLocation instead.
-    descriptor.AddProperty("tokenPos", iter.TokenPos());
-    descriptor.AddProperty("tryIndex", iter.TryIndex());
-  }
-}
-
-
-void PcDescriptors::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintToJSONObject(&jsobj, 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)
   // Only check ids for unoptimized code that is optimizable.
   if (!function.IsOptimizable()) {
     return;
@@ skipping 78 matching lines @@
                                       size,
                                       Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   return result.raw();
 }
 
 
-void CodeSourceMap::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
-}
-
-
 const char* CodeSourceMap::ToCString() const {
   // "*" in a printf format specifier tells it to read the field width from
   // the printf argument list.
 #define FORMAT "%#-*" Px "\t%s\n"
   if (Length() == 0) {
     return "empty CodeSourceMap\n";
   }
   // 4 bits per hex digit.
   const int addr_width = kBitsPerWord / 4;
   // First compute the buffer size required.
@@ skipping 154 matching lines @@
     for (intptr_t i = 0; i < Length(); i++) {
       chars[index++] = IsObject(i) ? '1' : '0';
     }
     chars[index] = '\0';
     return chars;
   }
 #undef FORMAT
 }
 
 
-void Stackmap::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
-}
-
-
 RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
   ASSERT(var_index < Length());
   ASSERT(Object::Handle(*raw()->nameAddrAt(var_index)).IsString());
   return *raw()->nameAddrAt(var_index);
 }
 
 
 void LocalVarDescriptors::SetVar(intptr_t var_index,
                                  const String& name,
                                  RawLocalVarDescriptors::VarInfo* info) const {
@@ skipping 76 matching lines @@
     var_name = GetName(i);
     GetInfo(i, &info);
     num_chars += PrintVarInfo((buffer + num_chars),
                               (len - num_chars),
                               i, var_name, info);
   }
   return buffer;
 }
 
 
-void LocalVarDescriptors::PrintJSONImpl(JSONStream* stream,
-                                        bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Object", ref);
-  // TODO(johnmccutchan): Generate a stable id. LocalVarDescriptors hang off
-  // a Code object but do not have a back reference to generate an ID.
-  jsobj.AddServiceId(*this);
-  if (ref) {
-    return;
-  }
-  JSONArray members(&jsobj, "members");
-  String& var_name = String::Handle();
-  for (intptr_t i = 0; i < Length(); i++) {
-    RawLocalVarDescriptors::VarInfo info;
-    var_name = GetName(i);
-    GetInfo(i, &info);
-    JSONObject var(&members);
-    var.AddProperty("name", var_name.ToCString());
-    var.AddProperty("index", static_cast<intptr_t>(info.index()));
-    var.AddProperty("beginPos", info.begin_pos);
-    var.AddProperty("endPos", info.end_pos);
-    var.AddProperty("scopeId", static_cast<intptr_t>(info.scope_id));
-    var.AddProperty("kind", KindToCString(info.kind()));
-  }
-}
-
-
 const char* LocalVarDescriptors::KindToCString(
     RawLocalVarDescriptors::VarInfoKind kind) {
   switch (kind) {
     case RawLocalVarDescriptors::kStackVar:
       return "StackVar";
     case RawLocalVarDescriptors::kContextVar:
       return "ContextVar";
     case RawLocalVarDescriptors::kContextLevel:
       return "ContextLevel";
     case RawLocalVarDescriptors::kSavedCurrentContext:
@@ skipping 209 matching lines @@
                                (len - num_chars),
                                FORMAT2, k, type.ToCString());
     }
   }
   return buffer;
 #undef FORMAT1
 #undef FORMAT2
 }
 
 
-void ExceptionHandlers::PrintJSONImpl(JSONStream* stream,
-                                      bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
-}
-
-
 intptr_t DeoptInfo::FrameSize(const TypedData& packed) {
   NoSafepointScope no_safepoint;
   typedef ReadStream::Raw<sizeof(intptr_t), intptr_t> Reader;
   ReadStream read_stream(reinterpret_cast<uint8_t*>(packed.DataAddr(0)),
                          packed.LengthInBytes());
   return Reader::Read(&read_stream);
 }
 
 
 intptr_t DeoptInfo::NumMaterializations(
@@ skipping 799 matching lines @@
       from.deopt_id(),
       from.NumArgsTested()));
   // Preserve entry array.
   result.set_ic_data_array(Array::Handle(zone, from.ic_data()));
   // Copy deoptimization reasons.
   result.SetDeoptReasons(from.DeoptReasons());
   return result.raw();
 }
 
 
-void ICData::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Object", ref);
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("_owner", Object::Handle(Owner()));
-  jsobj.AddProperty("_selector", String::Handle(target_name()).ToCString());
-  if (ref) {
-    return;
-  }
-  jsobj.AddProperty("_argumentsDescriptor",
-                    Object::Handle(arguments_descriptor()));
-  jsobj.AddProperty("_entries", Object::Handle(ic_data()));
-}
-
-
-void ICData::PrintToJSONArray(const JSONArray& jsarray,
-                              TokenPosition token_pos,
-                              bool is_static_call) const {
-  Isolate* isolate = Isolate::Current();
-  Class& cls = Class::Handle();
-  Function& func = Function::Handle();
-
-  JSONObject jsobj(&jsarray);
-  jsobj.AddProperty("name", String::Handle(target_name()).ToCString());
-  jsobj.AddProperty("tokenPos", token_pos);
-  // TODO(rmacnak): Figure out how to stringify DeoptReasons().
-  // jsobj.AddProperty("deoptReasons", ...);
-
-  JSONArray cache_entries(&jsobj, "cacheEntries");
-  for (intptr_t i = 0; i < NumberOfChecks(); i++) {
-    func = GetTargetAt(i);
-    if (is_static_call) {
-      cls ^= func.Owner();
-    } else {
-      intptr_t cid = GetReceiverClassIdAt(i);
-      cls ^= isolate->class_table()->At(cid);
-    }
-    intptr_t count = GetCountAt(i);
-    JSONObject cache_entry(&cache_entries);
-    if (cls.IsTopLevel()) {
-      cache_entry.AddProperty("receiverContainer",
-                              Library::Handle(cls.library()));
-    } else {
-      cache_entry.AddProperty("receiverContainer", cls);
-    }
-    cache_entry.AddProperty("count", count);
-    cache_entry.AddProperty("target", func);
-  }
-}
-
-
-void ICData::PrintToJSONArrayNew(const JSONArray& jsarray,
-                                 TokenPosition token_pos,
-                                 bool is_static_call) const {
-  Isolate* isolate = Isolate::Current();
-  Class& cls = Class::Handle();
-  Function& func = Function::Handle();
-
-  JSONObject jsobj(&jsarray);
-  jsobj.AddProperty("name", String::Handle(target_name()).ToCString());
-  jsobj.AddProperty("tokenPos", token_pos.value());
-  // TODO(rmacnak): Figure out how to stringify DeoptReasons().
-  // jsobj.AddProperty("deoptReasons", ...);
-
-  JSONArray cache_entries(&jsobj, "cacheEntries");
-  for (intptr_t i = 0; i < NumberOfChecks(); i++) {
-    JSONObject cache_entry(&cache_entries);
-    func = GetTargetAt(i);
-    intptr_t count = GetCountAt(i);
-    if (!is_static_call) {
-      intptr_t cid = GetReceiverClassIdAt(i);
-      cls ^= isolate->class_table()->At(cid);
-      cache_entry.AddProperty("receiver", cls);
-    }
-    cache_entry.AddProperty("target", func);
-    cache_entry.AddProperty("count", count);
-  }
-}
-
-
 static Token::Kind RecognizeArithmeticOp(const String& name) {
   ASSERT(name.IsSymbol());
   if (name.raw() == Symbols::Plus().raw()) {
     return Token::kADD;
   } else if (name.raw() == Symbols::Minus().raw()) {
     return Token::kSUB;
   } else if (name.raw() == Symbols::Star().raw()) {
     return Token::kMUL;
   } else if (name.raw() == Symbols::Slash().raw()) {
     return Token::kDIV;
@@ skipping 181 matching lines @@
   for (intptr_t i = kSCallTableEntryLength;
       i < value.Length();
       i += kSCallTableEntryLength) {
     ASSERT(value.At(i - kSCallTableEntryLength) < value.At(i));
   }
 #endif  // DEBUG
 }
 
 
 bool Code::HasBreakpoint() const {
+  if (!FLAG_support_debugger) {
+    return false;
+  }
   return Isolate::Current()->debugger()->HasBreakpoint(*this);
 }
 
 
 RawTypedData* Code::GetDeoptInfoAtPc(uword pc,
                                      ICData::DeoptReasonId* deopt_reason,
                                      uint32_t* deopt_flags) const {
   ASSERT(is_optimized());
   const Instructions& instrs = Instructions::Handle(instructions());
   uword code_entry = instrs.EntryPoint();
@@ skipping 526 matching lines @@
   DEBUG_ASSERT(IsMutatorOrAtSafepoint() || !is_alive());
   // RawInstructions are never allocated in New space and hence a
   // store buffer update is not needed here.
   StorePointer(&raw_ptr()->active_instructions_, instructions);
   StoreNonPointer(&raw_ptr()->entry_point_,
                   reinterpret_cast<uword>(instructions->ptr()) +
                   Instructions::HeaderSize());
 }
 
 
-void Code::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Code", ref);
-  jsobj.AddFixedServiceId("code/%" Px64"-%" Px "",
-                          compile_timestamp(),
-                          EntryPoint());
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  const bool is_stub = IsStubCode() || IsAllocationStubCode();
-  if (is_stub) {
-    jsobj.AddProperty("kind", "Stub");
-  } else {
-    jsobj.AddProperty("kind", "Dart");
-  }
-  jsobj.AddProperty("_optimized", is_optimized());
-  const Object& obj = Object::Handle(owner());
-  if (obj.IsFunction()) {
-    const Function& func = Function::Cast(obj);
-    jsobj.AddProperty("_intrinsic", func.is_intrinsic());
-    jsobj.AddProperty("_native", func.is_native());
-  } else {
-    jsobj.AddProperty("_intrinsic", false);
-    jsobj.AddProperty("_native", false);
-  }
-  if (ref) {
-    return;
-  }
-  if (obj.IsFunction()) {
-    jsobj.AddProperty("function", obj);
-  } else {
-    // Generate a fake function reference.
-    JSONObject func(&jsobj, "function");
-    func.AddProperty("type", "@Function");
-    func.AddProperty("_kind", "Stub");
-    func.AddProperty("name", user_name.ToCString());
-    AddNameProperties(&func, user_name, vm_name);
-  }
-  jsobj.AddPropertyF("_startAddress", "%" Px "", EntryPoint());
-  jsobj.AddPropertyF("_endAddress", "%" Px "", EntryPoint() + Size());
-  jsobj.AddProperty("_alive", is_alive());
-  const ObjectPool& object_pool = ObjectPool::Handle(GetObjectPool());
-  jsobj.AddProperty("_objectPool", object_pool);
-  {
-    JSONArray jsarr(&jsobj, "_disassembly");
-    if (is_alive()) {
-      // Only disassemble alive code objects.
-      DisassembleToJSONStream formatter(jsarr);
-      Disassemble(&formatter);
-    }
-  }
-  const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
-  if (!descriptors.IsNull()) {
-    JSONObject desc(&jsobj, "_descriptors");
-    descriptors.PrintToJSONObject(&desc, false);
-  }
-  const Array& inlined_function_table = Array::Handle(GetInlinedIdToFunction());
-  if (!inlined_function_table.IsNull() &&
-      (inlined_function_table.Length() > 0)) {
-    JSONArray inlined_functions(&jsobj, "_inlinedFunctions");
-    Function& function = Function::Handle();
-    for (intptr_t i = 0; i < inlined_function_table.Length(); i++) {
-      function ^= inlined_function_table.At(i);
-      ASSERT(!function.IsNull());
-      inlined_functions.AddValue(function);
-    }
-  }
-  const Array& intervals = Array::Handle(GetInlinedIntervals());
-  if (!intervals.IsNull() && (intervals.Length() > 0)) {
-    Smi& start = Smi::Handle();
-    Smi& end = Smi::Handle();
-    Smi& temp_smi = Smi::Handle();
-    JSONArray inline_intervals(&jsobj, "_inlinedIntervals");
-    for (intptr_t i = 0; i < intervals.Length() - Code::kInlIntNumEntries;
-         i += Code::kInlIntNumEntries) {
-      start ^= intervals.At(i + Code::kInlIntStart);
-      if (start.IsNull()) {
-        continue;
-      }
-      end ^= intervals.At(i + Code::kInlIntNumEntries + Code::kInlIntStart);
-
-      // Format: [start, end, inline functions...]
-      JSONArray inline_interval(&inline_intervals);
-      inline_interval.AddValue(start.Value());
-      inline_interval.AddValue(end.Value());
-
-      temp_smi ^= intervals.At(i + Code::kInlIntInliningId);
-      intptr_t inlining_id = temp_smi.Value();
-      ASSERT(inlining_id >= 0);
-      intptr_t caller_id = GetCallerId(inlining_id);
-      while (inlining_id >= 0) {
-        inline_interval.AddValue(inlining_id);
-        inlining_id = caller_id;
-        caller_id = GetCallerId(inlining_id);
-      }
-    }
-  }
-}
-
-
 uword Code::GetLazyDeoptPc() const {
   return (lazy_deopt_pc_offset() != kInvalidPc)
       ? EntryPoint() + lazy_deopt_pc_offset() : 0;
 }
 
 
 RawStackmap* Code::GetStackmap(
     uint32_t pc_offset, Array* maps, Stackmap* map) const {
   // This code is used during iterating frames during a GC and hence it
   // should not in turn start a GC.
@@ skipping 190 matching lines @@
 
   const Context& parent_ctx = Context::Handle(parent());
   if (!parent_ctx.IsNull()) {
     parent_ctx.Dump(indent + 2);
   }
   IndentN(indent);
   THR_Print("}\n");
 }
 
 
-void Context::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  // TODO(turnidge): Should the user level type for Context be Context
-  // or Object?
-  AddCommonObjectProperties(&jsobj, "Context", ref);
-  jsobj.AddServiceId(*this);
-
-  jsobj.AddProperty("length", num_variables());
-
-  if (ref) {
-    return;
-  }
-
-  const Context& parent_context = Context::Handle(parent());
-  if (!parent_context.IsNull()) {
-    jsobj.AddProperty("parent", parent_context);
-  }
-
-  JSONArray jsarr(&jsobj, "variables");
-  Object& var = Object::Handle();
-  for (intptr_t index = 0; index < num_variables(); index++) {
-    var = At(index);
-    JSONObject jselement(&jsarr);
-    jselement.AddProperty("value", var);
-  }
-}
-
-
 RawContextScope* ContextScope::New(intptr_t num_variables, bool is_implicit) {
   ASSERT(Object::context_scope_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ContextScope::New: invalid num_variables %" Pd "\n",
            num_variables);
   }
   intptr_t size = ContextScope::InstanceSize(num_variables);
   ContextScope& result = ContextScope::Handle();
   {
@@ skipping 113 matching lines @@
     intptr_t lvl = ContextLevelAt(i);
     char* chars = OS::SCreate(Thread::Current()->zone(),
         "%s\nvar %s  token-pos %s  ctx lvl %" Pd "  index %" Pd "",
         prev_cstr, cname, pos.ToCString(), lvl, idx);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
-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 120 matching lines @@
 }
 
 
 const char* MegamorphicCache::ToCString() const {
   const String& name = String::Handle(target_name());
   return OS::SCreate(Thread::Current()->zone(),
                      "MegamorphicCache(%s)", name.ToCString());
 }
 
 
-void MegamorphicCache::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Object", ref);
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("_selector", String::Handle(target_name()).ToCString());
-  if (ref) {
-    return;
-  }
-  jsobj.AddProperty("_buckets", Object::Handle(buckets()));
-  jsobj.AddProperty("_mask", mask());
-  jsobj.AddProperty("_argumentsDescriptor",
-                    Object::Handle(arguments_descriptor()));
-}
-
-
 RawSubtypeTestCache* SubtypeTestCache::New() {
   ASSERT(Object::subtypetestcache_class() != Class::null());
   SubtypeTestCache& result = SubtypeTestCache::Handle();
   {
     // SubtypeTestCache objects are long living objects, allocate them in the
     // old generation.
     RawObject* raw = Object::Allocate(SubtypeTestCache::kClassId,
                                       SubtypeTestCache::InstanceSize(),
                                       Heap::kOld);
     NoSafepointScope no_safepoint;
@@ skipping 51 matching lines @@
       data.At(data_pos + kInstantiatorTypeArguments);
   *test_result ^= data.At(data_pos + kTestResult);
 }
 
 
 const char* SubtypeTestCache::ToCString() const {
   return "SubtypeTestCache";
 }
 
 
-void SubtypeTestCache::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::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);
 }
 
 
 RawApiError* ApiError::New(const String& message, Heap::Space space) {
@@ skipping 20 matching lines @@
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* ApiError::ToCString() const {
   return "ApiError";
 }
 
 
-void ApiError::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Error", ref);
-  jsobj.AddProperty("kind", "InternalError");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("message", ToErrorCString());
-}
-
-
 RawLanguageError* LanguageError::New() {
   ASSERT(Object::language_error_class() != Class::null());
   RawObject* raw = Object::Allocate(LanguageError::kClassId,
                                     LanguageError::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLanguageError*>(raw);
 }
 
 
 RawLanguageError* LanguageError::NewFormattedV(const Error& prev_error,
@@ skipping 121 matching lines @@
   const String& msg_str = String::Handle(FormatMessage());
   return msg_str.ToCString();
 }
 
 
 const char* LanguageError::ToCString() const {
   return "LanguageError";
 }
 
 
-void LanguageError::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Error", ref);
-  jsobj.AddProperty("kind", "LanguageError");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("message", ToErrorCString());
-}
-
-
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
     RawObject* raw = Object::Allocate(UnhandledException::kClassId,
                                       UnhandledException::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
@@ skipping 60 matching lines @@
   return OS::SCreate(thread->zone(),
       "Unhandled exception:\n%s\n%s", exc_str, stack_str);
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
-
-void UnhandledException::PrintJSONImpl(JSONStream* stream,
-                                       bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Error", ref);
-  jsobj.AddProperty("kind", "UnhandledException");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("message", ToErrorCString());
-  if (ref) {
-    return;
-  }
-  Instance& instance = Instance::Handle();
-  instance = exception();
-  jsobj.AddProperty("exception", instance);
-  instance = stacktrace();
-  jsobj.AddProperty("stacktrace", instance);
-}
-
-
 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);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
@@ skipping 23 matching lines @@
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* UnwindError::ToCString() const {
   return "UnwindError";
 }
 
 
-void UnwindError::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  AddCommonObjectProperties(&jsobj, "Error", ref);
-  jsobj.AddProperty("kind", "TerminationError");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("message", ToErrorCString());
-  jsobj.AddProperty("_is_user_initiated", is_user_initiated());
-  jsobj.AddProperty("_is_vm_restart", is_vm_restart());
-}
-
-
 RawObject* Instance::Evaluate(const String& expr,
                               const Array& param_names,
                               const Array& param_values) const {
   const Class& cls = Class::Handle(clazz());
   const Function& eval_func =
       Function::Handle(EvaluateHelper(cls, expr, param_names, false));
   const Array& args = Array::Handle(Array::New(1 + param_values.Length()));
   PassiveObject& param = PassiveObject::Handle();
   args.SetAt(0, *this);
   for (intptr_t i = 0; i < param_values.Length(); i++) {
@@ skipping 522 matching lines @@
     }
     const Type& type = Type::Handle(
         Type::New(cls, type_arguments, TokenPosition::kNoSource));
     const String& type_name = String::Handle(type.UserVisibleName());
     return OS::SCreate(Thread::Current()->zone(),
         "Instance of '%s'", type_name.ToCString());
   }
 }
 
 
-void Instance::PrintSharedInstanceJSON(JSONObject* jsobj,
-                                       bool ref) const {
-  AddCommonObjectProperties(jsobj, "Instance", ref);
-  if (ref) {
-    return;
-  }
-
-  // Walk the superclass chain, adding all instance fields.
-  Class& cls = Class::Handle(this->clazz());
-  {
-    Instance& fieldValue = Instance::Handle();
-    JSONArray jsarr(jsobj, "fields");
-    while (!cls.IsNull()) {
-      const Array& field_array = Array::Handle(cls.fields());
-      Field& field = Field::Handle();
-      if (!field_array.IsNull()) {
-        for (intptr_t i = 0; i < field_array.Length(); i++) {
-          field ^= field_array.At(i);
-          if (!field.is_static()) {
-            fieldValue ^= GetField(field);
-            JSONObject jsfield(&jsarr);
-            jsfield.AddProperty("type", "BoundField");
-            jsfield.AddProperty("decl", field);
-            jsfield.AddProperty("value", fieldValue);
-          }
-        }
-      }
-      cls = cls.SuperClass();
-    }
-  }
-
-  if (NumNativeFields() > 0) {
-    JSONArray jsarr(jsobj, "_nativeFields");
-    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::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-
-  // Handle certain special instance values.
-  if (raw() == Object::sentinel().raw()) {
-    jsobj.AddProperty("type", "Sentinel");
-    jsobj.AddProperty("kind", "NotInitialized");
-    jsobj.AddProperty("valueAsString", "<not initialized>");
-    return;
-  } else if (raw() == Object::transition_sentinel().raw()) {
-    jsobj.AddProperty("type", "Sentinel");
-    jsobj.AddProperty("kind", "BeingInitialized");
-    jsobj.AddProperty("valueAsString", "<being initialized>");
-    return;
-  }
-
-  PrintSharedInstanceJSON(&jsobj, ref);
-  if (IsClosure()) {
-    jsobj.AddProperty("kind", "Closure");
-  } else {
-    jsobj.AddProperty("kind", "PlainInstance");
-  }
-  jsobj.AddServiceId(*this);
-  if (IsClosure()) {
-    jsobj.AddProperty("closureFunction",
-                      Function::Handle(Closure::Cast(*this).function()));
-    jsobj.AddProperty("closureContext",
-                      Context::Handle(Closure::Cast(*this).context()));
-  }
-  if (ref) {
-    return;
-  }
-  if (IsClosure()) {
-    Debugger* debugger = Isolate::Current()->debugger();
-    Breakpoint* bpt = debugger->BreakpointAtActivation(*this);
-    if (bpt != NULL) {
-      jsobj.AddProperty("_activationBreakpoint", bpt);
-    }
-  }
-}
-
-
 bool AbstractType::IsResolved() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 void AbstractType::SetIsResolved() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
@@ skipping 531 matching lines @@
 }
 
 
 const char* AbstractType::ToCString() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return "AbstractType";
 }
 
 
-void AbstractType::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  UNREACHABLE();
-}
-
-
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
 RawType* Type::DynamicType() {
   return Object::dynamic_type().raw();
 }
 
 
@@ skipping 576 matching lines @@
         "Type: (@%p H%" Px ") class '%s', args:[%s]",
         raw(), hash, class_name, args_cstr);
   } else {
     const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
     return OS::SCreate(Thread::Current()->zone(),
         "%sType: class '%s', args:[%s]", unresolved, class_name, args_cstr);
   }
 }
 
 
-void Type::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Type");
-  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.AddFixedServiceId("classes/%" Pd "/types/%" Pd "", cid, id);
-    jsobj.AddProperty("typeClass", type_cls);
-  } else {
-    jsobj.AddServiceId(*this);
-  }
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  if (ref) {
-    return;
-  }
-  const TypeArguments& typeArgs = TypeArguments::Handle(arguments());
-  if (!typeArgs.IsNull()) {
-    jsobj.AddProperty("typeArguments", typeArgs);
-  }
-}
-
-
 void FunctionType::SetIsFinalized() const {
   ASSERT(!IsFinalized());
   if (IsInstantiated()) {
     set_type_state(RawFunctionType::kFinalizedInstantiated);
   } else {
     set_type_state(RawFunctionType::kFinalizedUninstantiated);
   }
 }
 
 
@@ skipping 499 matching lines @@
   return OS::SCreate(
       Thread::Current()->zone(),
       "%s FunctionType: %s (scope_cls: %s, args: %s)",
       unresolved,
       signature_string.ToCString(),
       class_name,
       args_cstr);
 }
 
 
-void FunctionType::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "FunctionType");
-  if (IsCanonical()) {
-    const Class& scope_cls = Class::Handle(scope_class());
-    intptr_t id = scope_cls.FindCanonicalTypeIndex(*this);
-    ASSERT(id >= 0);
-    intptr_t cid = scope_cls.id();
-    jsobj.AddFixedServiceId("classes/%" Pd "/types/%" Pd "", cid, id);
-    jsobj.AddProperty("scopeClass", scope_cls);
-  } else {
-    jsobj.AddServiceId(*this);
-  }
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  if (ref) {
-    return;
-  }
-  const TypeArguments& typeArgs = TypeArguments::Handle(arguments());
-  if (!typeArgs.IsNull()) {
-    jsobj.AddProperty("typeArguments", typeArgs);
-  }
-}
-
-
 bool TypeRef::IsInstantiated(TrailPtr trail) const {
   if (TestAndAddToTrail(&trail)) {
     return true;
   }
   return AbstractType::Handle(type()).IsInstantiated(trail);
 }
 
 
 bool TypeRef::IsEquivalent(const Instance& other, TrailPtr trail) const {
   if (raw() == other.raw()) {
@@ skipping 140 matching lines @@
     const intptr_t hash = ref_type.Hash();
     return OS::SCreate(Thread::Current()->zone(),
         "TypeRef: %s<...> (@%p H%" Px ")", type_cstr, ref_type.raw(), hash);
   } else {
     return OS::SCreate(Thread::Current()->zone(),
         "TypeRef: %s<...>", type_cstr);
   }
 }
 
 
-void TypeRef::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "TypeRef");
-  jsobj.AddServiceId(*this);
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  if (ref) {
-    return;
-  }
-  jsobj.AddProperty("targetType", AbstractType::Handle(type()));
-}
-
-
 void TypeParameter::SetIsFinalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
 bool TypeParameter::IsEquivalent(const Instance& other, TrailPtr trail) const {
   if (raw() == other.raw()) {
     return true;
   }
@@ skipping 201 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 = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr, bound_cstr);
   return chars;
 }
 
 
-void TypeParameter::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "TypeParameter");
-  jsobj.AddServiceId(*this);
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  const Class& param_cls = Class::Handle(parameterized_class());
-  jsobj.AddProperty("parameterizedClass", param_cls);
-  if (ref) {
-    return;
-  }
-  jsobj.AddProperty("parameterIndex", index());
-  const AbstractType& upper_bound = AbstractType::Handle(bound());
-  jsobj.AddProperty("bound", upper_bound);
-}
-
-
 bool BoundedType::IsMalformed() const {
   return AbstractType::Handle(type()).IsMalformed();
 }
 
 
 bool BoundedType::IsMalbounded() const {
   return AbstractType::Handle(type()).IsMalbounded();
 }
 
 
@@ skipping 192 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 = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(
       chars, len, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr);
   return chars;
 }
 
 
-void BoundedType::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "BoundedType");
-  jsobj.AddServiceId(*this);
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
-  if (ref) {
-    return;
-  }
-  jsobj.AddProperty("targetType", AbstractType::Handle(type()));
-  jsobj.AddProperty("bound", AbstractType::Handle(bound()));
-}
-
-
 TokenPosition MixinAppType::token_pos() const {
   return AbstractType::Handle(MixinTypeAt(0)).token_pos();
 }
 
 
 intptr_t MixinAppType::Depth() const {
   return Array::Handle(mixin_types()).Length();
 }
 
 
 RawString* MixinAppType::Name() const {
   return String::New("MixinAppType");
 }
 
 
 const char* MixinAppType::ToCString() const {
   const char* format = "MixinAppType: super type: %s; first mixin type: %s";
   const char* super_type_cstr = String::Handle(AbstractType::Handle(
       super_type()).Name()).ToCString();
   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 = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
   return chars;
 }
 
 
-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 {
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
@@ skipping 21 matching lines @@
 }
 
 
 const char* Number::ToCString() const {
   // Number is an interface. No instances of Number should exist.
   UNREACHABLE();
   return "Number";
 }
 
 
-void Number::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  UNREACHABLE();
-}
-
-
 const char* Integer::ToCString() const {
   // Integer is an interface. No instances of Integer should exist except null.
   ASSERT(IsNull());
   return "NULL Integer";
 }
 
 
-void Integer::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Int");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("valueAsString", ToCString());
-}
-
-
 // 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 399 matching lines @@
   UNREACHABLE();
   return 0;
 }
 
 
 const char* Smi::ToCString() const {
   return OS::SCreate(Thread::Current()->zone(), "%" Pd "", Value());
 }
 
 
-void Smi::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Int");
-  jsobj.AddFixedServiceId("objects/int-%" Pd "", Value());
-  jsobj.AddPropertyF("valueAsString", "%" Pd "", Value());
-}
-
-
 RawClass* Smi::Class() {
   return Isolate::Current()->object_store()->smi_class();
 }
 
 
 void Mint::set_value(int64_t value) const {
   StoreNonPointer(&raw_ptr()->value_, value);
 }
 
 
@@ skipping 97 matching lines @@
   }
   return this->IsNegative() ? -1 : 1;
 }
 
 
 const char* Mint::ToCString() const {
   return OS::SCreate(Thread::Current()->zone(), "%" Pd64 "", value());
 }
 
 
-void Mint::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Integer::PrintJSONImpl(stream, ref);
-}
-
-
 void Double::set_value(double value) const {
   StoreNonPointer(&raw_ptr()->value_, value);
 }
 
 
 bool Double::BitwiseEqualsToDouble(double value) const {
   intptr_t value_offset = Double::value_offset();
   void* this_addr = reinterpret_cast<void*>(
       reinterpret_cast<uword>(this->raw_ptr()) + value_offset);
   void* other_addr = reinterpret_cast<void*>(&value);
@@ skipping 107 matching lines @@
     return value() < 0 ? "-Infinity" : "Infinity";
   }
   const int kBufferSize = 128;
   char* buffer = Thread::Current()->zone()->Alloc<char>(kBufferSize);
   buffer[kBufferSize - 1] = '\0';
   DoubleToCString(value(), buffer, kBufferSize);
   return buffer;
 }
 
 
-void Double::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Double");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("valueAsString", ToCString());
-}
-
-
 bool Bigint::Neg() const {
   return Bool::Handle(neg()).value();
 }
 
 
 void Bigint::SetNeg(bool value) const {
   StorePointer(&raw_ptr()->neg_, Bool::Get(value).raw());
 }
 
 
@@ skipping 727 matching lines @@
   Zone* zone = Thread::Current()->zone();
   return zone->AllocUnsafe(size);
 }
 
 
 const char* Bigint::ToCString() const {
   return ToDecCString(&BigintAllocator);
 }
 
 
-void Bigint::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Integer::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);
   }
   void Add(const String& str, intptr_t begin_index, intptr_t len);
 
   // Return a non-zero hash of at most 'bits' bits.
@@ skipping 810 matching lines @@
   }
   const intptr_t len = Utf8::Length(*this);
   Zone* zone = Thread::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::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", "Sentinel");
-    jsobj.AddProperty("kind", "OptimizedOut");
-    jsobj.AddProperty("valueAsString", "<optimized out>");
-    return;
-  }
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "String");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("length", Length());
-  if (ref) {
-    // String refs always truncate to a fixed count;
-    const intptr_t kFixedCount = 128;
-    if (jsobj.AddPropertyStr("valueAsString", *this, 0, kFixedCount)) {
-      jsobj.AddProperty("count", kFixedCount);
-      jsobj.AddProperty("valueAsStringIsTruncated", true);
-    }
-    return;
-  }
-
-  intptr_t offset;
-  intptr_t count;
-  stream->ComputeOffsetAndCount(Length(), &offset, &count);
-  if (offset > 0) {
-    jsobj.AddProperty("offset", offset);
-  }
-  if (count < Length()) {
-    jsobj.AddProperty("count", count);
-  }
-  jsobj.AddPropertyStr("valueAsString", *this, offset, count);
-}
-
-
 void String::ToUTF8(uint8_t* utf8_array, intptr_t array_len) const {
   ASSERT(array_len >= Utf8::Length(*this));
   Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
 }
 
 
 static FinalizablePersistentHandle* AddFinalizer(
     const Object& referent,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
@@ skipping 869 matching lines @@
   result.SetCanonical();
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
   return value() ? "true" : "false";
 }
 
 
-void Bool::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  const char* str = ToCString();
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Bool");
-  jsobj.AddFixedServiceId("objects/bool-%s", str);
-  jsobj.AddPropertyF("valueAsString", "%s", str);
-}
-
-
 bool Array::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   // An Array may be compared to an ImmutableArray.
   if (!other.IsArray() || other.IsNull()) {
     return false;
   }
@@ skipping 82 matching lines @@
   if (IsNull()) {
     return IsImmutable() ? "_ImmutableList NULL" : "_List NULL";
   }
   Zone* zone = Thread::Current()->zone();
   const char* format = IsImmutable() ? "_ImmutableList len:%" Pd
                                      : "_List len:%" Pd;
   return zone->PrintToString(format, Length());
 }
 
 
-void Array::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "List");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("length", Length());
-  if (ref) {
-    return;
-  }
-  intptr_t offset;
-  intptr_t count;
-  stream->ComputeOffsetAndCount(Length(), &offset, &count);
-  if (offset > 0) {
-    jsobj.AddProperty("offset", offset);
-  }
-  if (count < Length()) {
-    jsobj.AddProperty("count", count);
-  }
-  intptr_t limit = offset + count;
-  ASSERT(limit <= Length());
-  {
-    JSONArray jsarr(&jsobj, "elements");
-    Object& element = Object::Handle();
-    for (intptr_t index = offset; index < limit; index++) {
-      element = At(index);
-      jsarr.AddValue(element);
-    }
-  }
-}
-
-
 RawArray* Array::Grow(const Array& source,
                       intptr_t new_length,
                       Heap::Space space) {
   Zone* zone = Thread::Current()->zone();
   const Array& result = Array::Handle(zone, Array::New(new_length, space));
   intptr_t len = 0;
   if (!source.IsNull()) {
     len = source.Length();
     result.SetTypeArguments(
         TypeArguments::Handle(zone, source.GetTypeArguments()));
@@ skipping 197 matching lines @@
 
 const char* GrowableObjectArray::ToCString() const {
   if (IsNull()) {
     return "_GrowableList NULL";
   }
   return OS::SCreate(Thread::Current()->zone(),
       "Instance(length:%" Pd ") of '_GrowableList'", Length());
 }
 
 
-void GrowableObjectArray::PrintJSONImpl(JSONStream* stream,
-                                        bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "List");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("length", Length());
-  if (ref) {
-    return;
-  }
-  intptr_t offset;
-  intptr_t count;
-  stream->ComputeOffsetAndCount(Length(), &offset, &count);
-  if (offset > 0) {
-    jsobj.AddProperty("offset", offset);
-  }
-  if (count < Length()) {
-    jsobj.AddProperty("count", count);
-  }
-  intptr_t limit = offset + count;
-  ASSERT(limit <= Length());
-  {
-    JSONArray jsarr(&jsobj, "elements");
-    Object& element = Object::Handle();
-    for (intptr_t index = offset; index < limit; index++) {
-      element = At(index);
-      jsarr.AddValue(element);
-    }
-  }
-}
-
-
 // Equivalent to Dart's operator "==" and hashCode.
 class DefaultHashTraits {
  public:
   static bool IsMatch(const Object& a, const Object& b) {
     if (a.IsNull() || b.IsNull()) {
       return (a.IsNull() && b.IsNull());
     } else {
       return Instance::Cast(a).OperatorEquals(Instance::Cast(b));
     }
   }
@@ skipping 66 matching lines @@
   return result.raw();
 }
 
 
 const char* LinkedHashMap::ToCString() const {
   Zone* zone = Thread::Current()->zone();
   return zone->PrintToString("_LinkedHashMap len:%" Pd, Length());
 }
 
 
-void LinkedHashMap::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Map");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("length", Length());
-  if (ref) {
-    return;
-  }
-  intptr_t offset;
-  intptr_t count;
-  stream->ComputeOffsetAndCount(Length(), &offset, &count);
-  if (offset > 0) {
-    jsobj.AddProperty("offset", offset);
-  }
-  if (count < Length()) {
-    jsobj.AddProperty("count", count);
-  }
-  intptr_t limit = offset + count;
-  ASSERT(limit <= Length());
-  {
-    JSONArray jsarr(&jsobj, "associations");
-    Object& object = Object::Handle();
-    LinkedHashMap::Iterator iterator(*this);
-    int i = 0;
-    while (iterator.MoveNext() && i < limit) {
-      if (i >= offset) {
-        JSONObject jsassoc(&jsarr);
-        object = iterator.CurrentKey();
-        jsassoc.AddProperty("key", object);
-        object = iterator.CurrentValue();
-        jsassoc.AddProperty("value", object);
-      }
-      i++;
-    }
-  }
-}
-
-
 RawFloat32x4* Float32x4::New(float v0, float v1, float v2, float v3,
                              Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
          Class::null());
   Float32x4& result = Float32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Float32x4::kClassId,
                                       Float32x4::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
@@ skipping 76 matching lines @@
 const char* Float32x4::ToCString() const {
   float _x = x();
   float _y = y();
   float _z = z();
   float _w = w();
   return OS::SCreate(Thread::Current()->zone(),
       "[%f, %f, %f, %f]", _x, _y, _z, _w);
 }
 
 
-void Float32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Float32x4");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("valueAsString", ToCString());
-}
-
-
 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,
                                       Int32x4::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
@@ skipping 76 matching lines @@
 const char* Int32x4::ToCString() const {
   int32_t _x = x();
   int32_t _y = y();
   int32_t _z = z();
   int32_t _w = w();
   return OS::SCreate(Thread::Current()->zone(),
       "[%08x, %08x, %08x, %08x]", _x, _y, _z, _w);
 }
 
 
-void Int32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Int32x4");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("valueAsString", ToCString());
-}
-
-
 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(),
                                       space);
     NoSafepointScope no_safepoint;
     result ^= raw;
@@ skipping 50 matching lines @@
 }
 
 
 const char* Float64x2::ToCString() const {
   double _x = x();
   double _y = y();
   return OS::SCreate(Thread::Current()->zone(), "[%f, %f]", _x, _y);
 }
 
 
-void Float64x2::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "Float64x2");
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("valueAsString", ToCString());
-}
-
-
 const intptr_t TypedData::element_size_table[TypedData::kNumElementSizes] = {
   1,   // kTypedDataInt8ArrayCid.
   1,   // kTypedDataUint8ArrayCid.
   1,   // kTypedDataUint8ClampedArrayCid.
   2,   // kTypedDataInt16ArrayCid.
   2,   // kTypedDataUint16ArrayCid.
   4,   // kTypedDataInt32ArrayCid.
   4,   // kTypedDataUint32ArrayCid.
   8,   // kTypedDataInt64ArrayCid.
   8,   // kTypedDataUint64ArrayCid.
@@ skipping 68 matching lines @@
   isolate->object_store()->set_empty_uint32_array(array);
   return array.raw();
 }
 
 
 const char* TypedData::ToCString() const {
   return "TypedData";
 }
 
 
-void TypedData::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  const Class& cls = Class::Handle(clazz());
-  const String& kind = String::Handle(cls.UserVisibleName());
-  jsobj.AddProperty("kind", kind.ToCString());
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("length", Length());
-  if (ref) {
-    return;
-  }
-  intptr_t offset;
-  intptr_t count;
-  stream->ComputeOffsetAndCount(Length(), &offset, &count);
-  if (offset > 0) {
-    jsobj.AddProperty("offset", offset);
-  }
-  if (count < Length()) {
-    jsobj.AddProperty("count", count);
-  }
-  if (count == 0) {
-    jsobj.AddProperty("bytes", "");
-  } else {
-    NoSafepointScope no_safepoint;
-    jsobj.AddPropertyBase64("bytes",
-                            reinterpret_cast<const uint8_t*>(
-                                DataAddr(offset * ElementSizeInBytes())),
-                            count * ElementSizeInBytes());
-  }
-}
-
-
 FinalizablePersistentHandle* ExternalTypedData::AddFinalizer(
     void* peer, Dart_WeakPersistentHandleFinalizer callback) const {
   return dart::AddFinalizer(*this, peer, callback);
 }
 
 
 RawExternalTypedData* ExternalTypedData::New(intptr_t class_id,
                                              uint8_t* data,
                                              intptr_t len,
                                              Heap::Space space) {
   ExternalTypedData& result = ExternalTypedData::Handle();
   {
     RawObject* raw = Object::Allocate(class_id,
                                       ExternalTypedData::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetData(data);
   }
   return result.raw();
 }
 
 
 const char* ExternalTypedData::ToCString() const {
   return "ExternalTypedData";
 }
 
 
-void ExternalTypedData::PrintJSONImpl(JSONStream* stream,
-                                      bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  const Class& cls = Class::Handle(clazz());
-  const String& kind = String::Handle(cls.UserVisibleName());
-  jsobj.AddProperty("kind", kind.ToCString());
-  jsobj.AddServiceId(*this);
-  jsobj.AddProperty("length", Length());
-  if (ref) {
-    return;
-  }
-  intptr_t offset;
-  intptr_t count;
-  stream->ComputeOffsetAndCount(Length(), &offset, &count);
-  if (offset > 0) {
-    jsobj.AddProperty("offset", offset);
-  }
-  if (count < Length()) {
-    jsobj.AddProperty("count", count);
-  }
-  if (count == 0) {
-    jsobj.AddProperty("bytes", "");
-  } else {
-    NoSafepointScope no_safepoint;
-    jsobj.AddPropertyBase64("bytes",
-                            reinterpret_cast<const uint8_t*>(
-                                DataAddr(offset * ElementSizeInBytes())),
-                            count * ElementSizeInBytes());
-  }
-}
-
-
 RawCapability* Capability::New(uint64_t id, Heap::Space space) {
   Capability& result = Capability::Handle();
   {
     RawObject* raw = Object::Allocate(Capability::kClassId,
                                       Capability::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->id_, id);
   }
   return result.raw();
 }
 
 
 const char* Capability::ToCString() const {
   return "Capability";
 }
 
 
-void Capability::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Instance::PrintJSONImpl(stream, ref);
-}
-
-
 RawReceivePort* ReceivePort::New(Dart_Port id,
                                  bool is_control_port,
                                  Heap::Space space) {
   ASSERT(id != ILLEGAL_PORT);
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const SendPort& send_port =
       SendPort::Handle(zone, SendPort::New(id, thread->isolate()->origin_id()));
 
   ReceivePort& result = ReceivePort::Handle(zone);
@@ skipping 12 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* ReceivePort::ToCString() const {
   return "ReceivePort";
 }
 
 
-void ReceivePort::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Instance::PrintJSONImpl(stream, ref);
-}
-
-
 RawSendPort* SendPort::New(Dart_Port id, Heap::Space space) {
   return New(id, Isolate::Current()->origin_id(), space);
 }
 
 
 RawSendPort* SendPort::New(Dart_Port id,
                            Dart_Port origin_id,
                            Heap::Space space) {
   ASSERT(id != ILLEGAL_PORT);
   SendPort& result = SendPort::Handle();
   {
     RawObject* raw = Object::Allocate(SendPort::kClassId,
                                       SendPort::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->id_, id);
     result.StoreNonPointer(&result.raw_ptr()->origin_id_, origin_id);
   }
   return result.raw();
 }
 
 
 const char* SendPort::ToCString() const {
   return "SendPort";
 }
 
 
-void SendPort::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Instance::PrintJSONImpl(stream, ref);
-}
-
-
 const char* Closure::ToCString() const {
   const Function& fun = Function::Handle(function());
   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() : "";
   return OS::SCreate(Thread::Current()->zone(),
       "Closure: %s%s%s", fun_sig, from, fun_desc);
 }
 
 
-void Closure::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Instance::PrintJSONImpl(stream, ref);
-}
-
-
 RawClosure* Closure::New(const Function& function,
                          const Context& context,
                          Heap::Space space) {
   Closure& result = Closure::Handle();
   {
     RawObject* raw = Object::Allocate(Closure::kClassId,
                                       Closure::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
     result ^= raw;
@@ skipping 87 matching lines @@
   return result.raw();
 }
 
 
 const char* Stacktrace::ToCString() const {
   intptr_t idx = 0;
   return ToCStringInternal(&idx);
 }
 
 
-void Stacktrace::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "StackTrace");
-  jsobj.AddServiceId(*this);
-  intptr_t idx = 0;
-  jsobj.AddProperty("valueAsString", ToCStringInternal(&idx));
-}
-
-
 static intptr_t PrintOneStacktrace(Zone* zone,
                                    GrowableArray<char*>* frame_strings,
                                    uword pc,
                                    const Function& function,
                                    const Code& code,
                                    intptr_t frame_index) {
   const TokenPosition token_pos = code.GetTokenIndexOfPC(pc);
   const Script& script = Script::Handle(zone, function.script());
   const String& function_name =
       String::Handle(zone, function.QualifiedUserVisibleName());
@@ skipping 229 matching lines @@
 }
 
 
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   return OS::SCreate(Thread::Current()->zone(),
       "JSRegExp: pattern=%s flags=%s", str.ToCString(), Flags());
 }
 
 
-void JSRegExp::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "RegExp");
-  jsobj.AddServiceId(*this);
-
-  jsobj.AddProperty("pattern", String::Handle(pattern()));
-
-  if (ref) {
-    return;
-  }
-
-  jsobj.AddProperty("isCaseSensitive", !is_ignore_case());
-  jsobj.AddProperty("isMultiLine", is_multi_line());
-
-  Function& func = Function::Handle();
-  func = function(kOneByteStringCid);
-  jsobj.AddProperty("_oneByteFunction", func);
-  func = function(kTwoByteStringCid);
-  jsobj.AddProperty("_twoByteFunction", func);
-  func = function(kExternalOneByteStringCid);
-  jsobj.AddProperty("_externalOneByteFunction", func);
-  func = function(kExternalTwoByteStringCid);
-  jsobj.AddProperty("_externalTwoByteFunction", func);
-}
-
-
 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::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "WeakProperty");
-  jsobj.AddServiceId(*this);
-  if (ref) {
-    return;
-  }
-
-  const Object& key_handle = Object::Handle(key());
-  jsobj.AddProperty("propertyKey", key_handle);
-  const Object& value_handle = Object::Handle(value());
-  jsobj.AddProperty("propertyValue", value_handle);
-}
-
 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());
   return Class::Cast(Object::Handle(referent())).raw();
 }
@@ skipping 36 matching lines @@
   result.set_referent(referent);
   return result.raw();
 }
 
 
 const char* MirrorReference::ToCString() const {
   return "_MirrorReference";
 }
 
 
-void MirrorReference::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
-  PrintSharedInstanceJSON(&jsobj, ref);
-  jsobj.AddProperty("kind", "MirrorReference");
-  jsobj.AddServiceId(*this);
-
-  if (ref) {
-    return;
-  }
-
-  const Object& referent_handle = Object::Handle(referent());
-  jsobj.AddProperty("mirrorReferent", referent_handle);
-}
-
-
 void UserTag::MakeActive() const {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   isolate->set_current_tag(*this);
 }
 
 
 RawUserTag* UserTag::New(const String& label, Heap::Space space) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
@@ skipping 117 matching lines @@
   }
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
-
-void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Instance::PrintJSONImpl(stream, ref);
-}
-
-
 }  // namespace dart