[lldb][NFCI] Remove StructuredData::Array::GetItemAtIndexAsString overloads with ConstString

[bulbazord]

Summary

This is the next step in removing ConstString from StructuredData. There
are StringRef overloads already, let's use those where we can.

[mib]

lldb/source/Target/DynamicRegisterInfo.cpp

204

I guess m_sets is a vector of char* ... Should we change it to lldb::StringList or llvm::StringSet so we don't have to create a ConstString here ?

[bulbazord]

lldb/source/Target/DynamicRegisterInfo.cpp

204

m_sets is a vector of lldb_private::RegisterSet (which contains a const char *). I think it's assumed that they are backed by a ConstString. Because RegisterSet is defined in lldb-private-types.h we'd have to move it somewhere else before we could actually use any types other than const char *, I think?

[fdeazeve]

LGTM!

lldb/include/lldb/Utility/StructuredData.h

public:
     bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result,
                                 llvm::StringRef default_val) const {
       bool success = GetItemAtIndexAsString(idx, result);
       if (!success)
         result = default_val;
       return success;
     }
 
-    bool GetItemAtIndexAsString(size_t idx, ConstString &result) const {
-      ObjectSP value_sp = GetItemAtIndex(idx);
-      if (value_sp.get()) {
-        if (auto string_value = value_sp->GetAsString()) {
-          result = ConstString(string_value->GetValue());
-          return true;
-        }
-      }
-      return false;
-    }
-
-    bool GetItemAtIndexAsString(size_t idx, ConstString &result,
-                                const char *default_val) const {
-      bool success = GetItemAtIndexAsString(idx, result);
-      if (!success)
-        result.SetCString(default_val);
-      return success;
-    }
-
     bool GetItemAtIndexAsDictionary(size_t idx, Dictionary *&result) const {
       result = nullptr;
       ObjectSP value_sp = GetItemAtIndex(idx);
       if (value_sp.get()) {
         result = value_sp->GetAsDictionary();
         return (result != nullptr);
       }
       return false;

lldb/source/Target/DynamicRegisterInfo.cpp

llvm::Expected<uint32_t> DynamicRegisterInfo::ByteOffsetFromComposite(
   const size_t num_composite_regs = composite_reg_list.GetSize();
   if (num_composite_regs == 0)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "\"composite\" list is empty");
 
   uint32_t composite_offset = UINT32_MAX;
   for (uint32_t composite_idx = 0; composite_idx < num_composite_regs;
        ++composite_idx) {
-    ConstString composite_reg_name;
-    if (!composite_reg_list.GetItemAtIndexAsString(composite_idx,
-                                                   composite_reg_name, nullptr))
+    llvm::StringRef composite_reg_name;
+    if (!composite_reg_list.GetItemAtIndexAsString(composite_idx, composite_reg_name))
       return llvm::createStringError(
           llvm::inconvertibleErrorCode(),
           "\"composite\" list value is not a Python string at index %d",
           composite_idx);
 
     const RegisterInfo *composite_reg_info =
-        GetRegisterInfo(composite_reg_name.GetStringRef());
+        GetRegisterInfo(composite_reg_name);
     if (!composite_reg_info)
       return llvm::createStringError(
           llvm::inconvertibleErrorCode(),
           "failed to find composite register by name: \"%s\"",
-          composite_reg_name.GetCString());
+          composite_reg_name.str().c_str());
 
     composite_offset =
         std::min(composite_offset, composite_reg_info->byte_offset);
     m_value_regs_map[index].push_back(
         composite_reg_info->kinds[eRegisterKindLLDB]);
     m_invalidate_regs_map[composite_reg_info->kinds[eRegisterKindLLDB]]
         .push_back(index);
     m_invalidate_regs_map[index].push_back(

 DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
                                      const ArchSpec &arch) {
   Log *log = GetLog(LLDBLog::Object);
   assert(!m_finalized);
   StructuredData::Array *sets = nullptr;
   if (dict.GetValueForKeyAsArray("sets", sets)) {
     const uint32_t num_sets = sets->GetSize();
     for (uint32_t i = 0; i < num_sets; ++i) {
-      ConstString set_name;
-      if (sets->GetItemAtIndexAsString(i, set_name) && !set_name.IsEmpty()) {
-        m_sets.push_back({set_name.AsCString(), nullptr, 0, nullptr});
+      llvm::StringRef set_name;
+      if (sets->GetItemAtIndexAsString(i, set_name) && !set_name.empty()) {
+        m_sets.push_back(
+            {ConstString(set_name).AsCString(), nullptr, 0, nullptr});
       } else {
         Clear();
         printf("error: register sets must have valid names\n");
         return 0;
       }
     }
     m_set_reg_nums.resize(m_sets.size());
   }
for (uint32_t i = 0; i < num_regs; ++i) {
     // Check if this register invalidates any other register values when it is
     // modified
     StructuredData::Array *invalidate_reg_list = nullptr;
     if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs",
                                              invalidate_reg_list)) {
       const size_t num_regs = invalidate_reg_list->GetSize();
       if (num_regs > 0) {
         for (uint32_t idx = 0; idx < num_regs; ++idx) {
-          ConstString invalidate_reg_name;
+          llvm::StringRef invalidate_reg_name;
           uint64_t invalidate_reg_num;
           if (invalidate_reg_list->GetItemAtIndexAsString(
                   idx, invalidate_reg_name)) {
             const RegisterInfo *invalidate_reg_info =
-                GetRegisterInfo(invalidate_reg_name.GetStringRef());
+                GetRegisterInfo(invalidate_reg_name);
             if (invalidate_reg_info) {
               m_invalidate_regs_map[i].push_back(
                   invalidate_reg_info->kinds[eRegisterKindLLDB]);
             } else {
               // TODO: print error invalid slice string that doesn't follow the
               // format
               printf("error: failed to find a 'invalidate-regs' register for "
                      "\"%s\" while parsing register \"%s\"\n",
-                     invalidate_reg_name.GetCString(), reg_info.name);
+                     invalidate_reg_name.str().c_str(), reg_info.name);
             }
           } else if (invalidate_reg_list->GetItemAtIndexAsInteger(
                          idx, invalidate_reg_num)) {
             if (invalidate_reg_num != UINT64_MAX)
               m_invalidate_regs_map[i].push_back(invalidate_reg_num);
             else
               printf("error: 'invalidate-regs' list value wasn't a valid "
                      "integer\n");