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

[bulbazord]

Summary

This method just takes its ConstString parameter and gets a StringRef
out of it. Let's just pass in a StringRef directly.

This also cleans up some logic in the callers to be a little easier to
read and to avoid unnecessary ConstString creation.

[aprantl]

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

76

why not directly pass in "__lldb_autogen_nspair" here?

[bulbazord]

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

76

It's used below as well, I didn't trust myself to be able to type it correctly twice in a row. :)
It's also nice that we can constexpr the llvm::StringRef and avoid computing the length at runtime, but that's a minor thing.

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

 NSDictionary_Additionals::GetAdditionalSynthetics() {
   static AdditionalFormatters<CXXSyntheticChildren::CreateFrontEndCallback>
       g_map;
   return g_map;
 }
 
 static CompilerType GetLLDBNSPairType(TargetSP target_sp) {
   CompilerType compiler_type;
-
   TypeSystemClangSP scratch_ts_sp =
       ScratchTypeSystemClang::GetForTarget(*target_sp);
 
-  if (scratch_ts_sp) {
-    ConstString g_lldb_autogen_nspair("__lldb_autogen_nspair");
+  if (!scratch_ts_sp)
+    return compiler_type;
+
+  static constexpr llvm::StringLiteral g_lldb_autogen_nspair("__lldb_autogen_nspair");
 
-    compiler_type = scratch_ts_sp->GetTypeForIdentifier<clang::CXXRecordDecl>(
-        g_lldb_autogen_nspair);
+  compiler_type = scratch_ts_sp->GetTypeForIdentifier<clang::CXXRecordDecl>(g_lldb_autogen_nspair);
 
-    if (!compiler_type) {
-      compiler_type = scratch_ts_sp->CreateRecordType(
-          nullptr, OptionalClangModuleID(), lldb::eAccessPublic,
-          g_lldb_autogen_nspair.GetCString(), clang::TTK_Struct,
-          lldb::eLanguageTypeC);
+        g_lldb_autogen_nspair, clang::TTK_Struct, lldb::eLanguageTypeC);
 
-      if (compiler_type) {
-        TypeSystemClang::StartTagDeclarationDefinition(compiler_type);
-        CompilerType id_compiler_type =
-            scratch_ts_sp->GetBasicType(eBasicTypeObjCID);
-        TypeSystemClang::AddFieldToRecordType(
-            compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0);
-        TypeSystemClang::AddFieldToRecordType(
-            compiler_type, "value", id_compiler_type, lldb::eAccessPublic, 0);
-        TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type);
-      }
-    }
-  }
   return compiler_type;
 }
 
 namespace lldb_private {
 namespace formatters {
 class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSDictionaryISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

lldb/source/Plugins/RegisterTypeBuilder/RegisterTypeBuilderClang.cpp

lldb::TypeSystemClangSP type_system =
       ScratchTypeSystemClang::GetForTarget(m_target);
   assert(type_system);
 
   std::string register_type_name = "__lldb_register_fields_";
   register_type_name += name;
   // See if we have made this type before and can reuse it.
   CompilerType fields_type =
       type_system->GetTypeForIdentifier<clang::CXXRecordDecl>(
-          ConstString(register_type_name.c_str()));
+          register_type_name);
 
   if (!fields_type) {
     // In most ABI, a change of field type means a change in storage unit.
     // We want it all in one unit, so we use a field type the same as the
     // register's size.
     CompilerType field_uint_type =
         type_system->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,
                                                          byte_size * 8);

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

case PDB_SymType::UDT: {
 
     auto decl_context = GetDeclContextContainingSymbol(type);
 
     // Check if such an UDT already exists in the current context.
     // This may occur with const or volatile types. There are separate type
     // symbols in PDB for types with const or volatile modifiers, but we need
     // to create only one declaration for them all.
     Type::ResolveState type_resolve_state;
-    CompilerType clang_type = m_ast.GetTypeForIdentifier<clang::CXXRecordDecl>(
-        ConstString(name), decl_context);
+    CompilerType clang_type =
+        m_ast.GetTypeForIdentifier<clang::CXXRecordDecl>(name, decl_context);
     if (!clang_type.IsValid()) {
       auto access = GetAccessibilityForUdt(*udt);
 
       auto tag_type_kind = TranslateUdtKind(udt->getUdtKind());
 
       ClangASTMetadata metadata;
       metadata.SetUserID(type.getSymIndexId());
       metadata.SetIsDynamicCXXType(false);
case PDB_SymType::Enum: {
     assert(enum_type);
 
     std::string name =
         std::string(MSVCUndecoratedNameParser::DropScope(enum_type->getName()));
     auto decl_context = GetDeclContextContainingSymbol(type);
     uint64_t bytes = enum_type->getLength();
 
     // Check if such an enum already exists in the current context
-    CompilerType ast_enum = m_ast.GetTypeForIdentifier<clang::EnumDecl>(
-        ConstString(name), decl_context);
+    CompilerType ast_enum =
+        m_ast.GetTypeForIdentifier<clang::EnumDecl>(name, decl_context);
     if (!ast_enum.IsValid()) {
       auto underlying_type_up = enum_type->getUnderlyingType();
       if (!underlying_type_up)
         return nullptr;
 
       lldb::Encoding encoding =
           TranslateBuiltinEncoding(underlying_type_up->getBuiltinType());
       // FIXME: Type of underlying builtin is always `Int`. We correct it with
if (!target_type)
       return nullptr;
 
     std::string name =
         std::string(MSVCUndecoratedNameParser::DropScope(type_def->getName()));
     auto decl_ctx = GetDeclContextContainingSymbol(type);
 
     // Check if such a typedef already exists in the current context
     CompilerType ast_typedef =
-        m_ast.GetTypeForIdentifier<clang::TypedefNameDecl>(ConstString(name),
-                                                           decl_ctx);
+        m_ast.GetTypeForIdentifier<clang::TypedefNameDecl>(name, decl_ctx);
     if (!ast_typedef.IsValid()) {
       CompilerType target_ast_type = target_type->GetFullCompilerType();
 
       ast_typedef = target_ast_type.CreateTypedef(
           name.c_str(), m_ast.CreateDeclContext(decl_ctx), 0);
       if (!ast_typedef)
         return nullptr;
 

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

public:
   CompilerType GetTypeForDecl(clang::NamedDecl *decl);
 
   CompilerType GetTypeForDecl(clang::TagDecl *decl);
 
   CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl);
 
   template <typename RecordDeclType>
   CompilerType
-  GetTypeForIdentifier(ConstString type_name,
+  GetTypeForIdentifier(llvm::StringRef type_name,
                        clang::DeclContext *decl_context = nullptr) {
     CompilerType compiler_type;
+    if (type_name.empty())
+      return compiler_type;
 
-    if (type_name.GetLength()) {
-      clang::ASTContext &ast = getASTContext();
-      if (!decl_context)
-        decl_context = ast.getTranslationUnitDecl();
 
-      clang::IdentifierInfo &myIdent = ast.Idents.get(type_name.GetCString());
-      clang::DeclarationName myName =
-          ast.DeclarationNames.getIdentifier(&myIdent);
-
-      clang::DeclContext::lookup_result result = decl_context->lookup(myName);
+    clang::IdentifierInfo &myIdent = ast.Idents.get(type_name);
+    if (result.empty())
+      return compiler_type;
 
-      if (!result.empty()) {
-        clang::NamedDecl *named_decl = *result.begin();
-        if (const RecordDeclType *record_decl =
-                llvm::dyn_cast<RecordDeclType>(named_decl))
-          compiler_type =
-              CompilerType(weak_from_this(),
-                           clang::QualType(record_decl->getTypeForDecl(), 0)
-                               .getAsOpaquePtr());
-      }
-    }
+      compiler_type = CompilerType(
+          weak_from_this(),
+          clang::QualType(record_decl->getTypeForDecl(), 0).getAsOpaquePtr());
 
     return compiler_type;
   }
 
   CompilerType CreateStructForIdentifier(
       ConstString type_name,
       const std::initializer_list<std::pair<const char *, CompilerType>>
           &type_fields,