[lldb][NFCI] TypeSystemClang::CreateStructForIdentifier should take a StringRef

[bulbazord]

Summary

This doesn't really use fast comparison or string uniqueness. In fact,
all of the current callers pass an empty string for type_name. The only
reason I don't remove it is because it looks like it is used downstream
for swift.

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

BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     const CompilerType flags_type =
         clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
     const char *const reserved_name("__reserved");
     const CompilerType reserved_type =
         clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
     const char *const FuncPtr_name("__FuncPtr");
 
     m_block_struct_type = clang_ast_context->CreateStructForIdentifier(
-        ConstString(), {{isa_name, isa_type},
+        llvm::StringRef(), {{isa_name, isa_type},
                             {flags_name, flags_type},
                             {reserved_name, reserved_type},
                             {FuncPtr_name, function_pointer_type}});
   }
 
   ~BlockPointerSyntheticFrontEnd() override = default;
 
   size_t CalculateNumChildren() override {
     const bool omit_empty_base_classes = false;
     return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr);
   }

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

if (m_pair_ptr) {
         //        | pointer __right_;           |
         //        | __parent_pointer __parent_; |
         //        | bool __is_black_;           |
         //        +-----------------------------+ class __tree_node
         //        | __node_value_type __value_; | <<< our key/value pair
         //        +-----------------------------+
         //
         CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(
-            ConstString(),
+            llvm::StringRef(),
             {{"ptr0",
               ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
              {"ptr1",
               ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
              {"ptr2",
               ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
              {"cw", ast_ctx->GetBasicType(lldb::eBasicTypeBool)},
              {"payload", pair_type}});
if (m_iter_ptr) {
     //         +-----------------------------+ class __hash_node_base
     // __node_ | __next_pointer __next_;     |
     //         +-----------------------------+ class __hash_node
     //         | size_t __hash_;             |
     //         | __node_value_type __value_; | <<< our key/value pair
     //         +-----------------------------+
     //
     CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(
-        ConstString(),
+        llvm::StringRef(),
         {{"__next_",
           ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"__hash_", ast_ctx->GetBasicType(lldb::eBasicTypeUnsignedLongLong)},
          {"__value_", pair_type}});
     std::optional<uint64_t> size = tree_node_type.GetByteSize(nullptr);
     if (!size)
       return false;
     WritableDataBufferSP buffer_sp(new DataBufferHeap(*size, 0));

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

void lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset(
   if (node_type.GetIndexOfFieldWithName("__value_", nullptr, &bit_offset) !=
       UINT32_MAX) {
     m_skip_size = bit_offset / 8u;
   } else {
     auto ast_ctx = node_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>();
     if (!ast_ctx)
       return;
     CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(
-        ConstString(),
+        llvm::StringRef(),
         {{"ptr0", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"ptr1", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"ptr2", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"cw", ast_ctx->GetBasicType(lldb::eBasicTypeBool)},
          {"payload", (m_element_type.GetCompleteType(), m_element_type)}});
     std::string child_name;
     uint32_t child_byte_size;
     int32_t child_byte_offset = 0;

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

CompilerType PlatformFreeBSD::GetSiginfoType(const llvm::Triple &triple) {
   // union used to hold the signal data
   CompilerType union_type = ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
       clang::TTK_Union, lldb::eLanguageTypeC);
   ast->StartTagDeclarationDefinition(union_type);
 
   ast->AddFieldToRecordType(
       union_type, "_fault",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_trapno", int_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_timer",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_timerid", int_type},
                                          {"_overrun", int_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_mesgq",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_mqd", int_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_poll",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_band", long_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(union_type);
   ast->AddFieldToRecordType(siginfo_type, "_reason", union_type,
                             lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(siginfo_type);
   return siginfo_type;
 }

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

CompilerType PlatformLinux::GetSiginfoType(const llvm::Triple &triple) {
   ast->AddFieldToRecordType(sigval_type, "sival_ptr", voidp_type,
                             lldb::eAccessPublic, 0);
   ast->CompleteTagDeclarationDefinition(sigval_type);
 
   CompilerType sigfault_bounds_type = ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
       clang::TTK_Union, lldb::eLanguageTypeC);
   ast->StartTagDeclarationDefinition(sigfault_bounds_type);
-  ast->AddFieldToRecordType(sigfault_bounds_type, "_addr_bnd",
-      ast->CreateStructForIdentifier(ConstString(),
+  ast->AddFieldToRecordType(
+      sigfault_bounds_type, "_addr_bnd",
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_lower", voidp_type},
                                          {"_upper", voidp_type},
                                      }),
-                            lldb::eAccessPublic, 0);
   ast->AddFieldToRecordType(sigfault_bounds_type, "_pkey", uint_type,
                             lldb::eAccessPublic, 0);
   ast->CompleteTagDeclarationDefinition(sigfault_bounds_type);
 
   // siginfo_t
   CompilerType siginfo_type = ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "__lldb_siginfo_t",
       clang::TTK_Struct, lldb::eLanguageTypeC);
CompilerType PlatformLinux::GetSiginfoType(const llvm::Triple &triple) {
   // union used to hold the signal data
   CompilerType union_type = ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
       clang::TTK_Union, lldb::eLanguageTypeC);
   ast->StartTagDeclarationDefinition(union_type);
 
   ast->AddFieldToRecordType(
       union_type, "_kill",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"si_pid", pid_type},
                                          {"si_uid", uid_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_timer",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"si_tid", int_type},
                                          {"si_overrun", int_type},
                                          {"si_sigval", sigval_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_rt",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"si_pid", pid_type},
                                          {"si_uid", uid_type},
                                          {"si_sigval", sigval_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_sigchld",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"si_pid", pid_type},
                                          {"si_uid", uid_type},
                                          {"si_status", int_type},
                                          {"si_utime", clock_type},
                                          {"si_stime", clock_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_sigfault",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"si_addr", voidp_type},
                                          {"si_addr_lsb", short_type},
                                          {"_bounds", sigfault_bounds_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_sigpoll",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"si_band", band_type},
                                          {"si_fd", int_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   // NB: SIGSYS is not present on ia64 but we don't seem to support that
   ast->AddFieldToRecordType(
       union_type, "_sigsys",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_call_addr", voidp_type},
                                          {"_syscall", int_type},
                                          {"_arch", uint_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(union_type);
   ast->AddFieldToRecordType(siginfo_type, "_sifields", union_type,
                             lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(siginfo_type);
   return siginfo_type;
 }

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

CompilerType PlatformNetBSD::GetSiginfoType(const llvm::Triple &triple) {
   // union used to hold the signal data
   CompilerType union_type = ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
       clang::TTK_Union, lldb::eLanguageTypeC);
   ast->StartTagDeclarationDefinition(union_type);
 
   ast->AddFieldToRecordType(
       union_type, "_rt",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_pid", pid_type},
                                          {"_uid", uid_type},
                                          {"_value", sigval_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_child",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_pid", pid_type},
                                          {"_uid", uid_type},
                                          {"_status", int_type},
                                          {"_utime", clock_type},
                                          {"_stime", clock_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_fault",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_addr", voidp_type},
                                          {"_trap", int_type},
                                          {"_trap2", int_type},
                                          {"_trap3", int_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_poll",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_band", long_type},
                                          {"_fd", int_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(union_type, "_syscall",
                             ast->CreateStructForIdentifier(
-                                ConstString(),
+                                llvm::StringRef(),
                                 {
                                     {"_sysnum", int_type},
                                     {"_retval", int_type.GetArrayType(2)},
                                     {"_error", int_type},
                                     {"_args", long_long_type.GetArrayType(8)},
                                 }),
                             lldb::eAccessPublic, 0);
 
   ast->AddFieldToRecordType(
       union_type, "_ptrace_state",
-      ast->CreateStructForIdentifier(ConstString(),
+      ast->CreateStructForIdentifier(llvm::StringRef(),
                                      {
                                          {"_pe_report_event", int_type},
                                          {"_option", ptrace_option_type},
                                      }),
       lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(union_type);
   ast->AddFieldToRecordType(ksiginfo_type, "_reason", union_type,

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

if (const RecordDeclType *record_decl =
       compiler_type = CompilerType(
           weak_from_this(),
           clang::QualType(record_decl->getTypeForDecl(), 0).getAsOpaquePtr());
 
     return compiler_type;
   }
 
   CompilerType CreateStructForIdentifier(
-      ConstString type_name,
+      llvm::StringRef type_name,
       const std::initializer_list<std::pair<const char *, CompilerType>>
           &type_fields,
       bool packed = false);
 
   CompilerType GetOrCreateStructForIdentifier(
-      ConstString type_name,
+      llvm::StringRef type_name,
       const std::initializer_list<std::pair<const char *, CompilerType>>
           &type_fields,
       bool packed = false);
 
   static bool IsOperator(llvm::StringRef name,
                          clang::OverloadedOperatorKind &op_kind);
 
   // Structure, Unions, Classes

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

if (is_vector) {
             clang::ArrayType::Normal, 0));
       }
     }
   }
   return CompilerType();
 }
 
 CompilerType TypeSystemClang::CreateStructForIdentifier(
-    ConstString type_name,
+    llvm::StringRef type_name,
     const std::initializer_list<std::pair<const char *, CompilerType>>
         &type_fields,
     bool packed) {
   CompilerType type;
-  if (!type_name.IsEmpty() &&
+  if (!type_name.empty() &&
       (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
           .IsValid()) {
     lldbassert(0 && "Trying to create a type for an existing name");
     return type;
   }
 
   type = CreateRecordType(nullptr, OptionalClangModuleID(), lldb::eAccessPublic,
-                          type_name.GetCString(), clang::TTK_Struct,
-                          lldb::eLanguageTypeC);
+                          type_name, clang::TTK_Struct, lldb::eLanguageTypeC);
   StartTagDeclarationDefinition(type);
   for (const auto &field : type_fields)
     AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic,
                          0);
   if (packed)
     SetIsPacked(type);
   CompleteTagDeclarationDefinition(type);
   return type;
 }
 
 CompilerType TypeSystemClang::GetOrCreateStructForIdentifier(
-    ConstString type_name,
+    llvm::StringRef type_name,
     const std::initializer_list<std::pair<const char *, CompilerType>>
         &type_fields,
     bool packed) {
   CompilerType type;
   if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
     return type;
 
   return CreateStructForIdentifier(type_name, type_fields, packed);