Support displaying of types in the observatory (back-end only for now):

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 3907 matching lines @@
       if (!subclasses.IsNull()) {
         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);
         }
       }
     }
   }
+  {
+    JSONObject typesRef(&jsobj, "canonicalTypes");
+    typesRef.AddProperty("type", "@TypeList");
+    typesRef.AddPropertyF("id", "classes/%" Pd "/types", id());

[Cutch, 2014/03/19 23:13:31]

Need to add a name and user_name here.

[regis, 2014/03/19 23:47:41]

Done here and also for @TypeArgumentsList in isolate.cc.

+  }
 }
 
 
 void Class::InsertCanonicalConstant(intptr_t index,
                                     const Instance& constant) const {
   // The constant needs to be added to the list. Grow the list if it is full.
   Array& canonical_list = Array::Handle(constants());
   const intptr_t list_len = canonical_list.Length();
   if (index >= list_len) {
     const intptr_t new_length = (list_len == 0) ? 4 : list_len + 4;
@@ skipping 192 matching lines @@
     if (!type.TypeTest(test_kind, other_type, bound_error)) {
       return false;
     }
   }
   return true;
 }
 
 
 void TypeArguments::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  if (IsNull()) {
+    jsobj.AddProperty("type", ref ? "@Null" : "Null");
+    jsobj.AddProperty("id", "objects/null");
+    return;
+  }
+  // The index in the canonical_type_arguments table cannot be used as part of
+  // the object id (as in typearguments/id), because the indices are not
+  // preserved when the table grows and the entries get rehashed. Use the ring.
+  Isolate* isolate = Isolate::Current();
+  ObjectStore* object_store = isolate->object_store();
+  const Array& table = Array::Handle(object_store->canonical_type_arguments());
+  ASSERT(table.Length() > 0);
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  const intptr_t id = ring->GetIdForObject(raw());
+  jsobj.AddProperty("type", JSONType(ref));
+  jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  const char* name = String::Handle(Name()).ToCString();
+  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", name);
+  jsobj.AddProperty("user_name", user_name);
+  jsobj.AddProperty("length", Length());
+  jsobj.AddProperty("num_instantiations", NumInstantiations());
+  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;
 }
 
 
@@ skipping 8272 matching lines @@
   } else if (raw() == Symbols::OptimizedOut().raw()) {
     // TODO(turnidge): This is a hack.  The user could have this
     // special string in their program.  Fixing this involves updating
     // the debugging api a bit.
     jsobj.AddProperty("type", ref ? "@Null" : "Null");
     jsobj.AddProperty("id", "objects/optimized-out");
     jsobj.AddProperty("preview", "<optimized out>");
     return;
   } else {
     ObjectIdRing* ring = Isolate::Current()->object_id_ring();
-    intptr_t id = ring->GetIdForObject(raw());
+    const intptr_t id = ring->GetIdForObject(raw());
     if (IsClosure()) {
       const Function& closureFunc = Function::Handle(Closure::function(*this));
       jsobj.AddProperty("closureFunc", closureFunc);
       jsobj.AddProperty("type", ref ? "@Closure" : "Closure");
     } else {
       jsobj.AddProperty("type", JSONType(ref));
     }
     jsobj.AddPropertyF("id", "objects/%" Pd "", id);
     jsobj.AddProperty("class", cls);
     jsobj.AddProperty("preview", ToUserCString(40));
@@ skipping 429 matching lines @@
 
 
 const char* AbstractType::ToCString() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return "AbstractType";
 }
 
 
 void AbstractType::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  UNREACHABLE();
 }
 
 
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
 RawType* Type::DynamicType() {
   return Object::dynamic_type();
@@ skipping 520 matching lines @@
       OS::SNPrint(chars, len, format, class_name, args_cstr);
       return chars;
     }
   } else {
     return "Unresolved Type";
   }
 }
 
 
 void Type::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  ASSERT(IsCanonical());
   JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(ref));
+  const Class& type_cls = Class::Handle(type_class());
+  intptr_t id = type_cls.FindCanonicalTypeIndex(*this);
+  ASSERT(id >= 0);
+  intptr_t cid = type_cls.id();
+  jsobj.AddPropertyF("id", "classes/%" Pd "/types/%" Pd "", cid, id);
+  const char* name = String::Handle(Name()).ToCString();
+  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", name);
+  jsobj.AddProperty("user_name", user_name);
+  if (ref) {
+    return;
+  }
+  jsobj.AddProperty("type_class", type_cls);
+  jsobj.AddProperty("type_arguments", TypeArguments::Handle(arguments()));
 }
 
 
 bool TypeRef::IsInstantiated(GrowableObjectArray* trail) const {
   if (TestAndAddToTrail(&trail)) {
     return true;
   }
   return AbstractType::Handle(type()).IsInstantiated(trail);
 }
 
@@ skipping 148 matching lines @@
       type()).arguments() == TypeArguments::null()) ? "" : "<...>";
   intptr_t len = OS::SNPrint(NULL, 0, format, type_cstr, args_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, type_cstr, args_cstr);
   return chars;
 }
 
 
 void TypeRef::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  const intptr_t id = ring->GetIdForObject(raw());
+  jsobj.AddProperty("type", JSONType(ref));
+  jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  const char* name = String::Handle(Name()).ToCString();
+  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", name);
+  jsobj.AddProperty("user_name", user_name);
+  if (ref) {
+    return;
+  }
+  jsobj.AddProperty("ref_type", AbstractType::Handle(type()));
 }
 
 
 void TypeParameter::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
 bool TypeParameter::IsEquivalent(const Instance& other,
@@ skipping 184 matching lines @@
   intptr_t len = OS::SNPrint(
       NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr, bound_cstr);
   return chars;
 }
 
 
 void TypeParameter::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  const intptr_t id = ring->GetIdForObject(raw());
+  jsobj.AddProperty("type", JSONType(ref));
+  jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  const char* name = String::Handle(Name()).ToCString();
+  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", name);
+  jsobj.AddProperty("user_name", user_name);
+  const Class& cls = Class::Handle(parameterized_class());
+  jsobj.AddProperty("parameterized_class", cls);
+  if (ref) {
+    return;
+  }
+  jsobj.AddProperty("index", index());
+  const AbstractType& upper_bound = AbstractType::Handle(bound());
+  jsobj.AddProperty("upper_bound", upper_bound);
 }
 
 
 bool BoundedType::IsMalformed() const {
   return AbstractType::Handle(type()).IsMalformed();
 }
 
 
 bool BoundedType::IsMalbounded() const {
   return AbstractType::Handle(type()).IsMalbounded();
@@ skipping 161 matching lines @@
       NULL, 0, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(
       chars, len, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr);
   return chars;
 }
 
 
 void BoundedType::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  const intptr_t id = ring->GetIdForObject(raw());
+  jsobj.AddProperty("type", JSONType(ref));
+  jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  const char* name = String::Handle(Name()).ToCString();
+  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", name);
+  jsobj.AddProperty("user_name", user_name);
+  if (ref) {
+    return;
+  }
+  jsobj.AddProperty("bounded_type", AbstractType::Handle(type()));
+  jsobj.AddProperty("upper_bound", AbstractType::Handle(bound()));
 }
 
 
 intptr_t MixinAppType::token_pos() const {
   return AbstractType::Handle(MixinTypeAt(0)).token_pos();
 }
 
 
 intptr_t MixinAppType::Depth() const {
   return Array::Handle(mixin_types()).Length();
@@ skipping 13 matching lines @@
       MixinTypeAt(0)).Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, super_type_cstr, first_mixin_type_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
   return chars;
 }
 
 
 void MixinAppType::PrintToJSONStream(JSONStream* stream, bool ref) const {
-  JSONObject jsobj(stream);
+  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 2600 matching lines @@
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, Length());
   return chars;
 }
 
 
 void Array::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   Class& cls = Class::Handle(this->clazz());
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
-  intptr_t id = ring->GetIdForObject(raw());
+  const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   jsobj.AddProperty("class", cls);
   jsobj.AddProperty("length", Length());
   if (ref) {
     return;
   }
   {
     JSONArray jsarr(&jsobj, "elements");
     for (intptr_t index = 0; index < Length(); index++) {
@@ skipping 319 matching lines @@
   buffer[pos] = '\0';
   return buffer;
 }
 
 
 void GrowableObjectArray::PrintToJSONStream(JSONStream* stream,
                                             bool ref) const {
   JSONObject jsobj(stream);
   Class& cls = Class::Handle(this->clazz());
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
-  intptr_t id = ring->GetIdForObject(raw());
+  const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   jsobj.AddProperty("class", cls);
   jsobj.AddProperty("length", Length());
   if (ref) {
     return;
   }
   {
     JSONArray jsarr(&jsobj, "elements");
     for (intptr_t index = 0; index < Length(); index++) {
@@ skipping 857 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart