[lldb][NFCI] Remove unneeded ConstString conversions

[bulbazord]

Summary

ConstString can be implicitly converted into a llvm::StringRef. This is
very useful in many places, but it also hides places where we are
creating a ConstString only to use it as a StringRef for the entire
lifespan of the ConstString object.

I locally removed the implicit conversion and found some of the places we
were doing this.

[JDevlieghere]

LGTM

lldb/include/lldb/Target/Platform.h

 
 class ModuleCache;
 enum MmapFlags { eMmapFlagsPrivate = 1, eMmapFlagsAnon = 2 };
 
 class PlatformProperties : public Properties {
 public:
   PlatformProperties();
 
-  static ConstString GetSettingName();
+  static llvm::StringRef GetSettingName();
 
   bool GetUseModuleCache() const;
   bool SetUseModuleCache(bool use_module_cache);
 
   FileSpec GetModuleCacheDirectory() const;
   bool SetModuleCacheDirectory(const FileSpec &dir_spec);
 
 private:

lldb/source/Core/ModuleList.cpp

 enum {
 #define LLDB_PROPERTIES_modulelist
 #include "CorePropertiesEnum.inc"
 };
 
 } // namespace
 
 ModuleListProperties::ModuleListProperties() {
-  m_collection_sp =
-      std::make_shared<OptionValueProperties>(ConstString("symbols"));
+  m_collection_sp = std::make_shared<OptionValueProperties>("symbols");
   m_collection_sp->Initialize(g_modulelist_properties);
   m_collection_sp->SetValueChangedCallback(ePropertySymLinkPaths,
                                            [this] { UpdateSymlinkMappings(); });
 
   llvm::SmallString<128> path;
   if (clang::driver::Driver::getDefaultModuleCachePath(path)) {
     lldbassert(SetClangModulesCachePath(FileSpec(path)));
   }

lldb/source/Core/ValueObjectSyntheticFilter.cpp

lldb::ValueObjectSP ValueObjectSynthetic::GetChildAtIndex(size_t idx,
   }
 }
 
 lldb::ValueObjectSP
 ValueObjectSynthetic::GetChildMemberWithName(llvm::StringRef name,
                                              bool can_create) {
   UpdateValueIfNeeded();
 
-  uint32_t index = GetIndexOfChildWithName(ConstString(name));
+  uint32_t index = GetIndexOfChildWithName(name);
 
   if (index == UINT32_MAX)
     return lldb::ValueObjectSP();
 
   return GetChildAtIndex(index, can_create);
 }
 
 size_t ValueObjectSynthetic::GetIndexOfChildWithName(llvm::StringRef name_ref) {

lldb/source/Interpreter/CommandInterpreter.cpp

ConstString &CommandInterpreter::GetStaticBroadcasterClass() {
   static ConstString class_name("lldb.commandInterpreter");
   return class_name;
 }
 
 CommandInterpreter::CommandInterpreter(Debugger &debugger,
                                        bool synchronous_execution)
     : Broadcaster(debugger.GetBroadcasterManager(),
                   CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
-      Properties(OptionValuePropertiesSP(
-          new OptionValueProperties(ConstString("interpreter")))),
+      Properties(
+          OptionValuePropertiesSP(new OptionValueProperties("interpreter"))),
       IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
       m_debugger(debugger), m_synchronous_execution(true),
       m_skip_lldbinit_files(false), m_skip_app_init_files(false),
       m_comment_char('#'), m_batch_command_mode(false),
       m_truncation_warning(eNoOmission), m_max_depth_warning(eNoOmission),
       m_command_source_depth(0) {
   SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
   SetEventName(eBroadcastBitResetPrompt, "reset-prompt");

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

 
 enum {
 #define LLDB_PROPERTIES_dynamicloaderdarwinkernel
 #include "DynamicLoaderDarwinKernelPropertiesEnum.inc"
 };
 
 class DynamicLoaderDarwinKernelProperties : public Properties {
 public:
-  static ConstString &GetSettingName() {
-    static ConstString g_setting_name("darwin-kernel");
+  static llvm::StringRef GetSettingName() {
+    static constexpr llvm::StringLiteral g_setting_name("darwin-kernel");
     return g_setting_name;
   }
 
   DynamicLoaderDarwinKernelProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_dynamicloaderdarwinkernel_properties);
   }
 

lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

 enum {
 #define LLDB_PROPERTIES_jitloadergdb
 #include "JITLoaderGDBPropertiesEnum.inc"
   ePropertyEnableJITBreakpoint
 };
 
 class PluginProperties : public Properties {
 public:
-  static ConstString GetSettingName() {
-    return ConstString(JITLoaderGDB::GetPluginNameStatic());
+  static llvm::StringRef GetSettingName() {
+    return JITLoaderGDB::GetPluginNameStatic();
   }
 
   PluginProperties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_jitloadergdb_properties);
   }
 
   EnableJITLoaderGDB GetEnable() const {

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

public:
   }
 
   bool MightHaveChildren() override { return true; }
   bool Update() override;
   size_t CalculateNumChildren() override { return m_elements.size(); }
   ValueObjectSP GetChildAtIndex(size_t idx) override;
 
 private:
-  ConstString GetDataContainerMemberName();
+  llvm::StringRef GetDataContainerMemberName();
 
   // The lifetime of a ValueObject and all its derivative ValueObjects
   // (children, clones, etc.) is managed by a ClusterManager. These
   // objects are only destroyed when every shared pointer to any of them
   // is destroyed, so we must not store a shared pointer to any ValueObject
   // derived from our backend ValueObject (since we're in the same cluster).
   // Value objects created from raw data (i.e. in a different cluster) must
   // be referenced via shared pointer to keep them alive, however.
GenericBitsetFrontEnd::GenericBitsetFrontEnd(ValueObject &valobj, StdLib stdlib)
   m_bool_type = valobj.GetCompilerType().GetBasicTypeFromAST(eBasicTypeBool);
   if (auto target_sp = m_backend.GetTargetSP()) {
     m_byte_order = target_sp->GetArchitecture().GetByteOrder();
     m_byte_size = target_sp->GetArchitecture().GetAddressByteSize();
     Update();
   }
 }
 
-ConstString GenericBitsetFrontEnd::GetDataContainerMemberName() {
+llvm::StringRef GenericBitsetFrontEnd::GetDataContainerMemberName() {
+  static constexpr llvm::StringLiteral s_libcxx_case("__first_");
+  static constexpr llvm::StringLiteral s_libstdcpp_case("_M_w");
   switch (m_stdlib) {
   case StdLib::LibCxx:
-    return ConstString("__first_");
+    return s_libcxx_case;
   case StdLib::LibStdcpp:
-    return ConstString("_M_w");
+    return s_libstdcpp_case;
   }
   llvm_unreachable("Unknown StdLib enum");
 }
 
 bool GenericBitsetFrontEnd::Update() {
   m_elements.clear();
   m_first = nullptr;
 

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 
 enum {
 #define LLDB_PROPERTIES_objectfilepecoff
 #include "ObjectFilePECOFFPropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
-  static ConstString GetSettingName() {
-    return ConstString(ObjectFilePECOFF::GetPluginNameStatic());
+  static llvm::StringRef GetSettingName() {
+    return ObjectFilePECOFF::GetPluginNameStatic();
   }
 
   PluginProperties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_objectfilepecoff_properties);
   }
 
   llvm::Triple::EnvironmentType ABI() const {

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

 #define LLDB_PROPERTIES_android
 #include "PlatformAndroidPropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
   PluginProperties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(
-        ConstString(PlatformAndroid::GetPluginNameStatic(false)));
+        PlatformAndroid::GetPluginNameStatic(false));
     m_collection_sp->Initialize(g_android_properties);
   }
 };
 
 static PluginProperties &GetGlobalProperties() {
   static PluginProperties g_settings;
   return g_settings;
 }
#endif
   LLDB_LOGF(
       log, "PlatformAndroid::%s() aborting creation of remote-android platform",
       __FUNCTION__);
 
   return PlatformSP();
 }
 
 void PlatformAndroid::DebuggerInitialize(Debugger &debugger) {
-  if (!PluginManager::GetSettingForPlatformPlugin(
-          debugger, ConstString(GetPluginNameStatic(false)))) {
+  if (!PluginManager::GetSettingForPlatformPlugin(debugger,
+                                                  GetPluginNameStatic(false))) {
     PluginManager::CreateSettingForPlatformPlugin(
         debugger, GetGlobalProperties().GetValueProperties(),
         "Properties for the Android platform plugin.",
         /*is_global_property=*/true);
   }
 }
 
 PlatformAndroid::PlatformAndroid(bool is_host)

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 
 #define LLDB_PROPERTIES_platformdarwin
 enum {
 #include "PlatformMacOSXPropertiesEnum.inc"
 };
 
 class PlatformDarwinProperties : public Properties {
 public:
-  static ConstString &GetSettingName() {
-    static ConstString g_setting_name("darwin");
+  static llvm::StringRef GetSettingName() {
+    static constexpr llvm::StringLiteral g_setting_name("darwin");
     return g_setting_name;
   }
 
   PlatformDarwinProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_platformdarwin_properties);
   }
 

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 
 enum {
 #define LLDB_PROPERTIES_platformdarwinkernel
 #include "PlatformMacOSXPropertiesEnum.inc"
 };
 
 class PlatformDarwinKernelProperties : public Properties {
 public:
-  static ConstString &GetSettingName() {
-    static ConstString g_setting_name("darwin-kernel");
+  static llvm::StringRef GetSettingName() {
+    static constexpr llvm::StringLiteral g_setting_name("darwin-kernel");
     return g_setting_name;
   }
 
   PlatformDarwinKernelProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_platformdarwinkernel_properties);
   }
 

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.cpp

 #define LLDB_PROPERTIES_platformqemuuser
 #include "PlatformQemuUserPropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
   PluginProperties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(
-        ConstString(PlatformQemuUser::GetPluginNameStatic()));
+        PlatformQemuUser::GetPluginNameStatic());
     m_collection_sp->Initialize(g_platformqemuuser_properties);
   }
 
   llvm::StringRef GetArchitecture() {
     return GetPropertyAtIndexAs<llvm::StringRef>(ePropertyArchitecture, "");
   }
 
   FileSpec GetEmulatorPath() {
PluginManager::RegisterPlugin(
       PlatformQemuUser::CreateInstance, PlatformQemuUser::DebuggerInitialize);
 }
 
 void PlatformQemuUser::Terminate() {
   PluginManager::UnregisterPlugin(PlatformQemuUser::CreateInstance);
 }
 
 void PlatformQemuUser::DebuggerInitialize(Debugger &debugger) {
-  if (!PluginManager::GetSettingForPlatformPlugin(
-          debugger, ConstString(GetPluginNameStatic()))) {
+  if (!PluginManager::GetSettingForPlatformPlugin(debugger,
+                                                  GetPluginNameStatic())) {
     PluginManager::CreateSettingForPlatformPlugin(
         debugger, GetGlobalProperties().GetValueProperties(),
         "Properties for the qemu-user platform plugin.",
         /*is_global_property=*/true);
   }
 }
 
 PlatformSP PlatformQemuUser::CreateInstance(bool force, const ArchSpec *arch) {

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 
 enum {
 #define LLDB_PROPERTIES_processkdp
 #include "ProcessKDPPropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
-  static ConstString GetSettingName() {
-    return ConstString(ProcessKDP::GetPluginNameStatic());
+  static llvm::StringRef GetSettingName() {
+    return ProcessKDP::GetPluginNameStatic();
   }
 
   PluginProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_processkdp_properties);
   }
 
   ~PluginProperties() override = default;

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 
 enum {
 #define LLDB_PROPERTIES_processgdbremote
 #include "ProcessGDBRemotePropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
-  static ConstString GetSettingName() {
-    return ConstString(ProcessGDBRemote::GetPluginNameStatic());
+  static llvm::StringRef GetSettingName() {
+    return ProcessGDBRemote::GetPluginNameStatic();
   }
 
   PluginProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_processgdbremote_properties);
   }
 
   ~PluginProperties() override = default;

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 
 enum {
 #define LLDB_PROPERTIES_darwinlog
 #include "StructuredDataDarwinLogPropertiesEnum.inc"
 };
 
 class StructuredDataDarwinLogProperties : public Properties {
 public:
-  static ConstString &GetSettingName() {
-    static ConstString g_setting_name("darwin-log");
+  static llvm::StringRef GetSettingName() {
+    static constexpr llvm::StringLiteral g_setting_name("darwin-log");
     return g_setting_name;
   }
 
   StructuredDataDarwinLogProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_darwinlog_properties);
   }
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 enum {
 #define LLDB_PROPERTIES_symbolfiledwarf
 #include "SymbolFileDWARFPropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
-  static ConstString GetSettingName() {
-    return ConstString(SymbolFileDWARF::GetPluginNameStatic());
+  static llvm::StringRef GetSettingName() {
+    return SymbolFileDWARF::GetPluginNameStatic();
   }
 
   PluginProperties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_symbolfiledwarf_properties);
   }
 
   bool IgnoreFileIndexes() const {

lldb/source/Target/Platform.cpp

 
 enum {
 #define LLDB_PROPERTIES_platform
 #include "TargetPropertiesEnum.inc"
 };
 
 } // namespace
 
-ConstString PlatformProperties::GetSettingName() {
-  static ConstString g_setting_name("platform");
+llvm::StringRef PlatformProperties::GetSettingName() {
+  static constexpr llvm::StringLiteral g_setting_name("platform");
   return g_setting_name;
 }
 
 PlatformProperties::PlatformProperties() {
   m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
   m_collection_sp->Initialize(g_platform_properties);
 
   auto module_cache_dir = GetModuleCacheDirectory();

lldb/source/Target/Process.cpp

 #define DISABLE_MEM_CACHE_DEFAULT false
 #else
 #define DISABLE_MEM_CACHE_DEFAULT true
 #endif
 
 class ProcessOptionValueProperties
     : public Cloneable<ProcessOptionValueProperties, OptionValueProperties> {
 public:
-  ProcessOptionValueProperties(ConstString name) : Cloneable(name) {}
+  ProcessOptionValueProperties(llvm::StringRef name) : Cloneable(name) {}
 
   const Property *
   GetPropertyAtIndex(size_t idx,
                      const ExecutionContext *exe_ctx) const override {
     // When getting the value for a key from the process options, we will
     // always try and grab the setting from the current process if there is
     // one. Else we just use the one from this instance.
     if (exe_ctx) {

 #include "TargetPropertiesEnum.inc"
 };
 
 class ProcessExperimentalOptionValueProperties
     : public Cloneable<ProcessExperimentalOptionValueProperties,
                        OptionValueProperties> {
 public:
   ProcessExperimentalOptionValueProperties()
-      : Cloneable(
-            ConstString(Properties::GetExperimentalSettingsName())) {}
+      : Cloneable(Properties::GetExperimentalSettingsName()) {}
 };
 
 ProcessExperimentalProperties::ProcessExperimentalProperties()
     : Properties(OptionValuePropertiesSP(
           new ProcessExperimentalOptionValueProperties())) {
   m_collection_sp->Initialize(g_process_experimental_properties);
 }
 
 ProcessProperties::ProcessProperties(lldb_private::Process *process)
     : Properties(),
       m_process(process) // Can be nullptr for global ProcessProperties
 {
   if (process == nullptr) {
     // Global process properties, set them up one time
-    m_collection_sp =
-        std::make_shared<ProcessOptionValueProperties>(ConstString("process"));
+    m_collection_sp = std::make_shared<ProcessOptionValueProperties>("process");
     m_collection_sp->Initialize(g_process_properties);
     m_collection_sp->AppendProperty(
         "thread", "Settings specific to threads.", true,
         Thread::GetGlobalProperties().GetValueProperties());
   } else {
     m_collection_sp =
         OptionValueProperties::CreateLocalCopy(Process::GetGlobalProperties());
     m_collection_sp->SetValueChangedCallback(

lldb/source/Target/Target.cpp

 #define LLDB_PROPERTIES_target
 #include "TargetPropertiesEnum.inc"
   ePropertyExperimental,
 };
 
 class TargetOptionValueProperties
     : public Cloneable<TargetOptionValueProperties, OptionValueProperties> {
 public:
-  TargetOptionValueProperties(ConstString name) : Cloneable(name) {}
+  TargetOptionValueProperties(llvm::StringRef name) : Cloneable(name) {}
 
   const Property *
   GetPropertyAtIndex(size_t idx,
                      const ExecutionContext *exe_ctx = nullptr) const override {
     // When getting the value for a key from the target options, we will always
     // try and grab the setting from the current target if there is one. Else
     // we just use the one from this instance.
     if (exe_ctx) {

 #include "TargetPropertiesEnum.inc"
 };
 
 class TargetExperimentalOptionValueProperties
     : public Cloneable<TargetExperimentalOptionValueProperties,
                        OptionValueProperties> {
 public:
   TargetExperimentalOptionValueProperties()
-      : Cloneable(ConstString(Properties::GetExperimentalSettingsName())) {}
+      : Cloneable(Properties::GetExperimentalSettingsName()) {}
 };
 
 TargetExperimentalProperties::TargetExperimentalProperties()
     : Properties(OptionValuePropertiesSP(
           new TargetExperimentalOptionValueProperties())) {
   m_collection_sp->Initialize(g_target_experimental_properties);
 }
 
if (target) {
     m_experimental_properties_up =
         std::make_unique<TargetExperimentalProperties>();
     m_collection_sp->AppendProperty(
         Properties::GetExperimentalSettingsName(),
         "Experimental settings - setting these won't produce "
         "errors if the setting is not present.",
         true, m_experimental_properties_up->GetValueProperties());
   } else {
-    m_collection_sp =
-        std::make_shared<TargetOptionValueProperties>(ConstString("target"));
+    m_collection_sp = std::make_shared<TargetOptionValueProperties>("target");
     m_collection_sp->Initialize(g_target_properties);
     m_experimental_properties_up =
         std::make_unique<TargetExperimentalProperties>();
     m_collection_sp->AppendProperty(
         Properties::GetExperimentalSettingsName(),
         "Experimental settings - setting these won't produce "
         "errors if the setting is not present.",
         true, m_experimental_properties_up->GetValueProperties());

lldb/source/Target/Thread.cpp

 enum {
 #define LLDB_PROPERTIES_thread
 #include "TargetPropertiesEnum.inc"
 };
 
 class ThreadOptionValueProperties
     : public Cloneable<ThreadOptionValueProperties, OptionValueProperties> {
 public:
-  ThreadOptionValueProperties(ConstString name) : Cloneable(name) {}
+  ThreadOptionValueProperties(llvm::StringRef name) : Cloneable(name) {}
 
   const Property *
   GetPropertyAtIndex(size_t idx,
                      const ExecutionContext *exe_ctx) const override {
     // When getting the value for a key from the thread options, we will always
     // try and grab the setting from the current thread if there is one. Else
     // we just use the one from this instance.
     if (exe_ctx) {
       Thread *thread = exe_ctx->GetThreadPtr();
       if (thread) {
         ThreadOptionValueProperties *instance_properties =
             static_cast<ThreadOptionValueProperties *>(
                 thread->GetValueProperties().get());
         if (this != instance_properties)
           return instance_properties->ProtectedGetPropertyAtIndex(idx);
       }
     }
     return ProtectedGetPropertyAtIndex(idx);
   }
 };
 
 ThreadProperties::ThreadProperties(bool is_global) : Properties() {
   if (is_global) {
-    m_collection_sp =
-        std::make_shared<ThreadOptionValueProperties>(ConstString("thread"));
+    m_collection_sp = std::make_shared<ThreadOptionValueProperties>("thread");
     m_collection_sp->Initialize(g_thread_properties);
   } else
     m_collection_sp =
         OptionValueProperties::CreateLocalCopy(Thread::GetGlobalProperties());
 }
 
 ThreadProperties::~ThreadProperties() = default;