Add support for TokenStream, LocalVarDescriptors, and PcDescriptors over service

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 7925 matching lines @@
   return result.raw();
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
 
 
 void TokenStream::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
+  JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(ref));
+  // TODO(johnmccutchan): Generate a stable id. TokenStreams hang off
+  // a Script object but do not have a back reference to generate a stable id.
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  const intptr_t id = ring->GetIdForObject(raw());
+  jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  if (ref) {
+    return;
+  }
+  const String& private_key = String::Handle(PrivateKey());
+  jsobj.AddProperty("privateKey", private_key);
+  // TODO(johnmccutchan): Add support for printing LiteralTokens and add
+  // them to members array.
+  JSONArray members(&jsobj, "members");
 }
 
 
 TokenStream::Iterator::Iterator(const TokenStream& tokens,
                                 intptr_t token_pos,
                                 Iterator::StreamType stream_type)
     : tokens_(TokenStream::Handle(tokens.raw())),
       data_(ExternalTypedData::Handle(tokens.GetStream())),
       stream_(reinterpret_cast<uint8_t*>(data_.DataAddr(0)), data_.Length()),
       token_objects_(Array::Handle(tokens.TokenObjects())),
@@ skipping 2588 matching lines @@
                          iter.Pc(),
                          KindAsStr(iter.Kind()),
                          iter.DeoptId(),
                          iter.TokenPos(),
                          iter.TryIndex());
   }
   return buffer;
 }
 
 
-void PcDescriptors::PrintToJSONObject(JSONObject* jsobj) const {
-  jsobj->AddProperty("type", JSONType(false));
-  // TODO(johnmccutchan): Generate a valid ID.
-  // PcDescriptors hang off a Code object but do not have a back reference to
-  // generate an ID. Currently we only print PcDescriptors inline with a Code.
-  jsobj->AddProperty("id", "");
+void PcDescriptors::PrintToJSONObject(JSONObject* jsobj, bool ref) const {
+  jsobj->AddProperty("type", JSONType(ref));
+  // TODO(johnmccutchan): Generate a stable id. PcDescriptors hang off a Code
+  // object but do not have a back reference to generate an ID.
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  const intptr_t id = ring->GetIdForObject(raw());
+  jsobj->AddPropertyF("id", "objects/%" Pd "", id);
+  if (ref) {
+    return;
+  }
   JSONArray members(jsobj, "members");
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.MoveNext()) {
     JSONObject descriptor(&members);
     descriptor.AddPropertyF("pc", "%" Px "", iter.Pc());
     descriptor.AddProperty("kind", KindAsStr(iter.Kind()));
     descriptor.AddProperty("deoptId", iter.DeoptId());
     descriptor.AddProperty("tokenPos", iter.TokenPos());
     descriptor.AddProperty("tryIndex", iter.TryIndex());
   }
 }
 
 
 void PcDescriptors::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
-  PrintToJSONObject(&jsobj);
+  PrintToJSONObject(&jsobj, ref);
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same deoptimization id.
 // - No two ic-call descriptors have the same deoptimization id (type feedback).
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
 void PcDescriptors::Verify(const Function& function) const {
 #if defined(DEBUG)
@@ skipping 253 matching lines @@
     num_chars += PrintVarInfo((buffer + num_chars),
                               (len - num_chars),
                               i, var_name, info);
   }
   return buffer;
 }
 
 
 void LocalVarDescriptors::PrintJSONImpl(JSONStream* stream,
                                         bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
+  JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(ref));
+  // TODO(johnmccutchan): Generate a stable id. LocalVarDescriptors hang off
+  // a Code object but do not have a back reference to generate an ID.
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  const intptr_t id = ring->GetIdForObject(raw());
+  jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  if (ref) {
+    return;
+  }
+  JSONArray members(&jsobj, "members");
+  String& var_name = String::Handle();
+  for (intptr_t i = 0; i < Length(); i++) {
+    RawLocalVarDescriptors::VarInfo info;
+    var_name = GetName(i);
+    if (var_name.IsNull()) {
+      var_name = Symbols::Empty().raw();
+    }
+    GetInfo(i, &info);
+    JSONObject var(&members);
+    var.AddProperty("name", var_name.ToCString());
+    var.AddProperty("index", info.index);
+    var.AddProperty("beginPos", info.begin_pos);
+    var.AddProperty("endPos", info.end_pos);
+    var.AddProperty("scopeId", static_cast<intptr_t>(info.scope_id));
+    var.AddProperty("kind", KindToStr(info.kind));
+  }
 }
 
 
+const char* LocalVarDescriptors::KindToStr(intptr_t kind) {
+  switch (kind) {
+    case RawLocalVarDescriptors::kStackVar:
+      return "StackVar";
+    case RawLocalVarDescriptors::kContextVar:
+      return "ContextVar";
+    case RawLocalVarDescriptors::kContextLevel:
+      return "ContextLevel";
+    case RawLocalVarDescriptors::kSavedEntryContext:
+      return "SavedEntryContext";
+    case RawLocalVarDescriptors::kSavedCurrentContext:
+      return "SavedCurrentContext";
+    default:
+      UNIMPLEMENTED();
+      return NULL;
+  }
+}
+
 RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
   ASSERT(Object::var_descriptors_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in LocalVarDescriptors::New: "
            "invalid num_variables %" Pd "\n", num_variables);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
@@ skipping 1438 matching lines @@
     JSONArray jsarr(&jsobj, "disassembly");
     if (is_alive()) {
       // Only disassemble alive code objects.
       DisassembleToJSONStream formatter(jsarr);
       Disassemble(&formatter);
     }
   }
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   if (!descriptors.IsNull()) {
     JSONObject desc(&jsobj, "descriptors");
-    descriptors.PrintToJSONObject(&desc);
+    descriptors.PrintToJSONObject(&desc, false);
   }
 }
 
 
 uword Code::GetEntryPatchPc() const {
   return (entry_patch_pc_offset() != kInvalidPc)
       ? EntryPoint() + entry_patch_pc_offset() : 0;
 }
 
 
@@ skipping 7365 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart