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

runtime/vm/service.cc

 // Copyright (c) 2013, 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/service.h"
 
 #include "include/dart_api.h"
 
 #include "vm/compiler.h"
 #include "vm/coverage.h"
@@ skipping 779 matching lines @@
   Field& field = Field::Handle(cls.FieldFromIndex(id));
   if (field.IsNull()) {
     PrintError(js, "Field %" Pd " not found", id);
     return true;
   }
   field.PrintToJSONStream(js, false);
   return true;
 }
 
 
+static bool HandleClassesTypes(Isolate* isolate, const Class& cls,
+                               JSONStream* js) {
+  if (js->num_arguments() == 3) {
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "TypeList");
+    JSONArray members(&jsobj, "members");
+    const intptr_t num_types = cls.NumCanonicalTypes();
+    Type& type = Type::Handle();
+    for (intptr_t i = 0; i < num_types; i++) {
+      type = cls.CanonicalTypeFromIndex(i);
+      members.AddValue(type);
+    }
+    return true;
+  }
+  intptr_t id;
+  if (js->num_arguments() > 4) {
+    PrintError(js, "Command too long");
+    return true;
+  }
+  if (!GetIntegerId(js->GetArgument(3), &id)) {
+    PrintError(js, "Must specify collection object id: types/id");
+    return true;
+  }
+  Type& type = Type::Handle();
+  type ^= cls.CanonicalTypeFromIndex(id);
+  if (type.IsNull()) {
+    PrintError(js, "Canonical type %" Pd " not found", id);
+    return true;
+  }
+  type.PrintToJSONStream(js, false);
+  return true;
+}
+
+
 static bool HandleClasses(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() == 1) {
     ClassTable* table = isolate->class_table();
     table->PrintToJSONStream(js);
     return true;
   }
   ASSERT(js->num_arguments() >= 2);
   intptr_t id;
   if (!GetIntegerId(js->GetArgument(1), &id)) {
     PrintError(js, "Must specify collection object id: /classes/id");
     return true;
   }
   ClassTable* table = isolate->class_table();
   if (!table->IsValidIndex(id)) {
-    PrintError(js, "%" Pd " is not a valid class id.", id);;
+    PrintError(js, "%" Pd " is not a valid class id.", id);
     return true;
   }
   Class& cls = Class::Handle(table->At(id));
   if (js->num_arguments() == 2) {
     cls.PrintToJSONStream(js, false);
     return true;
   } else if (js->num_arguments() >= 3) {
     const char* second = js->GetArgument(2);
     if (strcmp(second, "closures") == 0) {
       return HandleClassesClosures(isolate, cls, js);
     } else if (strcmp(second, "fields") == 0) {
       return HandleClassesFields(isolate, cls, js);
     } else if (strcmp(second, "functions") == 0) {
       return HandleClassesFunctions(isolate, cls, js);
     } else if (strcmp(second, "implicit_closures") == 0) {
       return HandleClassesImplicitClosures(isolate, cls, js);
     } else if (strcmp(second, "dispatchers") == 0) {
       return HandleClassesDispatchers(isolate, cls, js);
+    } else if (!strcmp(second, "types")) {
+      return HandleClassesTypes(isolate, cls, js);
     } else {
       PrintError(js, "Invalid sub collection %s", second);
       return true;
     }
   }
   UNREACHABLE();
   return true;
 }
 
 
@@ skipping 319 matching lines @@
 }
 
 
 static bool HandleUnpin(Isolate* isolate, JSONStream* js) {
   // TODO(johnmccutchan): What do I respond with??
   isolate->ClosePinPort();
   return true;
 }
 
 
+static bool HandleTypeArguments(Isolate* isolate, JSONStream* js,
+                                bool only_with_instantiations) {
+  ObjectStore* object_store = isolate->object_store();
+  const Array& table = Array::Handle(object_store->canonical_type_arguments());
+  ASSERT(table.Length() > 0);
+  TypeArguments& type_args = TypeArguments::Handle();
+  const intptr_t table_size = table.Length() - 1;
+  const intptr_t table_used = Smi::Value(Smi::RawCast(table.At(table_size)));
+  if (js->num_arguments() == 1) {
+    JSONObject jsobj(js);
+    jsobj.AddProperty("type", "TypeArgumentsList");
+    jsobj.AddProperty("table_size", table_size);
+    jsobj.AddProperty("table_used", table_used);
+    const char* members_kind = only_with_instantiations ?
+        "members with instantiations" : "members";

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

This should always be "members". Also, please do not use spaces in key names.

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

Done.

+    JSONArray members(&jsobj, members_kind);
+    for (intptr_t i = 0; i < table_size; i++) {
+      type_args ^= table.At(i);
+      if (!type_args.IsNull()) {
+        if (!only_with_instantiations || type_args.HasInstantiations()) {
+          members.AddValue(type_args);
+        }
+      }
+    }
+    return true;
+  }
+  ASSERT(js->num_arguments() >= 2);
+  if (only_with_instantiations) {
+    PrintError(js, "Command too long");
+    return true;
+  }
+  intptr_t id;
+  if (!GetIntegerId(js->GetArgument(1), &id)) {
+    // Note that the table index of the canonical type arguments will change
+    // when the table grows. Should we not support this access at all?
+    PrintError(js, "Must specify collection object id: /typearguments/id");
+    return true;
+  }
+  if ((id < 0) || (id >= table_size) || (table.At(id) == Object::null())) {
+    PrintError(js, "%" Pd " is not a valid typearguments id.", id);
+    return true;
+  }
+  type_args ^= table.At(id);
+  type_args.PrintToJSONStream(js, false);
+  return true;
+}
+
+
+static bool HandleTypeArgumentsAll(Isolate* isolate, JSONStream* js) {
+  return HandleTypeArguments(isolate, js, false);
+}
+
+
+static bool HandleTypeArgumentsWithInstantiations(Isolate* isolate,
+                                                  JSONStream* js) {
+  return HandleTypeArguments(isolate, js, true);
+}
+
+
 static IsolateMessageHandlerEntry isolate_handlers[] = {
   { "_echo", HandleIsolateEcho },
   { "", HandleIsolate },
   { "allocationprofile", HandleAllocationProfile },
   { "classes", HandleClasses },
   { "code", HandleCode },
   { "coverage", HandleCoverage },
   { "cpu", HandleCpu },
   { "debug", HandleDebug },
   { "libraries", HandleLibraries },
   { "objects", HandleObjects },
   { "profile", HandleProfile },
   { "unpin", HandleUnpin },
   { "scripts", HandleScripts },
   { "stacktrace", HandleStackTrace },
+  { "typearguments", HandleTypeArgumentsAll },
+  { "typeargumentswithinstantiations", HandleTypeArgumentsWithInstantiations },

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

Does it make sense to make the "withinstantiations" a sub-command of
typearguments?

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

Good idea. Done.

 };
 
 
 static IsolateMessageHandler FindIsolateMessageHandler(const char* command) {
   intptr_t num_message_handlers = sizeof(isolate_handlers) /
                                   sizeof(isolate_handlers[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const IsolateMessageHandlerEntry& entry = isolate_handlers[i];
     if (strcmp(command, entry.command) == 0) {
       return entry.handler;
@@ skipping 199 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart