[lldb][NFCI] Remove unneeded temporary std::string allocations in SBAPI

[bulbazord]

Summary

This uses some friend class trickery to avoid some unneeded temporary
std::string allocations.

lldb/include/lldb/API/SBStringList.h

public:
   void Clear();
 
 protected:
   friend class SBCommandInterpreter;
   friend class SBDebugger;
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
+  friend class SBStructuredData;
 
   SBStringList(const lldb_private::StringList *lldb_strings);
 
   void AppendList(const lldb_private::StringList &strings);
 
+  lldb_private::StringList *operator->();
+
   const lldb_private::StringList *operator->() const;
 
   const lldb_private::StringList &operator*() const;
 
 private:
   std::unique_ptr<lldb_private::StringList> m_opaque_up;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBSTRINGLIST_H

lldb/source/API/SBDebugger.cpp

if (m_opaque_sp)
     m_opaque_sp->SetTerminalWidth(term_width);
 }
 
 const char *SBDebugger::GetPrompt() const {
   LLDB_INSTRUMENT_VA(this);
 
   Log *log = GetLog(LLDBLog::API);
 
-  LLDB_LOGF(log, "SBDebugger(%p)::GetPrompt () => \"%s\"",
-            static_cast<void *>(m_opaque_sp.get()),
-            (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
+  LLDB_LOG(log, "SBDebugger({0:x})::GetPrompt () => \"{1}\"",
+           (m_opaque_sp ? m_opaque_sp->GetPrompt() : ""));
 
   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
                       : nullptr);
 }
 
 void SBDebugger::SetPrompt(const char *prompt) {
   LLDB_INSTRUMENT_VA(this, prompt);
 

lldb/source/API/SBStringList.cpp

const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
   return *this;
 }
 
 SBStringList::~SBStringList() = default;
 
+lldb_private::StringList *SBStringList::operator->() {
+  if (!IsValid())
+    m_opaque_up = std::make_unique<lldb_private::StringList>();
+
+  return m_opaque_up.get();
+}
+
 const lldb_private::StringList *SBStringList::operator->() const {
   return m_opaque_up.get();
 }
 
 const lldb_private::StringList &SBStringList::operator*() const {
   return *m_opaque_up;
 }
 

lldb/source/API/SBStructuredData.cpp

 #include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StringList.h"
 #include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark--
 #pragma mark SBStructuredData
 
bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
   StructuredData::Dictionary *dict = obj_sp->GetAsDictionary();
   // We claimed we were a dictionary, so this can't be null.
   assert(dict);
   // The return kind of GetKeys is an Array:
   StructuredData::ObjectSP array_sp = dict->GetKeys();
   StructuredData::Array *key_arr = array_sp->GetAsArray();
   assert(key_arr);
 
-  key_arr->ForEach([&keys] (StructuredData::Object *object) -> bool {
+  key_arr->ForEach([&keys](StructuredData::Object *object) -> bool {
     llvm::StringRef key = object->GetStringValue("");
-    keys.AppendString(key.str().c_str());
+    keys->AppendString(key);
     return true;
   });
   return true;
 }
 
 lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
   LLDB_INSTRUMENT_VA(this, key);
 

lldb/source/API/SBThread.cpp

if (exe_ctx.HasThreadScope()) {
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       Thread *thread = exe_ctx.GetThreadPtr();
       StructuredData::ObjectSP info_root_sp = thread->GetExtendedInfo();
       if (info_root_sp) {
         StructuredData::ObjectSP node =
             info_root_sp->GetObjectForDotSeparatedPath(path);
         if (node) {
           if (node->GetType() == eStructuredDataTypeString) {
-            strm.Printf("%s", node->GetAsString()->GetValue().str().c_str());
+            strm.ref() << node->GetAsString()->GetValue();
             success = true;
           }
           if (node->GetType() == eStructuredDataTypeInteger) {
             strm.Printf("0x%" PRIx64, node->GetUnsignedIntegerValue());
             success = true;
           }
           if (node->GetType() == eStructuredDataTypeFloat) {
             strm.Printf("0x%f", node->GetAsFloat()->GetValue());