[lldb] Take StringRef name in GetIndexOfChildMemberWithName (NFC)

[kastiglione]

Summary

Change the type of the name parameter from char * to StringRef.

Follow up to D151615.

[JDevlieghere]

LGTM

[bulbazord]

Very straightforward. LGTM.

lldb/include/lldb/Symbol/CompilerType.h

public:
 
   /// 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.
   size_t
-  GetIndexOfChildMemberWithName(const char *name, bool omit_empty_base_classes,
+  GetIndexOfChildMemberWithName(llvm::StringRef name,
+                                bool omit_empty_base_classes,
                                 std::vector<uint32_t> &child_indexes) const;
 
   /// Return the number of template arguments the type has.
   /// If expand_pack is true, then variadic argument packs are automatically
   /// expanded to their supplied arguments. If it is false an argument pack
   /// will only count as 1 argument.
   size_t GetNumTemplateArguments(bool expand_pack = false) const;
 

lldb/include/lldb/Symbol/TypeSystem.h

virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
                                            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.
-  virtual size_t
-  GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
-                                const char *name, bool omit_empty_base_classes,
-                                std::vector<uint32_t> &child_indexes) = 0;
+  virtual size_t GetIndexOfChildMemberWithName(
+      lldb::opaque_compiler_type_t type, llvm::StringRef name,
+      bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) = 0;
 
   virtual bool IsTemplateType(lldb::opaque_compiler_type_t type);
 
   virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
                                          bool expand_pack);
 
   virtual lldb::TemplateArgumentKind
   GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx,

lldb/source/Core/ValueObject.cpp

ValueObjectSP ValueObject::GetChildMemberWithName(llvm::StringRef name,
   std::vector<uint32_t> child_indexes;
   bool omit_empty_base_classes = true;
 
   if (!GetCompilerType().IsValid())
     return ValueObjectSP();
 
   const size_t num_child_indexes =
       GetCompilerType().GetIndexOfChildMemberWithName(
-          name.str().data(), omit_empty_base_classes, child_indexes);
+          name, omit_empty_base_classes, child_indexes);
   if (num_child_indexes == 0)
     return nullptr;
 
   ValueObjectSP child_sp = GetSP();
   for (uint32_t idx : child_indexes)
     if (child_sp)
       child_sp = child_sp->GetChildAtIndex(idx, can_create);
   return child_sp;

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

#endif
   // 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.
   size_t
   GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
-                                const char *name, bool omit_empty_base_classes,
+                                llvm::StringRef name,
+                                bool omit_empty_base_classes,
                                 std::vector<uint32_t> &child_indexes) override;
 
   bool IsTemplateType(lldb::opaque_compiler_type_t type) override;
 
   size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
                                  bool expand_pack) override;
 
   lldb::TemplateArgumentKind

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

 // class C The second index 1 is the child index for "m_b" within class A
 //
 // With omit_empty_base_classes == true we would get an integer array back
 // with: { 0,  1 } The first index 0 is the child index for "class A" within
 // class C (since class B doesn't have any members it doesn't count) The second
 // index 1 is the child index for "m_b" within class A
 
 size_t TypeSystemClang::GetIndexOfChildMemberWithName(
-    lldb::opaque_compiler_type_t type, const char *name,
+    lldb::opaque_compiler_type_t type, llvm::StringRef name,
     bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
-  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 =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
         const clang::RecordDecl *record_decl = record_type->getDecl();
 
         assert(record_decl);
         uint32_t child_idx = 0;
 
         const clang::CXXRecordDecl *cxx_record_decl =
             llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
 
         // 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) {
           llvm::StringRef field_name = field->getName();
           if (field_name.empty()) {
             CompilerType field_type = GetType(field->getType());
             child_indexes.push_back(child_idx);
             if (field_type.GetIndexOfChildMemberWithName(
                     name, omit_empty_base_classes, child_indexes))
               return child_indexes.size();
             child_indexes.pop_back();
 
-          } else if (field_name.equals(name_sref)) {
+          } else if (field_name.equals(name)) {
             // We have to add on the number of base classes to this index!
             child_indexes.push_back(
                 child_idx + TypeSystemClang::GetNumBaseClasses(
                                 cxx_record_decl, omit_empty_base_classes));
             return child_indexes.size();
           }
         }
 
         if (cxx_record_decl) {
           const clang::RecordDecl *parent_record_decl = cxx_record_decl;
 
           // Didn't find things easily, lets let clang do its thang...
-          clang::IdentifierInfo &ident_ref =
-              getASTContext().Idents.get(name_sref);
+          clang::IdentifierInfo &ident_ref = getASTContext().Idents.get(name);
           clang::DeclarationName decl_name(&ident_ref);
 
           clang::CXXBasePaths paths;
           if (cxx_record_decl->lookupInBases(
                   [decl_name](const clang::CXXBaseSpecifier *specifier,
                               clang::CXXBasePath &path) {
                     CXXRecordDecl *record =
                       specifier->getType()->getAsCXXRecordDecl();

lldb/source/Symbol/CompilerType.cpp

 // class C The second index 1 is the child index for "m_b" within class A
 //
 // With omit_empty_base_classes == true we would get an integer array back
 // with: { 0,  1 } The first index 0 is the child index for "class A" within
 // class C (since class B doesn't have any members it doesn't count) The second
 // index 1 is the child index for "m_b" within class A
 
 size_t CompilerType::GetIndexOfChildMemberWithName(
-    const char *name, bool omit_empty_base_classes,
+    llvm::StringRef name, bool omit_empty_base_classes,
     std::vector<uint32_t> &child_indexes) const {
-  if (IsValid() && name && name[0]) {
+  if (IsValid() && !name.empty()) {
     if (auto type_system_sp = GetTypeSystem())
       return type_system_sp->GetIndexOfChildMemberWithName(
         m_type, name, omit_empty_base_classes, child_indexes);
   }
   return 0;
 }
 
 size_t CompilerType::GetNumTemplateArguments(bool expand_pack) const {