[lldb] Take StringRef names in GetChildAtNamePath (NFC)

[kastiglione]

Summary

Following D151810, this changes GetChildAtNamePath to take a path of StringRef
values instead of ConstString.

[Michael137]

lgtm

lldb/include/lldb/Core/ValueObject.h

483

Guessing removing the parameter is fine because no callers were actually passing it?

[JDevlieghere]

lldb/source/Core/ValueObject.cpp

434

I don’t think this qualifies for ‘auto’ according to the LLVM coding guidelines.

[kastiglione]

lldb/include/lldb/Core/ValueObject.h

483

I forgot I had made this change too. Correct, no callers were using this, so I removed it. I can imagine there could be a hypothetical case that uses it to determine a fallback action, but none do and it seems unlikely.

lldb/source/Core/ValueObject.cpp

434

I find the guidelines to be not specific enough. Case in point, this section shows auto being used in range for loops: https://llvm.org/docs/CodingStandards.html#beware-unnecessary-copies-with-auto

[bulbazord]

lldb/source/Core/ValueObject.cpp

434

nit: mark name as const -> const auto name.
I suppose it's ok if it's a copy since it's a StringRef and it's less expensive to make the copy?

[kastiglione]

lldb/source/Core/ValueObject.cpp

434

yes I figure a StringRef is cheap to copy.

[kastiglione]

Change auto to StringRef

lldb/include/lldb/Core/ValueObject.h

public:
   lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,
                                           size_t *index_of_error = nullptr);
 
   lldb::ValueObjectSP
   GetChildAtIndexPath(llvm::ArrayRef<std::pair<size_t, bool>> idxs,
                       size_t *index_of_error = nullptr);
 
   // this will always create the children if necessary
-  lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<ConstString> names,
-                                         ConstString *name_of_error = nullptr);
+  lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<llvm::StringRef> names);
 
   lldb::ValueObjectSP
   GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names,
                      ConstString *name_of_error = nullptr);
 
   virtual lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
                                                      bool can_create);
 

lldb/source/Core/ValueObject.cpp

if (!root) {
         *index_of_error = idx.first;
       return root;
     }
   }
   return root;
 }
 
 lldb::ValueObjectSP
-ValueObject::GetChildAtNamePath(llvm::ArrayRef<ConstString> names,
-                                ConstString *name_of_error) {
+ValueObject::GetChildAtNamePath(llvm::ArrayRef<llvm::StringRef> names) {
   if (names.size() == 0)
     return GetSP();
   ValueObjectSP root(GetSP());
-  for (ConstString name : names) {
+  for (auto name : names) {
     root = root->GetChildMemberWithName(name, true);
     if (!root) {
-      if (name_of_error)
-        *name_of_error = name;
       return root;
     }
   }
   return root;
 }
 
 lldb::ValueObjectSP ValueObject::GetChildAtNamePath(
     llvm::ArrayRef<std::pair<ConstString, bool>> names,

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

 }
 
 bool lldb_private::formatters::LibcxxSmartPointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
   ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_", true));
-  ValueObjectSP count_sp(valobj_sp->GetChildAtNamePath(
-      {ConstString("__cntrl_"), ConstString("__shared_owners_")}));
-  ValueObjectSP weakcount_sp(valobj_sp->GetChildAtNamePath(
-      {ConstString("__cntrl_"), ConstString("__shared_weak_owners_")}));
+  ValueObjectSP count_sp(
+      valobj_sp->GetChildAtNamePath({"__cntrl_", "__shared_owners_"}));
+  ValueObjectSP weakcount_sp(
+      valobj_sp->GetChildAtNamePath({"__cntrl_", "__shared_weak_owners_"}));
 
   if (!ptr_sp)
     return false;
 
   if (ptr_sp->GetValueAsUnsigned(0) == 0) {
     stream.Printf("nullptr");
     return true;
   } else {
ExtractLibcxxStringInfo(ValueObject &valobj) {
   uint64_t size_mode_value = 0;
 
   ValueObjectSP short_sp =
       valobj_rep_sp->GetChildMemberWithName("__s", /*can_create=*/true);
   if (!short_sp)
     return {};
 
   ValueObjectSP is_long = short_sp->GetChildMemberWithName("__is_long_", true);
-  ValueObjectSP size_sp =
-      short_sp->GetChildAtNamePath({ConstString("__size_")});
+  ValueObjectSP size_sp = short_sp->GetChildMemberWithName("__size_", true);
   if (!size_sp)
     return {};
 
   if (is_long) {
     using_bitmasks = false;
     short_mode = !is_long->GetValueAsUnsigned(/*fail_value=*/0);
     size = size_sp->GetValueAsUnsigned(/*fail_value=*/0);
   } else {

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
 
   if (!m_item)
     return 0;
   m_count = m_item->GetValueAsUnsigned(0);
   return m_count;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() {
-  static ConstString g_tree_("__tree_");
-  static ConstString g_pair3("__pair3_");
-
   if (m_element_type.IsValid())
     return true;
   m_element_type.Clear();
   ValueObjectSP deref;
   Status error;
   deref = m_root_node->Dereference(error);
   if (!deref || error.Fail())
     return false;
   deref = deref->GetChildMemberWithName("__value_", true);
   if (deref) {
     m_element_type = deref->GetCompilerType();
     return true;
   }
-  deref = m_backend.GetChildAtNamePath({g_tree_, g_pair3});
+  deref = m_backend.GetChildAtNamePath({"__tree_", "__pair3_"});
   if (!deref)
     return false;
   m_element_type = deref->GetCompilerType()
                        .GetTypeTemplateArgument(1)
                        .GetTypeTemplateArgument(1);
   if (m_element_type) {
     std::string name;
     uint64_t bit_offset_ptr;

lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

while (idx >= m_elements_cache.size()) {
     ValueObjectSP node_sp = m_next_element->Dereference(error);
     if (!node_sp || error.Fail())
       return lldb::ValueObjectSP();
 
     ValueObjectSP value_sp = node_sp->GetChildMemberWithName("__value_", true);
     ValueObjectSP hash_sp = node_sp->GetChildMemberWithName("__hash_", true);
     if (!hash_sp || !value_sp) {
       if (!m_element_type) {
-        auto p1_sp = m_backend.GetChildAtNamePath({ConstString("__table_"),
-                                                   ConstString("__p1_")});
+        auto p1_sp = m_backend.GetChildAtNamePath({"__table_", "__p1_"});
         if (!p1_sp)
           return nullptr;
 
         ValueObjectSP first_sp = nullptr;
         switch (p1_sp->GetCompilerType().GetNumDirectBaseClasses()) {
         case 1:
           // Assume a pre llvm r300140 __compressed_pair implementation:
           first_sp = p1_sp->GetChildMemberWithName("__first_", true);
bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
   m_next_element = nullptr;
   m_elements_cache.clear();
   ValueObjectSP table_sp = m_backend.GetChildMemberWithName("__table_", true);
   if (!table_sp)
     return false;
 
   ValueObjectSP p2_sp = table_sp->GetChildMemberWithName("__p2_", true);
   ValueObjectSP num_elements_sp = nullptr;
-  llvm::SmallVector<ConstString, 3> next_path;
+  llvm::SmallVector<llvm::StringRef, 3> next_path;
   switch (p2_sp->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
     num_elements_sp = p2_sp->GetChildMemberWithName("__first_", true);
-    next_path.append({ConstString("__p1_"), ConstString("__first_"),
-                      ConstString("__next_")});
+    next_path.append({"__p1_", "__first_", "__next_"});
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
     ValueObjectSP first_elem_parent = p2_sp->GetChildAtIndex(0, true);
     num_elements_sp =
         first_elem_parent->GetChildMemberWithName("__value_", true);
-    next_path.append({ConstString("__p1_"), ConstString("__value_"),
-                      ConstString("__next_")});
+    next_path.append({"__p1_", "__value_", "__next_"});
     break;
   }
   default:
     return false;
   }
 
   if (!num_elements_sp)
     return false;

lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

bool lldb_private::formatters::LibStdcppSmartPointerSummaryProvider(
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
   ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("_M_ptr", true));
   if (!ptr_sp)
     return false;
 
-  ValueObjectSP usecount_sp(valobj_sp->GetChildAtNamePath(
-      {ConstString("_M_refcount"), ConstString("_M_pi"),
-       ConstString("_M_use_count")}));
+  ValueObjectSP usecount_sp(
+      valobj_sp->GetChildAtNamePath({"_M_refcount", "_M_pi", "_M_use_count"}));
   if (!usecount_sp)
     return false;
 
   if (ptr_sp->GetValueAsUnsigned(0) == 0 ||
       usecount_sp->GetValueAsUnsigned(0) == 0) {
     stream.Printf("nullptr");
     return true;
   }