Port type arguments to new RPC protocol

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 "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 1439 matching lines @@
       return Object::sentinel().raw();
     }
     return type.raw();
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
+static RawObject* LookupHeapObjectTypeArguments(Isolate* isolate,
+                                          char** parts, int num_parts) {
+  // TypeArguments ids look like: "typearguments/17"
+  if (num_parts < 2) {
+    return Object::sentinel().raw();
+  }
+  intptr_t id;
+  if (!GetIntegerId(parts[1], &id)) {
+    return Object::sentinel().raw();
+  }
+  ObjectStore* object_store = isolate->object_store();
+  const Array& table = Array::Handle(object_store->canonical_type_arguments());
+  ASSERT(table.Length() > 0);
+  const intptr_t table_size = table.Length() - 1;
+  if ((id < 0) || (id >= table_size) || (table.At(id) == Object::null())) {
+    return Object::sentinel().raw();
+  }
+  return table.At(id);
+}
+
+
 static RawObject* LookupHeapObjectCode(Isolate* isolate,
                                        char** parts, int num_parts) {
   if (num_parts != 2) {
     return Object::sentinel().raw();
   }
   uword pc;
   static const char* kCollectedPrefix = "collected-";
   static intptr_t kCollectedPrefixLen = strlen(kCollectedPrefix);
   static const char* kNativePrefix = "native-";
   static intptr_t kNativePrefixLen = strlen(kNativePrefix);
@@ skipping 76 matching lines @@
         *result = lookup_result;
       }
       return Object::sentinel().raw();
     }
     return obj.raw();
 
   } else if (strcmp(parts[0], "libraries") == 0) {
     return LookupHeapObjectLibraries(isolate, parts, num_parts);
   } else if (strcmp(parts[0], "classes") == 0) {
     return LookupHeapObjectClasses(isolate, parts, num_parts);
+  } else if (strcmp(parts[0], "typearguments") == 0) {
+    return LookupHeapObjectTypeArguments(isolate, parts, num_parts);
   } else if (strcmp(parts[0], "code") == 0) {
     return LookupHeapObjectCode(isolate, parts, num_parts);
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
 static void PrintSentinel(JSONStream* js,
@@ skipping 1206 matching lines @@
   }
   if (should_collect) {
     isolate->UpdateLastAllocationProfileGCTimestamp();
     isolate->heap()->CollectAllGarbage();
   }
   isolate->class_table()->AllocationProfilePrintJSON(js);
   return true;
 }
 
 
-static bool HandleTypeArguments(Isolate* isolate, JSONStream* js) {
-  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)));
-  bool only_with_instantiations = false;
-  if (js->num_arguments() >= 2) {
-    const char* second = js->GetArgument(1);
-    if (strcmp(second, "withinstantiations") == 0) {
-      only_with_instantiations = true;
-      if (js->num_arguments() > 2) {
-        PrintError(js, "Command too long");
-        return true;
-      }
-    }
-  }
-  if ((js->num_arguments() == 1) || only_with_instantiations) {
-    JSONObject jsobj(js);
-    jsobj.AddProperty("type", "TypeArgumentsList");
-    jsobj.AddProperty("table_size", table_size);
-    jsobj.AddProperty("table_used", table_used);
-    JSONArray members(&jsobj, "members");
-    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) && !only_with_instantiations);
-  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.PrintJSON(js, false);
-  return true;
-}
-
-
 static bool HandleIsolateGetHeapMap(Isolate* isolate, JSONStream* js) {
   isolate->heap()->PrintHeapMapToJSONStream(isolate, js);
   return true;
 }
 
 
 static bool HandleIsolateRequestHeapSnapshot(Isolate* isolate, JSONStream* js) {
   Service::SendGraphEvent(isolate);
   // TODO(koda): Provide some id that ties this request to async response(s).
   JSONObject jsobj(js);
@@ skipping 88 matching lines @@
   { "_malformedobject", HandleMalformedObject },  // debug
   { "_echo", HandleIsolateEcho },                 // debug
   { "", HandleIsolate },                          // getObject
   { "address", HandleAddress },                   // to do
   { "classes", HandleClasses },                   // getObject
   { "code", HandleCode },                         // getObject
   { "libraries", HandleLibraries },               // getObject
   { "metrics", HandleMetrics },                   // to do - complex?
   { "objects", HandleObjects },                   // getObject
   { "scripts", HandleScripts },                   // getObject
-  { "typearguments", HandleTypeArguments },       // confusing
 };
 
 
 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 42 matching lines @@
 
 
 static bool HandleIsolateGetClassList(Isolate* isolate, JSONStream* js) {
   ClassTable* table = isolate->class_table();
   JSONObject jsobj(js);
   table->PrintToJSONObject(&jsobj);
   return true;
 }
 
 
+static bool HandleIsolateGetTypeArgumentsList(Isolate* isolate,
+                                              JSONStream* js) {
+  bool only_with_instantiations = false;
+  if (js->OptionIs("onlyWithInstantiations", "true")) {
+    only_with_instantiations = true;
+  }
+  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)));
+  JSONObject jsobj(js);
+  jsobj.AddProperty("type", "TypeArgumentsList");
+  jsobj.AddProperty("canonicalTypeArgumentsTableSize", table_size);
+  jsobj.AddProperty("canonicalTypeArgumentsTableUsed", table_used);
+  JSONArray members(&jsobj, "typeArguments");
+  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;
+}
+
+
 static IsolateMessageHandlerEntry isolate_handlers_new[] = {
   { "getIsolate", HandleIsolate },
   { "getObject", HandleIsolateGetObject },
   { "getBreakpoints", HandleIsolateGetBreakpoints },
   { "pause", HandleIsolatePause },
   { "resume", HandleIsolateResume },
   { "getStack", HandleIsolateGetStack },
   { "getCpuProfile", HandleIsolateGetCpuProfile },
   { "getTagProfile", HandleIsolateGetTagProfile },
   { "getAllocationProfile", HandleIsolateGetAllocationProfile },
   { "getHeapMap", HandleIsolateGetHeapMap },
   { "addBreakpoint", HandleIsolateAddBreakpoint },
   { "removeBreakpoint", HandleIsolateRemoveBreakpoint },
   { "getCoverage", HandleIsolateGetCoverage },
   { "eval", HandleIsolateEval },
   { "getRetainedSize", HandleIsolateGetRetainedSize },
   { "getRetainingPath", HandleIsolateGetRetainingPath },
   { "getInboundReferences", HandleIsolateGetInboundReferences },
   { "getInstances", HandleIsolateGetInstances },
   { "requestHeapSnapshot", HandleIsolateRequestHeapSnapshot },
   { "getClassList", HandleIsolateGetClassList },
+  { "getTypeArgumentsList", HandleIsolateGetTypeArgumentsList }
 };
 
 
 static IsolateMessageHandler FindIsolateMessageHandlerNew(const char* command) {
   intptr_t num_message_handlers = sizeof(isolate_handlers_new) /
                                   sizeof(isolate_handlers_new[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const IsolateMessageHandlerEntry& entry = isolate_handlers_new[i];
     if (strcmp(command, entry.command) == 0) {
       return entry.handler;
@@ skipping 444 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart