[lldb] Take StringRef name in GetIndexOfChildWithName (NFC)

[kastiglione]

Summary

As with D151615, which changed GetIndexOfChildMemberWithName to take a StringRef
instead of a ConstString, this change does the same for GetIndexOfChildWithName.

[Michael137]

lgtm

lldb/source/Core/ValueObjectSyntheticFilter.cpp

338

Could pass name_ref directly now, instead of doing the implicit conversion

[kastiglione]

lldb/source/Core/ValueObjectSyntheticFilter.cpp

338

This is a different GetIndexOfChildWithName, in the SyntheticChildrenFrontEnd class. It still takes a ConstString, changing it is a follow up.

lldb/include/lldb/Core/ValueObject.h

public:
 
   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);
 
-  virtual size_t GetIndexOfChildWithName(ConstString name);
+  virtual size_t GetIndexOfChildWithName(llvm::StringRef name);
 
   size_t GetNumChildren(uint32_t max = UINT32_MAX);
 
   const Value &GetValue() const { return m_value; }
 
   Value &GetValue() { return m_value; }
 
   virtual bool ResolveValue(Scalar &scalar);

lldb/include/lldb/Core/ValueObjectRegister.h

public:
   size_t CalculateNumChildren(uint32_t max) override;
 
   ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
                                   int32_t synthetic_index) override;
 
   lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
                                              bool can_create) override;
 
-  size_t GetIndexOfChildWithName(ConstString name) override;
+  size_t GetIndexOfChildWithName(llvm::StringRef name) override;
 
 protected:
   bool UpdateValue() override;
 
   CompilerType GetCompilerTypeImpl() override;
 
   lldb::RegisterContextSP m_reg_ctx_sp;
   const RegisterSet *m_reg_set;

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

public:
 
   lldb::ValueType GetValueType() const override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create) override;
 
   lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
                                              bool can_create) override;
 
-  size_t GetIndexOfChildWithName(ConstString name) override;
+  size_t GetIndexOfChildWithName(llvm::StringRef name) override;
 
   lldb::ValueObjectSP
   GetDynamicValue(lldb::DynamicValueType valueType) override;
 
   bool IsInScope() override;
 
   bool HasSyntheticValue() override { return false; }
 

lldb/include/lldb/Symbol/CompilerType.h

CompilerType GetChildCompilerTypeAtIndex(
       std::string &child_name, uint32_t &child_byte_size,
       int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
       uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
       bool &child_is_deref_of_parent, ValueObject *valobj,
       uint64_t &language_flags) const;
 
   /// Lookup a child given a name. This function will match base class names and
   /// member member names in "clang_type" only, not descendants.
-  uint32_t GetIndexOfChildWithName(const char *name,
+  uint32_t GetIndexOfChildWithName(llvm::StringRef name,
                                    bool omit_empty_base_classes) const;
 
   /// Lookup a child member given a name. This function will match member names
   /// only and will descend into "clang_type" children in search for the first
   /// member in this class, or any base class that matches "name".
   /// TODO: Return all matches for a given name by returning a
   /// vector<vector<uint32_t>>
   /// so we catch all names that match a given child name, not just the first.

lldb/include/lldb/Symbol/TypeSystem.h

virtual CompilerType GetChildCompilerTypeAtIndex(
       uint32_t &child_byte_size, int32_t &child_byte_offset,
       uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
       bool &child_is_base_class, bool &child_is_deref_of_parent,
       ValueObject *valobj, uint64_t &language_flags) = 0;
 
   // Lookup a child given a name. This function will match base class names and
   // member member names in "clang_type" only, not descendants.
   virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
-                                           const char *name,
+                                           llvm::StringRef name,
                                            bool omit_empty_base_classes) = 0;
 
   // Lookup a child member given a name. This function will match member names
   // only and will descend into "clang_type" children in search for the first
   // member in this class, or any base class that matches "name".
   // TODO: Return all matches for a given name by returning a
   // vector<vector<uint32_t>>
   // so we catch all names that match a given child name, not just the first.

lldb/source/API/SBValue.cpp

 
 uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
   LLDB_INSTRUMENT_VA(this, name);
 
   uint32_t idx = UINT32_MAX;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
-    idx = value_sp->GetIndexOfChildWithName(ConstString(name));
+    idx = value_sp->GetIndexOfChildWithName(name);
   }
   return idx;
 }
 
 SBValue SBValue::GetChildMemberWithName(const char *name) {
   LLDB_INSTRUMENT_VA(this, name);
 
   lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;

lldb/source/Core/ValueObject.cpp

if (!root) {
       if (name_of_error)
         *name_of_error = name.first;
       return root;
     }
   }
   return root;
 }
 
-size_t ValueObject::GetIndexOfChildWithName(ConstString name) {
+size_t ValueObject::GetIndexOfChildWithName(llvm::StringRef name) {
   bool omit_empty_base_classes = true;
-  return GetCompilerType().GetIndexOfChildWithName(name.GetCString(),
+  return GetCompilerType().GetIndexOfChildWithName(name,
                                                    omit_empty_base_classes);
 }
 
 ValueObjectSP ValueObject::GetChildMemberWithName(llvm::StringRef name,
                                                   bool can_create) {
   // We may need to update our value if we are dynamic.
   if (IsPossibleDynamicType())
     UpdateValueIfNeeded(false);

lldb/source/Core/ValueObjectRegister.cpp

if (reg_info != nullptr)
       valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, reg_info);
   }
   if (valobj)
     return valobj->GetSP();
   else
     return ValueObjectSP();
 }
 
-size_t
-ValueObjectRegisterSet::GetIndexOfChildWithName(ConstString name) {
+size_t ValueObjectRegisterSet::GetIndexOfChildWithName(llvm::StringRef name) {
   if (m_reg_ctx_sp && m_reg_set) {
-    const RegisterInfo *reg_info =
-        m_reg_ctx_sp->GetRegisterInfoByName(name.GetStringRef());
+    const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName(name);
     if (reg_info != nullptr)
       return reg_info->kinds[eRegisterKindLLDB];
   }
   return UINT32_MAX;
 }
 
 #pragma mark -
 #pragma mark ValueObjectRegister

lldb/source/Core/ValueObjectSyntheticFilter.cpp

 //===-- ValueObjectSyntheticFilter.cpp ------------------------------------===//
 //
 // 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/Core/ValueObjectSyntheticFilter.h"
 
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include <optional>
 
 namespace lldb_private {
ValueObjectSynthetic::GetChildMemberWithName(llvm::StringRef name,
   uint32_t index = GetIndexOfChildWithName(ConstString(name));
 
   if (index == UINT32_MAX)
     return lldb::ValueObjectSP();
 
   return GetChildAtIndex(index, can_create);
 }
 
-size_t ValueObjectSynthetic::GetIndexOfChildWithName(ConstString name) {
+size_t ValueObjectSynthetic::GetIndexOfChildWithName(llvm::StringRef name_ref) {
   UpdateValueIfNeeded();
 
+  ConstString name(name_ref);
+
   uint32_t found_index = UINT32_MAX;
   bool did_find;
   {
     std::lock_guard<std::mutex> guard(m_child_mutex);
     auto name_to_index = m_name_toindex.find(name.GetCString());
     did_find = name_to_index != m_name_toindex.end();
     if (did_find)
       found_index = name_to_index->second;
   }
 
   if (!did_find && m_synth_filter_up != nullptr) {
     uint32_t index = m_synth_filter_up->GetIndexOfChildWithName(name);
     if (index == UINT32_MAX)
       return index;
     std::lock_guard<std::mutex> guard(m_child_mutex);
     m_name_toindex[name.GetCString()] = index;
     return index;
   } else if (!did_find && m_synth_filter_up == nullptr)
     return UINT32_MAX;
   else /*if (iter != m_name_toindex.end())*/

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

ExtractLibcxxStringInfo(ValueObject &valobj) {
   if (!valobj_rep_sp)
     return {};
 
   ValueObjectSP l = valobj_rep_sp->GetChildMemberWithName("__l",
                                                           /*can_create=*/true);
   if (!l)
     return {};
 
-  StringLayout layout = l->GetIndexOfChildWithName(ConstString("__data_")) == 0
+  StringLayout layout = l->GetIndexOfChildWithName("__data_") == 0
                             ? StringLayout::DSC
                             : StringLayout::CSD;
 
   bool short_mode = false; // this means the string is in short-mode and the
                            // data is stored inline
   bool using_bitmasks = true; // Whether the class uses bitmasks for the mode
                               // flag (pre-D123580).
   uint64_t size;

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

CompilerType GetChildCompilerTypeAtIndex(
       uint32_t &child_byte_size, int32_t &child_byte_offset,
       uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
       bool &child_is_base_class, bool &child_is_deref_of_parent,
       ValueObject *valobj, uint64_t &language_flags) override;
 
   // Lookup a child given a name. This function will match base class names and
   // member member names in "clang_type" only, not descendants.
   uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
-                                   const char *name,
+                                   llvm::StringRef name,
                                    bool omit_empty_base_classes) override;
 
   // Lookup a child member given a name. This function will match member names
   // only and will descend into "clang_type" children in search for the first
   // member in this class, or any base class that matches "name".
   // TODO: Return all matches for a given name by returning a
   // vector<vector<uint32_t>>
   // so we catch all names that match a given child name, not just the first.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

 }
 
 // Get the index of the child of "clang_type" whose name matches. This function
 // doesn't descend into the children, but only looks one level deep and name
 // matches can include base class names.
 
 uint32_t
 TypeSystemClang::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
-                                         const char *name,
+                                         llvm::StringRef name,
                                          bool omit_empty_base_classes) {
-  if (type && name && name[0]) {
+  if (type && !name.empty()) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
 
     switch (type_class) {
     case clang::Type::Record:
       if (GetCompleteType(type)) {
         const clang::RecordType *record_type =
case clang::Type::Record:
             if (base_class_type_name == name)
               return child_idx;
             ++child_idx;
           }
         }
 
         // Try and find a field that matches NAME
         clang::RecordDecl::field_iterator field, field_end;
-        llvm::StringRef name_sref(name);
         for (field = record_decl->field_begin(),
             field_end = record_decl->field_end();
              field != field_end; ++field, ++child_idx) {
-          if (field->getName().equals(name_sref))
+          if (field->getName().equals(name))
             return child_idx;
         }
       }
       break;
 
     case clang::Type::ObjCObject:
     case clang::Type::ObjCInterface:
       if (GetCompleteType(type)) {
-        llvm::StringRef name_sref(name);
         const clang::ObjCObjectType *objc_class_type =
             llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
         assert(objc_class_type);
         if (objc_class_type) {
           uint32_t child_idx = 0;
           clang::ObjCInterfaceDecl *class_interface_decl =
               objc_class_type->getInterface();
 
           if (class_interface_decl) {
             clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
                 ivar_end = class_interface_decl->ivar_end();
             clang::ObjCInterfaceDecl *superclass_interface_decl =
                 class_interface_decl->getSuperClass();
 
             for (ivar_pos = class_interface_decl->ivar_begin();
                  ivar_pos != ivar_end; ++ivar_pos, ++child_idx) {
               const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
 
-              if (ivar_decl->getName().equals(name_sref)) {
+              if (ivar_decl->getName().equals(name)) {
                 if ((!omit_empty_base_classes && superclass_interface_decl) ||
                     (omit_empty_base_classes &&
                      ObjCDeclHasIVars(superclass_interface_decl, true)))
                   ++child_idx;
 
                 return child_idx;
               }
             }
 
             if (superclass_interface_decl) {
-              if (superclass_interface_decl->getName().equals(name_sref))
+              if (superclass_interface_decl->getName().equals(name))
                 return 0;
             }
           }
         }
       }
       break;
 
     case clang::Type::ObjCObjectPointer: {

lldb/source/Symbol/CompilerType.cpp

bool CompilerType::IsMeaninglessWithoutDynamicResolution() const {
   return false;
 }
 
 // Get the index of the child of "clang_type" whose name matches. This function
 // doesn't descend into the children, but only looks one level deep and name
 // matches can include base class names.
 
 uint32_t
-CompilerType::GetIndexOfChildWithName(const char *name,
+CompilerType::GetIndexOfChildWithName(llvm::StringRef name,
                                       bool omit_empty_base_classes) const {
-  if (IsValid() && name && name[0]) {
+  if (IsValid() && !name.empty()) {
     if (auto type_system_sp = GetTypeSystem())
       return type_system_sp->GetIndexOfChildWithName(m_type, name,
                                                      omit_empty_base_classes);
   }
   return UINT32_MAX;
 }
 
 // Dumping types
 
 void CompilerType::DumpValue(ExecutionContext *exe_ctx, Stream *s,
                              lldb::Format format, const DataExtractor &data,