[lldb][NFC] Use StringRef in TypeSystem API (TypeSystem, CompilerType, TypeSystemClang)

[teemperor]

Summary

This replaces the C strings in the TypeSystem API with StringRefs. Also removes all the
StringRef locals that were previously used in the implementation as they are no longer necessary.

[augusto2112]

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

8235

Was this check unnecessary?

[teemperor]

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

8235

I probably should have commented on this. At the start of the function we already do the same check:

if (!enum_type || ConstString(name).IsEmpty())
  return nullptr;

Still, thanks for the careful review :)

[augusto2112]

LGTM!

[teemperor]

(I'm going to land this when I prepared the respective Swift patches)

lldb/include/lldb/Expression/FunctionCaller.h

 //===-- FunctionCaller.h ----------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_EXPRESSION_FUNCTIONCALLER_H
 #define LLDB_EXPRESSION_FUNCTIONCALLER_H
 
 #include <list>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Expression/ExpressionParser.h"
 #include "lldb/Symbol/CompilerType.h"
 
 namespace lldb_private {
 
 /// \class FunctionCaller FunctionCaller.h "lldb/Expression/FunctionCaller.h"
public:
   ///     The address of the function to call.
   ///
   /// \param[in] arg_value_list
   ///     The default values to use when calling this function.  Can
   ///     be overridden using WriteFunctionArguments().
   FunctionCaller(ExecutionContextScope &exe_scope,
                  const CompilerType &return_type,
                  const Address &function_address,
-                 const ValueList &arg_value_list, const char *name);
+                 const ValueList &arg_value_list, llvm::StringRef name);
 
   /// Destructor
   ~FunctionCaller() override;
 
   /// Compile the wrapper function
   ///
   /// \param[in] thread_to_use_sp
   ///     Compilation might end up calling functions.  Pass in the thread you

lldb/include/lldb/Symbol/CompilerType.h

 //===-- CompilerType.h ------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_COMPILERTYPE_H
 #define LLDB_SYMBOL_COMPILERTYPE_H
 
 #include <functional>
 #include <string>
 #include <vector>
 
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/APSInt.h"
 
 namespace lldb_private {
 
 class DataExtractor;
 
 /// Generic representation of a type in a programming language.
 ///
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.
   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;
 
   size_t GetNumTemplateArguments() const;
 
   lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx) const;
   CompilerType GetTypeTemplateArgument(size_t idx) const;
 
   /// Returns the value of the template argument and its type.

lldb/include/lldb/Symbol/TypeSystem.h

 #include <string>
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-private.h"
 
 class DWARFDIE;
 class DWARFASTParser;
 class PDBASTParser;
#endif
 
   virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type);
 
   virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type);
 
   /// \param opaque_payload      The m_payload field of Type, which may
   /// carry TypeSystem-specific extra information.
   virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
-                                     const char *name,
+                                     llvm::StringRef name,
                                      const CompilerDeclContext &decl_ctx,
                                      uint32_t opaque_payload);
 
   // Exploring the type
 
   virtual const llvm::fltSemantics &GetFloatTypeSemantics(size_t byte_size) = 0;
 
   virtual llvm::Optional<uint64_t>
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.
-  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 size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type);
 
   virtual lldb::TemplateArgumentKind
   GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx);
   virtual CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
                                            size_t idx);
   virtual llvm::Optional<CompilerType::IntegralTemplateArgument>
GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     const EvaluateExpressionOptions &options,
                     ValueObject *ctx_obj) {
     return nullptr;
   }
 
   virtual FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
                                             const Address &function_address,
                                             const ValueList &arg_value_list,
-                                            const char *name) {
+                                            llvm::StringRef name) {
     return nullptr;
   }
 
   virtual std::unique_ptr<UtilityFunction>
   CreateUtilityFunction(std::string text, std::string name);
 
   virtual PersistentExpressionState *GetPersistentExpressionState() {
     return nullptr;

lldb/source/Expression/FunctionCaller.cpp

 //===-- FunctionCaller.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/Expression/FunctionCaller.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Type.h"

 
 char FunctionCaller::ID;
 
 // FunctionCaller constructor
 FunctionCaller::FunctionCaller(ExecutionContextScope &exe_scope,
                                const CompilerType &return_type,
                                const Address &functionAddress,
                                const ValueList &arg_value_list,
-                               const char *name)
+                               llvm::StringRef name)
     : Expression(exe_scope), m_execution_unit_sp(), m_parser(),
-      m_jit_module_wp(), m_name(name ? name : "<unknown>"),
+      m_jit_module_wp(), m_name(name.empty() ? "<unknown>" : name),
       m_function_ptr(nullptr), m_function_addr(functionAddress),
       m_function_return_type(return_type),
       m_wrapper_function_name("__lldb_caller_function"),
       m_wrapper_struct_name("__lldb_caller_struct"), m_wrapper_args_addrs(),
       m_struct_valid(false), m_arg_values(arg_value_list), m_compiled(false),
       m_JITted(false) {
   m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
   // Can't make a FunctionCaller without a process.

lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h

public:
   ///     The address of the function to call.
   ///
   /// \param[in] arg_value_list
   ///     The default values to use when calling this function.  Can
   ///     be overridden using WriteFunctionArguments().
   ClangFunctionCaller(ExecutionContextScope &exe_scope,
                       const CompilerType &return_type,
                       const Address &function_address,
-                      const ValueList &arg_value_list, const char *name);
+                      const ValueList &arg_value_list, llvm::StringRef name);
 
   ~ClangFunctionCaller() override;
 
   /// Compile the wrapper function
   ///
   /// \param[in] thread_to_use_sp
   ///     Compilation might end up calling functions.  Pass in the thread you
   ///     want the compilation to use.  If you pass in an empty ThreadSP it will

lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp

 
 char ClangFunctionCaller::ID;
 
 // ClangFunctionCaller constructor
 ClangFunctionCaller::ClangFunctionCaller(ExecutionContextScope &exe_scope,
                                          const CompilerType &return_type,
                                          const Address &functionAddress,
                                          const ValueList &arg_value_list,
-                                         const char *name)
+                                         llvm::StringRef name)
     : FunctionCaller(exe_scope, return_type, functionAddress, arg_value_list,
                      name),
       m_type_system_helper(*this) {
   m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
   // Can't make a ClangFunctionCaller without a process.
   assert(m_jit_process_wp.lock());
 }
 

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

if (std::unique_ptr<PDBSymbolTypeFunctionSig> sig = func->getSignature()) {
               arg_enum = sig->findAllChildren<PDBSymbolTypeFunctionArg>()) {
         while (std::unique_ptr<PDBSymbolTypeFunctionArg> arg =
                    arg_enum->getNext()) {
           Type *arg_type = symbol_file->ResolveTypeUID(arg->getTypeId());
           if (!arg_type)
             continue;
 
           clang::ParmVarDecl *param = m_ast.CreateParameterDeclaration(
-              decl, OptionalClangModuleID(), nullptr,
+              decl, OptionalClangModuleID(), /*name=*/llvm::StringRef(),
               arg_type->GetForwardCompilerType(), clang::SC_None, true);
           if (param)
             params.push_back(param);
         }
       }
     }
     if (params.size())
       m_ast.SetFunctionParameters(decl, params.data(), params.size());

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

 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTFwd.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
public:
 
   CompilerType CreateFunctionType(const CompilerType &result_type,
                                   const CompilerType *args, unsigned num_args,
                                   bool is_variadic, unsigned type_quals) {
     return CreateFunctionType(result_type, args, num_args, is_variadic,
                               type_quals, clang::CC_C);
   }
 
-  clang::ParmVarDecl *
-  CreateParameterDeclaration(clang::DeclContext *decl_ctx,
-                             OptionalClangModuleID owning_module,
-                             const char *name, const CompilerType &param_type,
-                             int storage, bool add_decl = false);
+  clang::ParmVarDecl *CreateParameterDeclaration(
+      clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
+      llvm::StringRef name, const CompilerType &param_type, int storage,
+      bool add_decl = false);
 
   void SetFunctionParameters(clang::FunctionDecl *function_decl,
                              clang::ParmVarDecl **params, unsigned num_params);
 
   CompilerType CreateBlockPointerType(const CompilerType &function_type);
 
   // Array Types
 
   CompilerType CreateArrayType(const CompilerType &element_type,
                                size_t element_count, bool is_vector);
 
   // Enumeration Types
-  CompilerType CreateEnumerationType(const char *name,
+  CompilerType CreateEnumerationType(llvm::StringRef name,
                                      clang::DeclContext *decl_ctx,
                                      OptionalClangModuleID owning_module,
                                      const Declaration &decl,
                                      const CompilerType &integer_qual_type,
                                      bool is_scoped);
 
   // Integer type functions
 
#endif
   CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type) override;
 
   CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type) override;
 
   /// Using the current type, create a new typedef to that type using
   /// "typedef_name" as the name and "decl_ctx" as the decl context.
   /// \param opaque_payload is an opaque TypePayloadClang.
   CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
-                             const char *name,
+                             llvm::StringRef name,
                              const CompilerDeclContext &decl_ctx,
                              uint32_t opaque_payload) override;
 
   // If the current object represents a typedef type, get the underlying type
   CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
 
   // Create related types using the current type's AST
   CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
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.
   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;
 
   size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override;
 
   lldb::TemplateArgumentKind
   GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
                           size_t idx) override;
   CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
 
   // Tag Declarations
   static bool StartTagDeclarationDefinition(const CompilerType &type);
 
   static bool CompleteTagDeclarationDefinition(const CompilerType &type);
 
   // Modifying Enumeration types
   clang::EnumConstantDecl *AddEnumerationValueToEnumerationType(
-      const CompilerType &enum_type, const Declaration &decl, const char *name,
-      int64_t enum_value, uint32_t enum_value_bit_size);
+      const CompilerType &enum_type, const Declaration &decl,
+      llvm::StringRef name, int64_t enum_value, uint32_t enum_value_bit_size);
   clang::EnumConstantDecl *AddEnumerationValueToEnumerationType(
-      const CompilerType &enum_type, const Declaration &decl, const char *name,
-      const llvm::APSInt &value);
+      const CompilerType &enum_type, const Declaration &decl,
+      llvm::StringRef name, const llvm::APSInt &value);
 
   /// Returns the underlying integer type for an enum type. If the given type
   /// is invalid or not an enum-type, the function returns an invalid
   /// CompilerType.
   CompilerType GetEnumerationIntegerType(CompilerType type);
 
   // Pointers & References
 
CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx,
                                   clang::NamespaceDecl *ns_decl);
 
   clang::UsingDecl *CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
                                            OptionalClangModuleID owning_module,
                                            clang::NamedDecl *target);
 
   clang::VarDecl *CreateVariableDeclaration(clang::DeclContext *decl_context,
                                             OptionalClangModuleID owning_module,
-                                            const char *name,
+                                            llvm::StringRef name,
                                             clang::QualType type);
 
   static lldb::opaque_compiler_type_t
   GetOpaqueCompilerType(clang::ASTContext *ast, lldb::BasicType basic_type);
 
   static clang::QualType GetQualType(lldb::opaque_compiler_type_t type) {
     if (type)
       return clang::QualType::getFromOpaquePtr(type);
GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     lldb::LanguageType language,
                     Expression::ResultType desired_type,
                     const EvaluateExpressionOptions &options,
                     ValueObject *ctx_obj) override;
 
   FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
                                     const Address &function_address,
                                     const ValueList &arg_value_list,
-                                    const char *name) override;
+                                    llvm::StringRef name) override;
 
   std::unique_ptr<UtilityFunction>
   CreateUtilityFunction(std::string text, std::string name) override;
 
   PersistentExpressionState *GetPersistentExpressionState() override;
 
   /// Unregisters the given ASTContext as a source from the scratch AST (and
   /// all sub-ASTs).

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

if (current_decl_ctx && target) {
     current_decl_ctx->addDecl(using_decl);
     return using_decl;
   }
   return nullptr;
 }
 
 clang::VarDecl *TypeSystemClang::CreateVariableDeclaration(
     clang::DeclContext *decl_context, OptionalClangModuleID owning_module,
-    const char *name, clang::QualType type) {
+    llvm::StringRef name, clang::QualType type) {
   if (decl_context) {
     clang::VarDecl *var_decl =
         clang::VarDecl::CreateDeserialized(getASTContext(), 0);
     var_decl->setDeclContext(decl_context);
-    if (name && name[0])
+    if (!name.empty())
       var_decl->setDeclName(&getASTContext().Idents.getOwn(name));
     var_decl->setType(type);
     SetOwningModule(var_decl, owning_module);
     var_decl->setAccess(clang::AS_public);
     decl_context->addDecl(var_decl);
     return var_decl;
   }
   return nullptr;
TypeSystemClang::CreateFunctionType(const CompilerType &result_type,
   proto_info.RefQualifier = RQ_None;
 
   return GetType(getASTContext().getFunctionType(
       ClangUtil::GetQualType(result_type), qual_type_args, proto_info));
 }
 
 ParmVarDecl *TypeSystemClang::CreateParameterDeclaration(
     clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
-    const char *name, const CompilerType &param_type, int storage,
+    llvm::StringRef name, const CompilerType &param_type, int storage,
     bool add_decl) {
   ASTContext &ast = getASTContext();
   auto *decl = ParmVarDecl::CreateDeserialized(ast, 0);
   decl->setDeclContext(decl_ctx);
-  if (name && name[0])
+  if (!name.empty())
     decl->setDeclName(&ast.Idents.get(name));
   decl->setType(ClangUtil::GetQualType(param_type));
   decl->setStorageClass(static_cast<clang::StorageClass>(storage));
   SetOwningModule(decl, owning_module);
   if (add_decl)
     decl_ctx->addDecl(decl);
 
   return decl;
if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
     return type;
 
   return CreateStructForIdentifier(type_name, type_fields, packed);
 }
 
 #pragma mark Enumeration Types
 
 CompilerType TypeSystemClang::CreateEnumerationType(
-    const char *name, clang::DeclContext *decl_ctx,
+    llvm::StringRef name, clang::DeclContext *decl_ctx,
     OptionalClangModuleID owning_module, const Declaration &decl,
     const CompilerType &integer_clang_type, bool is_scoped) {
   // TODO: Do something intelligent with the Declaration object passed in
   // like maybe filling in the SourceLocation with it...
   ASTContext &ast = getASTContext();
 
   // TODO: ask about these...
   //    const bool IsFixed = false;
   EnumDecl *enum_decl = EnumDecl::CreateDeserialized(ast, 0);
   enum_decl->setDeclContext(decl_ctx);
-  if (name && name[0])
+  if (!name.empty())
     enum_decl->setDeclName(&ast.Idents.get(name));
   enum_decl->setScoped(is_scoped);
   enum_decl->setScopedUsingClassTag(is_scoped);
   enum_decl->setFixed(false);
   SetOwningModule(enum_decl, owning_module);
   if (enum_decl) {
     if (decl_ctx)
       decl_ctx->addDecl(enum_decl);
if (type) {
     clang::QualType result(GetQualType(type));
     result.addRestrict();
     return GetType(result);
   }
   return CompilerType();
 }
 
 CompilerType TypeSystemClang::CreateTypedef(
-    lldb::opaque_compiler_type_t type, const char *typedef_name,
+    lldb::opaque_compiler_type_t type, llvm::StringRef typedef_name,
     const CompilerDeclContext &compiler_decl_ctx, uint32_t payload) {
-  if (type && typedef_name && typedef_name[0]) {
+  if (type && !typedef_name.empty()) {
     clang::ASTContext &clang_ast = getASTContext();
     clang::QualType qual_type(GetQualType(type));
 
     clang::DeclContext *decl_ctx =
         TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
     if (!decl_ctx)
       decl_ctx = getASTContext().getTranslationUnitDecl();
 

 // 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();
case clang::Type::Record:
           }
         }
       }
       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;
 
                 child_indexes.push_back(child_idx);
                 return child_indexes.size();
               }

 }
 
 // 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:
             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: {
if (!integer_type.isNull()) {
     enum_decl->completeDefinition(enum_decl->getIntegerType(),
                                   promotion_qual_type, NumPositiveBits,
                                   NumNegativeBits);
   }
   return true;
 }
 
 clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
-    const CompilerType &enum_type, const Declaration &decl, const char *name,
-    const llvm::APSInt &value) {
+    const CompilerType &enum_type, const Declaration &decl,
+    llvm::StringRef name, const llvm::APSInt &value) {
 
-  if (!enum_type || ConstString(name).IsEmpty())
+  if (!enum_type || name.empty())
     return nullptr;
 
   lldbassert(enum_type.GetTypeSystem() == static_cast<TypeSystem *>(this));
 
   lldb::opaque_compiler_type_t enum_opaque_compiler_type =
       enum_type.GetOpaqueQualType();
 
   if (!enum_opaque_compiler_type)
clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
   const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type);
 
   if (!enutype)
     return nullptr;
 
   clang::EnumConstantDecl *enumerator_decl =
       clang::EnumConstantDecl::CreateDeserialized(getASTContext(), 0);
   enumerator_decl->setDeclContext(enutype->getDecl());
-  if (name && name[0])
-    enumerator_decl->setDeclName(&getASTContext().Idents.get(name));
   enumerator_decl->setType(clang::QualType(enutype, 0));
   enumerator_decl->setInitVal(value);
   SetMemberOwningModule(enumerator_decl, enutype->getDecl());
 
   if (!enumerator_decl)
     return nullptr;
 
   enutype->getDecl()->addDecl(enumerator_decl);
 
   VerifyDecl(enumerator_decl);
   return enumerator_decl;
 }
 
 clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
-    const CompilerType &enum_type, const Declaration &decl, const char *name,
-    int64_t enum_value, uint32_t enum_value_bit_size) {
+    const CompilerType &enum_type, const Declaration &decl,
+    llvm::StringRef name, int64_t enum_value, uint32_t enum_value_bit_size) {
   CompilerType underlying_type = GetEnumerationIntegerType(enum_type);
   bool is_signed = false;
   underlying_type.IsIntegerType(is_signed);
 
   llvm::APSInt value(enum_value_bit_size, is_signed);
   value = enum_value;
 
   return AddEnumerationValueToEnumerationType(enum_type, decl, name, value);
if (!target_sp)
     return nullptr;
 
   return new ClangUserExpression(*target_sp.get(), expr, prefix, language,
                                  desired_type, options, ctx_obj);
 }
 
 FunctionCaller *ScratchTypeSystemClang::GetFunctionCaller(
     const CompilerType &return_type, const Address &function_address,
-    const ValueList &arg_value_list, const char *name) {
+    const ValueList &arg_value_list, llvm::StringRef name) {
   TargetSP target_sp = m_target_wp.lock();
   if (!target_sp)
     return nullptr;
 
   Process *process = target_sp->GetProcessSP().get();
   if (!process)
     return nullptr;
 

lldb/source/Symbol/CompilerType.cpp

 //===-- CompilerType.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/Symbol/CompilerType.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBufferHeap.h"

 // 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()) {
     return m_type_system->GetIndexOfChildMemberWithName(
         m_type, name, omit_empty_base_classes, child_indexes);
   }
   return 0;
 }
 
 size_t CompilerType::GetNumTemplateArguments() const {
   if (IsValid()) {
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()) {
     return m_type_system->GetIndexOfChildWithName(m_type, name,
                                                   omit_empty_base_classes);
   }
   return UINT32_MAX;
 }
 
 // Dumping types
 

lldb/source/Symbol/TypeSystem.cpp

 //===-- TypeSystem.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/Symbol/TypeSystem.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Language.h"
 
 #include <set>
 
 using namespace lldb_private;

 }
 
 CompilerType
 TypeSystem::AddRestrictModifier(lldb::opaque_compiler_type_t type) {
   return CompilerType();
 }
 
 CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type,
-                                       const char *name,
+                                       llvm::StringRef name,
                                        const CompilerDeclContext &decl_ctx,
                                        uint32_t opaque_payload) {
   return CompilerType();
 }
 
 CompilerType TypeSystem::GetBuiltinTypeByName(ConstString name) {
   return CompilerType();
 }