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 3216 matching lines @@
 RawObject* Class::canonical_types() const {
   return raw_ptr()->canonical_types_;
 }
 
 void Class::set_canonical_types(const Object& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->canonical_types_, value.raw());
 }
 
 
+intptr_t Class::NumCanonicalTypes() const {
+  if (CanonicalType() != Type::null()) {
+    return 1;
+  }
+  const Object& types = Object::Handle(canonical_types());
+  if (types.IsNull() || !types.IsArray()) {
+    return 0;
+  }
+  intptr_t num_types = Array::Cast(types).Length();
+  while (Array::Cast(types).At(num_types - 1) == Type::null()) {
+    num_types--;
+  }
+  return num_types;
+}
+
+
+intptr_t Class::FindCanonicalTypeIndex(const Type& needle) const {
+  Isolate* isolate = Isolate::Current();
+  if (EnsureIsFinalized(isolate) != Error::null()) {
+    return -1;
+  }
+  if (needle.raw() == CanonicalType()) {
+    return 0;
+  }
+  ReusableHandleScope reused_handles(isolate);
+  Object& types = reused_handles.ObjectHandle();
+  types = canonical_types();
+  if (types.IsNull() || !types.IsArray()) {
+    return -1;
+  }
+  const intptr_t len = Array::Cast(types).Length();
+  AbstractType& type = reused_handles.AbstractTypeHandle();
+  for (intptr_t i = 0; i < len; i++) {
+    type ^= Array::Cast(types).At(i);
+    if (needle.raw() == type.raw()) {
+      return i;
+    }
+  }
+  // No type found.
+  return -1;
+}
+
+
+RawType* Class::CanonicalTypeFromIndex(intptr_t idx) const {
+  Type& type = Type::Handle();
+  if (idx == 0) {
+    type = CanonicalType();
+    if (!type.IsNull()) {
+      return type.raw();
+    }
+  }
+  Object& types = Object::Handle(canonical_types());
+  if (types.IsNull() || !types.IsArray()) {
+    types = empty_array().raw();
+  }
+  if ((idx < 0) || (idx >= Array::Cast(types).Length())) {
+    return Type::null();
+  }
+  type ^= Array::Cast(types).At(idx);
+  ASSERT(!type.IsNull());
+  return type.raw();
+}
+
+
 void Class::set_allocation_stub(const Code& value) const {
   ASSERT(!value.IsNull());
   ASSERT(raw_ptr()->allocation_stub_ == Code::null());
   StorePointer(&raw_ptr()->allocation_stub_, value.raw());
 }
 
 
 bool Class::IsFunctionClass() const {
   return raw() == Type::Handle(Type::Function()).type_class();
 }
@@ skipping 340 matching lines @@
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
   ReusableHandleScope reused_handles(isolate);
   Array& funcs = reused_handles.ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   Function& function = reused_handles.FunctionHandle();
   String& function_name = reused_handles.StringHandle();
-  intptr_t len = funcs.Length();
+  const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (String::EqualsIgnoringPrivateKey(function_name, name)) {
       return CheckFunctionType(function, type);
     }
   }
   // No function found.
   return Function::null();
 }
@@ skipping 174 matching lines @@
       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);
         }
       }
     }
+    jsobj.AddPropertyF("canonicalTypes", "classes/%" Pd "/types", id());
   }
 }
 
 
 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) {
@@ 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);
+  jsobj.AddProperty("name", String::Handle(UserVisibleName()).ToCString());
+  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;
+}
+
+
+intptr_t TypeArguments::NumInstantiations() const {
+  const Array& prior_instantiations = Array::Handle(instantiations());
+  ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
+  intptr_t i = 0;
+  while (prior_instantiations.At(i) != Smi::New(StubCode::kNoInstantiator)) {
+    i += 2;
+  }
+  return i/2;
 }
 
 
 RawArray* TypeArguments::instantiations() const {
   return raw_ptr()->instantiations_;
 }
 
+
 void TypeArguments::set_instantiations(const Array& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->instantiations_, value.raw());
 }
 
 
 intptr_t TypeArguments::Length() const {
   ASSERT(!IsNull());
   return Smi::Value(raw_ptr()->length_);
 }
@@ skipping 219 matching lines @@
     const TypeArguments& instantiator_type_arguments,
     Error* bound_error) const {
   ASSERT(!IsInstantiated());
   ASSERT(instantiator_type_arguments.IsNull() ||
          instantiator_type_arguments.IsCanonical());
   // Lookup instantiator and, if found, return paired instantiated result.
   Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(!prior_instantiations.IsNull() && prior_instantiations.IsArray());
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
-  ASSERT(prior_instantiations.Length() > 0);
+  ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
   intptr_t index = 0;
   while (true) {
     if (prior_instantiations.At(index) == instantiator_type_arguments.raw()) {
       return TypeArguments::RawCast(prior_instantiations.At(index + 1));
     }
     if (prior_instantiations.At(index) == Smi::New(StubCode::kNoInstantiator)) {
       break;
     }
     index += 2;
   }
@@ skipping 102 matching lines @@
                                              intptr_t index) {
   arguments.SetCanonical();  // Mark object as being canonical.
   table.SetAt(index, arguments);  // Remember the new element.
   // Update used count.
   // Last element of the array is the number of used elements.
   intptr_t table_size = table.Length() - 1;
   intptr_t used_elements = Smi::Value(Smi::RawCast(table.At(table_size))) + 1;
   const Smi& used = Smi::Handle(isolate, Smi::New(used_elements));
   table.SetAt(table_size, used);
 
+  // TODO(regis): Use a trail to compute hashes of TypeRef, or duplicates will
+  // show up in the table (different hashes but equal).
+#if 0  // #ifdef DEBUG
+  // Verify that there are no duplicates.
+  // Duplicates could appear if hash values are not kept constant across
+  // snapshots, e.g. if class ids are not preserved by the snapshots.
+  TypeArguments& other = TypeArguments::Handle();
+  for (intptr_t i = 0; i < table_size; i++) {
+    if ((i != index) && (table.At(i) != TypeArguments::null())) {
+      other ^= table.At(i);
+      ASSERT(!arguments.Equals(other));
+    }
+  }
+#endif
+
   // Rehash if table is 75% full.
   if (used_elements > ((table_size / 4) * 3)) {
     GrowCanonicalTypeArguments(isolate, table);
   }
 }
 
 
 static intptr_t FindIndexInCanonicalTypeArguments(
     Isolate* isolate,
     const Array& table,
@@ skipping 7742 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);
   }
@@ skipping 416 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 498 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);
+  if (id >= 0) {
+    intptr_t cid = type_cls.id();
+    jsobj.AddPropertyF("id", "classes/%" Pd "/types/%" Pd "", cid, id);
+  } else {
+    ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+    id = ring->GetIdForObject(raw());

[Cutch, 2014/03/11 13:50:01]

How frequently does this path happen?

[regis, 2014/03/14 23:52:07]

If I call PrintToJSON on all canonicalized type arguments on isolate shutdown
while running the tests, 58 out 11481 tests will take this path. So, no, this is
not frequent. However, this is a bug in canonicalization that I will fix in a
separate cl.

+    jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  }
+  const char* type_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", type_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* type_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", type_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);
+  jsobj.AddProperty("name", String::Handle(name()).ToCString());
+  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* type_name = String::Handle(UserVisibleName()).ToCString();
+  jsobj.AddProperty("name", type_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