[JSON] Use LLVM's library for encoding JSON

[JDevlieghere]

Summary

This patch replaces the hand-rolled JSON emission with LLVM's JSON library.

[shafik]

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

387 ↗

(On Diff #222509)

Removing the spaces, is this just a formatting change?

[JDevlieghere]

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

387 ↗

(On Diff #222509)

Yes

[vsk]

Sweet! Does this 'automatically' fix the 'llvm-argdumper has issues escaping JSON-ified input' issue we discussed in person?

[labath]

Yay.

BTW, there's another copy of json serialization code in JSON.cpp (JSONValue::Write).

[aprantl]

Cool. I mean both are supposed to be JSON, but are we expecting any fallout from a debugserver using the old library vs and lldb using the new one? I suppose not..

[JDevlieghere]

In D68248#1688975, @vsk wrote:

Sweet! Does this 'automatically' fix the 'llvm-argdumper has issues escaping JSON-ified input' issue we discussed in person?

No, that uses the JSON class that Pavel mentioned. My hope is to remove that altogether in favor of the LLVM counterpart.

In D68248#1689855, @aprantl wrote:

Cool. I mean both are supposed to be JSON, but are we expecting any fallout from a debugserver using the old library vs and lldb using the new one? I suppose not..

I ran the test suite with the just-built debugserver and didn't notice any regressions. If this does come up we should fix the debugserver implementation.

lldb/trunk/include/lldb/Core/StructuredDataImpl.h

public:
   Status GetAsJSON(Stream &stream) const {
     Status error;
 
     if (!m_data_sp) {
       error.SetErrorString("No structured data.");
       return error;
     }
 
-    m_data_sp->Dump(stream);
+    llvm::json::OStream s(stream.AsRawOstream());
+    m_data_sp->Serialize(s);
     return error;
   }
 
   Status GetDescription(Stream &stream) const {
     Status error;
 
     if (!m_data_sp) {
       error.SetErrorString("Cannot pretty print structured data: "

lldb/trunk/include/lldb/Utility/StructuredData.h

 //===-- StructuredData.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_StructuredData_h_
 #define liblldb_StructuredData_h_
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/JSON.h"
 
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Stream.h"
 #include "lldb/lldb-enumerations.h"
 
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace lldb_private {
 class Status;
-class Stream;
 }
 
 namespace lldb_private {
 
 /// \class StructuredData StructuredData.h "lldb/Utility/StructuredData.h"
 /// A class which can hold structured data
 ///
 /// The StructuredData class is designed to hold the data from a JSON or plist
Generic *GetAsGeneric() {
                   ? static_cast<Generic *>(this)
                   : nullptr);
     }
 
     ObjectSP GetObjectForDotSeparatedPath(llvm::StringRef path);
 
     void DumpToStdout(bool pretty_print = true) const;
 
-    virtual void Dump(Stream &s, bool pretty_print = true) const = 0;
+    virtual void Serialize(llvm::json::OStream &s) const = 0;
+
+    void Dump(lldb_private::Stream &s, bool pretty_print = true) const {
+      llvm::json::OStream jso(s.AsRawOstream(), pretty_print ? 2 : 0);
+      Serialize(jso);
+    }
 
   private:
     lldb::StructuredDataType m_type;
   };
 
   class Array : public Object {
   public:
     Array() : Object(lldb::eStructuredDataTypeArray) {}
bool GetItemAtIndexAsArray(size_t idx, Array *&result) const {
       }
       return false;
     }
 
     void Push(ObjectSP item) { m_items.push_back(item); }
 
     void AddItem(ObjectSP item) { m_items.push_back(item); }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
 
   protected:
     typedef std::vector<ObjectSP> collection;
     collection m_items;
   };
 
   class Integer : public Object {
   public:
     Integer(uint64_t i = 0)
         : Object(lldb::eStructuredDataTypeInteger), m_value(i) {}
 
     ~Integer() override = default;
 
     void SetValue(uint64_t value) { m_value = value; }
 
     uint64_t GetValue() { return m_value; }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
 
   protected:
     uint64_t m_value;
   };
 
   class Float : public Object {
   public:
     Float(double d = 0.0)
         : Object(lldb::eStructuredDataTypeFloat), m_value(d) {}
 
     ~Float() override = default;
 
     void SetValue(double value) { m_value = value; }
 
     double GetValue() { return m_value; }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
 
   protected:
     double m_value;
   };
 
   class Boolean : public Object {
   public:
     Boolean(bool b = false)
         : Object(lldb::eStructuredDataTypeBoolean), m_value(b) {}
 
     ~Boolean() override = default;
 
     void SetValue(bool value) { m_value = value; }
 
     bool GetValue() { return m_value; }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
 
   protected:
     bool m_value;
   };
 
   class String : public Object {
   public:
     String() : Object(lldb::eStructuredDataTypeString) {}
     explicit String(llvm::StringRef S)
         : Object(lldb::eStructuredDataTypeString), m_value(S) {}
 
     void SetValue(llvm::StringRef S) { m_value = S; }
 
     llvm::StringRef GetValue() { return m_value; }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
 
   protected:
     std::string m_value;
   };
 
   class Dictionary : public Object {
   public:
     Dictionary() : Object(lldb::eStructuredDataTypeDictionary), m_dict() {}
public:
     void AddStringItem(llvm::StringRef key, llvm::StringRef value) {
       AddItem(key, std::make_shared<String>(std::move(value)));
     }
 
     void AddBooleanItem(llvm::StringRef key, bool value) {
       AddItem(key, std::make_shared<Boolean>(value));
     }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
 
   protected:
     typedef std::map<ConstString, ObjectSP> collection;
     collection m_dict;
   };
 
   class Null : public Object {
   public:
     Null() : Object(lldb::eStructuredDataTypeNull) {}
 
     ~Null() override = default;
 
     bool IsValid() const override { return false; }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
   };
 
   class Generic : public Object {
   public:
     explicit Generic(void *object = nullptr)
         : Object(lldb::eStructuredDataTypeGeneric), m_object(object) {}
 
     void SetValue(void *value) { m_object = value; }
 
     void *GetValue() const { return m_object; }
 
     bool IsValid() const override { return m_object != nullptr; }
 
-    void Dump(Stream &s, bool pretty_print = true) const override;
+    void Serialize(llvm::json::OStream &s) const override;
 
   private:
     void *m_object;
   };
 
   static ObjectSP ParseJSON(std::string json_text);
 
   static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StructuredData_h_

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (!packet.consume_front(s_async_json_packet_prefix)) {
     return StructuredData::ObjectSP();
   }
 
   // This is an asynchronous JSON packet, destined for a StructuredDataPlugin.
   StructuredData::ObjectSP json_sp = StructuredData::ParseJSON(packet);
   if (log) {
     if (json_sp) {
       StreamString json_str;
-      json_sp->Dump(json_str);
+      json_sp->Dump(json_str, true);
       json_str.Flush();
       LLDB_LOGF(log,
                 "ProcessGDBRemote::%s() "
                 "received Async StructuredData packet: %s",
                 __FUNCTION__, json_str.GetData());
     } else {
       LLDB_LOGF(log,
                 "ProcessGDBRemote::%s"

lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

public:
   ~StructuredPythonObject() override {
     if (Py_IsInitialized())
       Py_XDECREF(GetValue());
     SetValue(nullptr);
   }
 
   bool IsValid() const override { return GetValue() && GetValue() != Py_None; }
 
-  void Dump(Stream &s, bool pretty_print = true) const override;
+  void Serialize(llvm::json::OStream &s) const override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(StructuredPythonObject);
 };
 
 enum class PyObjectType {
   Unknown,
   None,

lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Errno.h"
 
 #include <stdio.h>
 
 using namespace lldb_private;
 using namespace lldb;
 
-void StructuredPythonObject::Dump(Stream &s, bool pretty_print) const {
-  s << "Python Obj: 0x" << GetValue();
+void StructuredPythonObject::Serialize(llvm::json::OStream &s) const {
+  s.value(llvm::formatv("Python Obj: {0:X}", GetValue()).str());
 }
 
 // PythonObject
 
 void PythonObject::Dump(Stream &strm) const {
   if (m_py_obj) {
     FILE *file = llvm::sys::RetryAfterSignal(nullptr, ::tmpfile);
     if (file) {

lldb/trunk/source/Utility/StructuredData.cpp

 //===---------------------StructuredData.cpp ---------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cerrno>
 #include <cstdlib>
 #include <inttypes.h>
 #include <limits>
 
 using namespace lldb_private;
+using namespace llvm;
 
 // Functions that use a JSONParser to parse JSON into StructuredData
 static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser);
 
 StructuredData::ObjectSP
 StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
if (this->GetType() == lldb::eStructuredDataTypeArray) {
     }
     return ObjectSP();
   }
 
   return this->shared_from_this();
 }
 
 void StructuredData::Object::DumpToStdout(bool pretty_print) const {
-  StreamString stream;
-  Dump(stream, pretty_print);
-  llvm::outs() << stream.GetString();
+  json::OStream stream(llvm::outs(), pretty_print ? 2 : 0);
+  Serialize(stream);
 }
 
-void StructuredData::Array::Dump(Stream &s, bool pretty_print) const {
-  bool first = true;
-  s << "[";
-  if (pretty_print) {
-    s << "\n";
-    s.IndentMore();
-  }
+void StructuredData::Array::Serialize(json::OStream &s) const {
+  s.arrayBegin();
   for (const auto &item_sp : m_items) {
-    if (first) {
-      first = false;
-    } else {
-      s << ",";
-      if (pretty_print)
-        s << "\n";
-    }
-
-    if (pretty_print)
-      s.Indent();
-    item_sp->Dump(s, pretty_print);
-  }
-  if (pretty_print) {
-    s.IndentLess();
-    s.EOL();
-    s.Indent();
+    item_sp->Serialize(s);
   }
-  s << "]";
+  s.arrayEnd();
 }
 
-void StructuredData::Integer::Dump(Stream &s, bool pretty_print) const {
-  s.Printf("%" PRIu64, m_value);
+void StructuredData::Integer::Serialize(json::OStream &s) const {
+  s.value(static_cast<int64_t>(m_value));
 }
 
-void StructuredData::Float::Dump(Stream &s, bool pretty_print) const {
-  s.Printf("%lg", m_value);
+void StructuredData::Float::Serialize(json::OStream &s) const {
+  s.value(m_value);
 }
 
-void StructuredData::Boolean::Dump(Stream &s, bool pretty_print) const {
-  if (m_value)
-    s.PutCString("true");
-  else
-    s.PutCString("false");
+void StructuredData::Boolean::Serialize(json::OStream &s) const {
+  s.value(m_value);
 }
 
-void StructuredData::String::Dump(Stream &s, bool pretty_print) const {
-  std::string quoted;
-  const size_t strsize = m_value.size();
-  for (size_t i = 0; i < strsize; ++i) {
-    char ch = m_value[i];
-    if (ch == '"' || ch == '\\')
-      quoted.push_back('\\');
-    quoted.push_back(ch);
-  }
-  s.Printf("\"%s\"", quoted.c_str());
-}
-
-void StructuredData::Dictionary::Dump(Stream &s, bool pretty_print) const {
-  bool first = true;
-  s << "{";
-  if (pretty_print) {
-    s << "\n";
-    s.IndentMore();
-  }
+void StructuredData::String::Serialize(json::OStream &s) const {
+  s.value(m_value);
+
+void StructuredData::Dictionary::Serialize(json::OStream &s) const {
+  s.objectBegin();
   for (const auto &pair : m_dict) {
-    if (first)
-      first = false;
-    else {
-      s << ",";
-      if (pretty_print)
-        s << "\n";
-    }
-    if (pretty_print)
-      s.Indent();
-    s << "\"" << pair.first.AsCString() << "\" : ";
-    pair.second->Dump(s, pretty_print);
-  }
-  if (pretty_print) {
-    s.IndentLess();
-    s.EOL();
-    s.Indent();
+    s.attributeBegin(pair.first.AsCString());
+    pair.second->Serialize(s);
+    s.attributeEnd();
   }
-  s << "}";
+  s.objectEnd();
 }
 
-void StructuredData::Null::Dump(Stream &s, bool pretty_print) const {
-  s << "null";
+void StructuredData::Null::Serialize(json::OStream &s) const {
+  s.value(nullptr);
 }
 
-void StructuredData::Generic::Dump(Stream &s, bool pretty_print) const {
-  s << "0x" << m_object;
+void StructuredData::Generic::Serialize(json::OStream &s) const {
+  s.value(llvm::formatv("{0:X}", m_object));
 }

lldb/trunk/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

TEST_F(GDBRemoteCommunicationClientTest, SendStartTracePacket) {
   options.setTraceParams(custom_params);
 
   std::future<lldb::user_id_t> result = std::async(std::launch::async, [&] {
     return client.SendStartTracePacket(options, error);
   });
 
   // Since the line is exceeding 80 characters.
   std::string expected_packet1 =
-      R"(jTraceStart:{"buffersize" : 8192,"metabuffersize" : 8192,"params" :)";
+      R"(jTraceStart:{"buffersize":8192,"metabuffersize":8192,"params":)";
   std::string expected_packet2 =
-      R"( {"psb" : 1,"tracetech" : "intel-pt"},"threadid" : 35,"type" : 1})";
+      R"({"psb":1,"tracetech":"intel-pt"},"threadid":35,"type":1})";
   HandlePacket(server, (expected_packet1 + expected_packet2), "1");
   ASSERT_TRUE(error.Success());
   ASSERT_EQ(result.get(), 1u);
 
   error.Clear();
   result = std::async(std::launch::async, [&] {
     return client.SendStartTracePacket(options, error);
   });
 
   HandlePacket(server, (expected_packet1 + expected_packet2), "E23");
   ASSERT_EQ(result.get(), LLDB_INVALID_UID);
   ASSERT_FALSE(error.Success());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, SendStopTracePacket) {
   lldb::tid_t thread_id = 0x23;
   lldb::user_id_t trace_id = 3;
 
   std::future<Status> result = std::async(std::launch::async, [&] {
     return client.SendStopTracePacket(trace_id, thread_id);
   });
 
-  const char *expected_packet =
-      R"(jTraceStop:{"threadid" : 35,"traceid" : 3})";
+  const char *expected_packet = R"(jTraceStop:{"threadid":35,"traceid":3})";
   HandlePacket(server, expected_packet, "OK");
   ASSERT_TRUE(result.get().Success());
 
   result = std::async(std::launch::async, [&] {
     return client.SendStopTracePacket(trace_id, thread_id);
   });
 
   HandlePacket(server, expected_packet, "E23");
   ASSERT_FALSE(result.get().Success());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, SendGetDataPacket) {
   lldb::tid_t thread_id = 0x23;
   lldb::user_id_t trace_id = 3;
 
   uint8_t buf[32] = {};
   llvm::MutableArrayRef<uint8_t> buffer(buf, 32);
   size_t offset = 0;
 
   std::future<Status> result = std::async(std::launch::async, [&] {
     return client.SendGetDataPacket(trace_id, thread_id, buffer, offset);
   });
 
   std::string expected_packet1 =
-      R"(jTraceBufferRead:{"buffersize" : 32,"offset" : 0,"threadid" : 35,)";
-  std::string expected_packet2 = R"("traceid" : 3})";
+      R"(jTraceBufferRead:{"buffersize":32,"offset":0,"threadid":35,)";
+  std::string expected_packet2 = R"("traceid":3})";
   HandlePacket(server, expected_packet1+expected_packet2, "123456");
   ASSERT_TRUE(result.get().Success());
   ASSERT_EQ(buffer.size(), 3u);
   ASSERT_EQ(buf[0], 0x12);
   ASSERT_EQ(buf[1], 0x34);
   ASSERT_EQ(buf[2], 0x56);
 
   llvm::MutableArrayRef<uint8_t> buffer2(buf, 32);
TEST_F(GDBRemoteCommunicationClientTest, SendGetMetaDataPacket) {
   llvm::MutableArrayRef<uint8_t> buffer(buf, 32);
   size_t offset = 0;
 
   std::future<Status> result = std::async(std::launch::async, [&] {
     return client.SendGetMetaDataPacket(trace_id, thread_id, buffer, offset);
   });
 
   std::string expected_packet1 =
-      R"(jTraceMetaRead:{"buffersize" : 32,"offset" : 0,"threadid" : 35,)";
-  std::string expected_packet2 = R"("traceid" : 3})";
+      R"(jTraceMetaRead:{"buffersize":32,"offset":0,"threadid":35,)";
+  std::string expected_packet2 = R"("traceid":3})";
   HandlePacket(server, expected_packet1+expected_packet2, "123456");
   ASSERT_TRUE(result.get().Success());
   ASSERT_EQ(buffer.size(), 3u);
   ASSERT_EQ(buf[0], 0x12);
   ASSERT_EQ(buf[1], 0x34);
   ASSERT_EQ(buf[2], 0x56);
 
   llvm::MutableArrayRef<uint8_t> buffer2(buf, 32);
TEST_F(GDBRemoteCommunicationClientTest, SendGetTraceConfigPacket) {
   TraceOptions options;
   options.setThreadID(thread_id);
 
   std::future<Status> result = std::async(std::launch::async, [&] {
     return client.SendGetTraceConfigPacket(trace_id, options);
   });
 
   const char *expected_packet =
-      R"(jTraceConfigRead:{"threadid" : 35,"traceid" : 3})";
+      R"(jTraceConfigRead:{"threadid":35,"traceid":3})";
   std::string response1 =
-      R"({"buffersize" : 8192,"params" : {"psb" : 1,"tracetech" : "intel-pt"})";
-  std::string response2 =
-      R"(],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])";
+      R"({"buffersize":8192,"params":{"psb":1,"tracetech":"intel-pt"})";
+  std::string response2 = R"(],"metabuffersize":8192,"threadid":35,"type":1}])";
   HandlePacket(server, expected_packet, response1+response2);
   ASSERT_TRUE(result.get().Success());
   ASSERT_EQ(options.getTraceBufferSize(), 8192u);
   ASSERT_EQ(options.getMetaDataBufferSize(), 8192u);
   ASSERT_EQ(options.getType(), 1);
 
   auto custom_params = options.getTraceParams();