[lldb] Change parameter type of StructuredData::ParseJSON

[bulbazord]

Summary

Instead of taking a const std::string & we can take an
llvm::StringRef. The motivation for this change is that many of the
callers of ParseJSON end up creating a temporary std::string from an existing
StringRef or const char * in order to satisfy the API. There's no
reason we need to do this.

[mib]

LGTM!

lldb/include/lldb/Utility/StructuredData.h

public:
     void Serialize(llvm::json::OStream &s) const override;
 
     void GetDescription(lldb_private::Stream &s) const override;
 
   private:
     void *m_object;
   };
 
-  static ObjectSP ParseJSON(const std::string &json_text);
+  static ObjectSP ParseJSON(llvm::StringRef json_text);
   static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);
   static bool IsRecordType(const ObjectSP object_sp);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_STRUCTUREDDATA_H

lldb/source/API/SBDebugger.cpp

lldb::SBStructuredData SBDebugger::GetSetting(const char *setting) {
   if (setting && strlen(setting) > 0)
     m_opaque_sp->DumpPropertyValue(&exe_ctx, json_strm, setting,
                                    /*dump_mask*/ 0,
                                    /*is_json*/ true);
   else
     m_opaque_sp->DumpAllPropertyValues(&exe_ctx, json_strm, /*dump_mask*/ 0,
                                        /*is_json*/ true);
 
-  data.m_impl_up->SetObjectSP(
-      StructuredData::ParseJSON(json_strm.GetString().str()));
+  data.m_impl_up->SetObjectSP(StructuredData::ParseJSON(json_strm.GetString()));
   return data;
 }
 
 FILE *SBDebugger::GetInputFileHandle() {
   LLDB_INSTRUMENT_VA(this);
   if (m_opaque_sp) {
     File &file_sp = m_opaque_sp->GetInputFile();
     return file_sp.GetStream();

lldb/source/API/SBStructuredData.cpp

operator=(const lldb::SBStructuredData &rhs) {
   *m_impl_up = *rhs.m_impl_up;
   return *this;
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
   LLDB_INSTRUMENT_VA(this, stream);
 
   lldb::SBError error;
-  std::string json_str(stream.GetData());
 
-  StructuredData::ObjectSP json_obj = StructuredData::ParseJSON(json_str);
+  StructuredData::ObjectSP json_obj =
+      StructuredData::ParseJSON(stream.GetData());
   m_impl_up->SetObjectSP(json_obj);
 
   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
     error.SetErrorString("Invalid Syntax");
   return error;
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(const char *json) {

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

const UnixSignalsSP &PlatformRemoteGDBServer::GetRemoteUnixSignals() {
   StringExtractorGDBRemote response;
   auto result =
       m_gdb_client_up->SendPacketAndWaitForResponse("jSignalsInfo", response);
 
   if (result != decltype(result)::Success ||
       response.GetResponseType() != response.eResponse)
     return m_remote_signals_sp;
 
-  auto object_sp =
-      StructuredData::ParseJSON(std::string(response.GetStringRef()));
+  auto object_sp = StructuredData::ParseJSON(response.GetStringRef());
   if (!object_sp || !object_sp->IsValid())
     return m_remote_signals_sp;
 
   auto array_sp = object_sp->GetAsArray();
   if (!array_sp || !array_sp->IsValid())
     return m_remote_signals_sp;
 
   auto remote_signals_sp = std::make_shared<lldb_private::GDBRemoteSignals>();

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

StructuredData::ObjectSP GDBRemoteCommunicationClient::GetThreadsInfo() {
   if (m_supports_jThreadsInfo) {
     StringExtractorGDBRemote response;
     response.SetResponseValidatorToJSON();
     if (SendPacketAndWaitForResponse("jThreadsInfo", response) ==
         PacketResult::Success) {
       if (response.IsUnsupportedResponse()) {
         m_supports_jThreadsInfo = false;
       } else if (!response.Empty()) {
-        object_sp =
-            StructuredData::ParseJSON(std::string(response.GetStringRef()));
+        object_sp = StructuredData::ParseJSON(response.GetStringRef());
       }
     }
   }
   return object_sp;
 }
 
 bool GDBRemoteCommunicationClient::GetThreadExtendedInfoSupported() {
   if (m_supports_jThreadExtendedInfo == eLazyBoolCalculate) {
size_t GDBRemoteCommunicationClient::QueryGDBServer(
   connection_urls.clear();
 
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse("qQueryGDBServer", response) !=
       PacketResult::Success)
     return 0;
 
   StructuredData::ObjectSP data =
-      StructuredData::ParseJSON(std::string(response.GetStringRef()));
+      StructuredData::ParseJSON(response.GetStringRef());
   if (!data)
     return 0;
 
   StructuredData::Array *array = data->GetAsArray();
   if (!array)
     return 0;
 
   for (size_t i = 0, count = array->GetSize(); i < count; ++i) {
if (SendPacketAndWaitForResponse(payload.GetString(), response) !=
     return std::nullopt;
 
   if (response.IsUnsupportedResponse()) {
     m_supports_jModulesInfo = false;
     return std::nullopt;
   }
 
   StructuredData::ObjectSP response_object_sp =
-      StructuredData::ParseJSON(std::string(response.GetStringRef()));
+      StructuredData::ParseJSON(response.GetStringRef());
   if (!response_object_sp)
     return std::nullopt;
 
   StructuredData::Array *response_array = response_object_sp->GetAsArray();
   if (!response_array)
     return std::nullopt;
 
   std::vector<ModuleSpec> result;
if (!m_supported_async_json_packets_is_valid) {
 
     Log *log = GetLog(GDBRLog::Process);
 
     // Poll it now.
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response) ==
         PacketResult::Success) {
       m_supported_async_json_packets_sp =
-          StructuredData::ParseJSON(std::string(response.GetStringRef()));
+          StructuredData::ParseJSON(response.GetStringRef());
       if (m_supported_async_json_packets_sp &&
           !m_supported_async_json_packets_sp->GetAsArray()) {
         // We were returned something other than a JSON array.  This is
         // invalid.  Clear it out.
         LLDB_LOGF(log,
                   "GDBRemoteCommunicationClient::%s(): "
                   "QSupportedAsyncJSONPackets returned invalid "
                   "result: %s",

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

if (m_gdb_comm.GetThreadExtendedInfoSupported()) {
     StringExtractorGDBRemote response;
     response.SetResponseValidatorToJSON();
     if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
         GDBRemoteCommunication::PacketResult::Success) {
       StringExtractorGDBRemote::ResponseType response_type =
           response.GetResponseType();
       if (response_type == StringExtractorGDBRemote::eResponse) {
         if (!response.Empty()) {
-          object_sp =
-              StructuredData::ParseJSON(std::string(response.GetStringRef()));
+          object_sp = StructuredData::ParseJSON(response.GetStringRef());
         }
       }
     }
   }
   return object_sp;
 }
 
 StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos(
if (m_gdb_comm.GetLoadedDynamicLibrariesInfosSupported()) {
     StringExtractorGDBRemote response;
     response.SetResponseValidatorToJSON();
     if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
         GDBRemoteCommunication::PacketResult::Success) {
       StringExtractorGDBRemote::ResponseType response_type =
           response.GetResponseType();
       if (response_type == StringExtractorGDBRemote::eResponse) {
         if (!response.Empty()) {
-          object_sp =
-              StructuredData::ParseJSON(std::string(response.GetStringRef()));
+          object_sp = StructuredData::ParseJSON(response.GetStringRef());
         }
       }
     }
   }
   return object_sp;
 }
 
 StructuredData::ObjectSP ProcessGDBRemote::GetDynamicLoaderProcessState() {
   StructuredData::ObjectSP object_sp;
   StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
 
   if (m_gdb_comm.GetDynamicLoaderProcessStateSupported()) {
     StringExtractorGDBRemote response;
     response.SetResponseValidatorToJSON();
     if (m_gdb_comm.SendPacketAndWaitForResponse("jGetDyldProcessState",
                                                 response) ==
         GDBRemoteCommunication::PacketResult::Success) {
       StringExtractorGDBRemote::ResponseType response_type =
           response.GetResponseType();
       if (response_type == StringExtractorGDBRemote::eResponse) {
         if (!response.Empty()) {
-          object_sp =
-              StructuredData::ParseJSON(std::string(response.GetStringRef()));
+          object_sp = StructuredData::ParseJSON(response.GetStringRef());
         }
       }
     }
   }
   return object_sp;
 }
 
 StructuredData::ObjectSP ProcessGDBRemote::GetSharedCacheInfo() {
if (m_gdb_comm.GetSharedCacheInfoSupported()) {
     StringExtractorGDBRemote response;
     response.SetResponseValidatorToJSON();
     if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
         GDBRemoteCommunication::PacketResult::Success) {
       StringExtractorGDBRemote::ResponseType response_type =
           response.GetResponseType();
       if (response_type == StringExtractorGDBRemote::eResponse) {
         if (!response.Empty()) {
-          object_sp =
-              StructuredData::ParseJSON(std::string(response.GetStringRef()));
+          object_sp = StructuredData::ParseJSON(response.GetStringRef());
         }
       }
     }
   }
   return object_sp;
 }
 
 Status ProcessGDBRemote::ConfigureStructuredData(
if (log) {
           "%s",
           __FUNCTION__,
           packet.slice(0, strlen(s_async_json_packet_prefix)).str().c_str());
     }
     return StructuredData::ObjectSP();
   }
 
   // This is an asynchronous JSON packet, destined for a StructuredDataPlugin.
-  StructuredData::ObjectSP json_sp =
-      StructuredData::ParseJSON(std::string(packet));
+  StructuredData::ObjectSP json_sp = StructuredData::ParseJSON(packet);
   if (log) {
     if (json_sp) {
       StreamString json_str;
       json_sp->Dump(json_str, true);
       json_str.Flush();
       LLDB_LOGF(log,
                 "ProcessGDBRemote::%s() "
                 "received Async StructuredData packet: %s",

lldb/source/Utility/StructuredData.cpp

 
 using namespace lldb_private;
 using namespace llvm;
 
 static StructuredData::ObjectSP ParseJSONValue(json::Value &value);
 static StructuredData::ObjectSP ParseJSONObject(json::Object *object);
 static StructuredData::ObjectSP ParseJSONArray(json::Array *array);
 
-StructuredData::ObjectSP
-StructuredData::ParseJSON(const std::string &json_text) {
+StructuredData::ObjectSP StructuredData::ParseJSON(llvm::StringRef json_text) {
   llvm::Expected<json::Value> value = json::parse(json_text);
   if (!value) {
     llvm::consumeError(value.takeError());
     return nullptr;
   }
   return ParseJSONValue(*value);
 }
 

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

TEST_F(GDBRemoteCommunicationClientTest, TestPacketSpeedJSON) {
   });
 
   StreamString ss;
   client.TestPacketSpeed(10, 32, 32, 4096, true, ss);
   client.Disconnect();
   server_thread.join();
 
   GTEST_LOG_(INFO) << "Formatted output: " << ss.GetData();
-  auto object_sp = StructuredData::ParseJSON(std::string(ss.GetString()));
+  auto object_sp = StructuredData::ParseJSON(ss.GetString());
   ASSERT_TRUE(bool(object_sp));
   auto dict_sp = object_sp->GetAsDictionary();
   ASSERT_TRUE(bool(dict_sp));
 
   object_sp = dict_sp->GetValueForKey("packet_speeds");
   ASSERT_TRUE(bool(object_sp));
   dict_sp = object_sp->GetAsDictionary();
   ASSERT_TRUE(bool(dict_sp));

lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp

JThreadsInfo::parseRegisters(const StructuredData::Dictionary &Dict,
   }
   return std::move(Result);
 }
 
 Expected<JThreadsInfo> JThreadsInfo::create(StringRef Response,
                                             ArrayRef<RegisterInfo> RegInfos) {
   JThreadsInfo jthreads_info;
 
-  StructuredData::ObjectSP json =
-      StructuredData::ParseJSON(std::string(Response));
+  StructuredData::ObjectSP json = StructuredData::ParseJSON(Response);
   StructuredData::Array *array = json->GetAsArray();
   if (!array)
     return make_parsing_error("JThreadsInfo: JSON array");
 
   for (size_t i = 0; i < array->GetSize(); i++) {
     StructuredData::Dictionary *thread_info;
     array->GetItemAtIndexAsDictionary(i, thread_info);
     if (!thread_info)