Port type arguments to new RPC protocol

runtime/vm/service/service.idl

 //
 // TODO(turnidge): Finish writing an idl description of the service protocol.
 //
 
 interface Service {
   // Returns the list of breakpoints for an isolate.
   getBreakpoints(isolateId string) BreakpointList
 
   // Adds a breakpoint at the specified line.
   //
@@ skipping 57 matching lines @@
                    limit int) RetainingPath
 
   // Returns a collection of inbound references to some object.
   //
   // TODO(turnidge): Make limit an int instead of a string.
   getInboundReferences(isolateId string,
                        targetId string,
                        limit int) InboundReferences
 
   getClassList(isolateId string) ClassList
+
+  // When onlyWithInstantiations is true, the list only includes type arguments
+  // with instantiations. Otherwise, all type arguments are returned.

[turnidge, 2015/02/03 21:09:35]

I've been using <code/> around argument names.  Not sure if that is really what
we want but should do it for consistency.

[Cutch, 2015/02/03 21:35:53]

Done.

+  getTypeArgumentsList(isolateId string,
+                       onlyWithInstantiations bool) TypeArgumentsList
 }
 
 
 // Every top level response returned by the Service interface extends
 // <code>Response</code>.  This allows the client to distinguish
 // between different kinds of responses by using the <code>type</code>
 // property.
 struct Response {
   // Every response returned by the VM Service has the
   // <code>type</code> property.  This allows the client distinguish
@@ skipping 44 matching lines @@
 struct CodeRef extends ObjectRef {
   placeholder int
 }
 
 
 struct ClassRef extends ObjectRef {
   placeholder int
 }
 
 
+struct TypeArgumentsRef extends ObjectRef {
+  placeholder int
+}
+
+
 // A <code>FunctionRef</code> encodes a reference to a <code>Function</code> object.
 struct FunctionRef extends ObjectRef {
   placeholder int
 }
 
 
 // A <code>FieldRef</code> encodes a reference to a <code>Field</code> object.
 struct FieldRef extends ObjectRef {
   placeholder int
 }
 
 
 // A <code>InstanceRef</code> encodes a reference to a <code>Instance</code> object.
 struct InstanceRef extends ObjectRef {
   placeholder int
 }
 
 
 // A <code>ScriptRef</code> encodes a reference to a <code>Script</code> object.
 struct ScriptRef extends ObjectRef {
   placeholder int
 }
 
 
 struct Class extends Object {
   placeholder int
 }
 
 
+struct TypeArguments extends Object {
+  placeholder int
+}
+
+
 // A <code>Location</code> encodes a location withing a dart script.
 //
 // TODO(turnidge): Should this really be broken out as its own type?
 // If so, we should use it more consistently in the api.  For example,
 // in Frame.
 struct Location {
   script   ScriptRef
   tokenPos int
 }
 
@@ skipping 101 matching lines @@
   source InstanceRef
   slot   int
 }
 
 
 struct ClassList {
   classes []ClassRef
 }
 
 
+struct TypeArgumentsList {
+  tableSize int
+  tableUsed int
+  typeArguments []TypeArgumentsRef
+}
+
+
 // A <code>GCOption</code> is used to indicate which form of garbage
 // collection is requested.
 enum GCOption {
   full
 }
 
 // A <code>StepOption</code> is used to indicate which form of
 // single-stepping is requested.
 enum StepOption {
   into
   over
   out
 }
 
 // A <code>TagSelector</code> is used to indicate which sets of tags
 // should take precedence in a cpu profile.
 enum TagSelector {
   UserVM
   UserOnly
   VMUser
   VMOnly
   None
 }