[lldb] Add `operator StringRef` to ConstString

[kastiglione]

Summary

Add a StringRef conversion function to ConstString.

This will make using llvm and other non-ConstString APIs more convenient.

For demonstration, this change updates Module.cpp.

[aprantl]

I understand that the opposite direction is explicit because actual work is being done. In this direction, it shouldn't affect memory management (since ConstStrings live forever) or performance, so I think this is good (and very convenient!).
Does anyone else see a problem with this?

[jasonmolenda]

In D148175#4263217, @aprantl wrote:

I understand that the opposite direction is explicit because actual work is being done. In this direction, it shouldn't affect memory management (since ConstStrings live forever) or performance, so I think this is good (and very convenient!).
Does anyone else see a problem with this?

I think this is safe and helpful.

[JDevlieghere]

+1

[aprantl]

Okay, then let the refactor fest begin!

[fdeazeve]

since ConstStrings live forever

As long as this is true, I don't see any pitfalls either.

lldb/include/lldb/Utility/ConstString.h

public:
   /// \param[in] rhs
   ///     Another string object to compare this object to.
   ///
   /// \return \b true if this object is not equal to \a rhs, false otherwise.
   bool operator!=(const char *rhs) const { return !(*this == rhs); }
 
   bool operator<(ConstString rhs) const;
 
+  // Implicitly convert \class ConstString instances to \class StringRef.
+  operator llvm::StringRef() const { return GetStringRef(); }
+
   /// Get the string value as a C string.
   ///
   /// Get the value of the contained string as a NULL terminated C string
   /// value.
   ///
   /// If \a value_if_empty is nullptr, then nullptr will be returned.
   ///
   /// \return Returns \a value_if_empty if the string is empty, otherwise

lldb/source/Core/Module.cpp

if (m_name == function_name)
     return true;
 
   // If function_name is mangled, we'll need to demangle it.
   // In the pathologial case where the function name "looks" mangled but is
   // actually demangled (e.g. a method named _Zonk), this operation should be
   // relatively inexpensive since no demangling is actually occuring. See
   // Mangled::SetValue for more context.
   const bool function_name_may_be_mangled =
-      Mangled::GetManglingScheme(function_name.GetStringRef()) !=
-      Mangled::eManglingSchemeNone;
+      Mangled::GetManglingScheme(function_name) != Mangled::eManglingSchemeNone;
   ConstString demangled_function_name = function_name;
   if (function_name_may_be_mangled) {
     Mangled mangled_function_name(function_name);
     demangled_function_name = mangled_function_name.GetDemangledName();
   }
 
   // If the symbol has a language, then let the language make the match.
   // Otherwise just check that the demangled function name contains the
   // demangled user-provided name.
   if (Language *language = Language::FindPlugin(language_type))
-    return language->DemangledNameContainsPath(m_name.GetStringRef(),
-                                               demangled_function_name);
+    return language->DemangledNameContainsPath(m_name, demangled_function_name);
 
-  llvm::StringRef function_name_ref = demangled_function_name.GetStringRef();
-  return function_name_ref.contains(m_name.GetStringRef());
+  llvm::StringRef function_name_ref = demangled_function_name;
+  return function_name_ref.contains(m_name);
 }
 
 void Module::LookupInfo::Prune(SymbolContextList &sc_list,
                                size_t start_idx) const {
   if (m_match_name_after_lookup && m_name) {
     SymbolContext sc;
     size_t i = start_idx;
     while (i < sc_list.GetSize()) {
while (i < sc_list.GetSize()) {
       // Make sure the mangled and demangled names don't match before we try to
       // pull anything out
       ConstString mangled_name(sc.GetFunctionName(Mangled::ePreferMangled));
       ConstString full_name(sc.GetFunctionName());
       if (mangled_name != m_name && full_name != m_name) {
         CPlusPlusLanguage::MethodName cpp_method(full_name);
         if (cpp_method.IsValid()) {
           if (cpp_method.GetContext().empty()) {
-            if (cpp_method.GetBasename().compare(m_name.GetStringRef()) != 0) {
+            if (cpp_method.GetBasename().compare(m_name) != 0) {
               sc_list.RemoveContextAtIndex(i);
               continue;
             }
           } else {
             std::string qualified_name;
             llvm::StringRef anon_prefix("(anonymous namespace)");
             if (cpp_method.GetContext() == anon_prefix)
               qualified_name = cpp_method.GetBasename().str();
if (type_class != eTypeClassAny && !type_basename.empty()) {
       FindTypes_Impl(ConstString(type_basename), CompilerDeclContext(),
                      UINT_MAX, searched_symbol_files, typesmap);
       typesmap.RemoveMismatchedTypes(type_scope, type_basename, type_class,
                                      exact_match);
     } else {
       FindTypes_Impl(name, CompilerDeclContext(), UINT_MAX,
                      searched_symbol_files, typesmap);
       if (exact_match) {
-        typesmap.RemoveMismatchedTypes(type_scope, name.GetStringRef(),
-                                       type_class, exact_match);
+        typesmap.RemoveMismatchedTypes(type_scope, name, type_class,
+                                       exact_match);
       }
     }
   }
   if (typesmap.GetSize()) {
     SymbolContext sc;
     sc.module_sp = shared_from_this();
     sc.SortTypeList(typesmap, types);
   }

 
 void Module::ReportWarningOptimization(
     std::optional<lldb::user_id_t> debugger_id) {
   ConstString file_name = GetFileSpec().GetFilename();
   if (file_name.IsEmpty())
     return;
 
   StreamString ss;
-  ss << file_name.GetStringRef()
+  ss << file_name
      << " was compiled with optimization - stepping may behave "
         "oddly; variables may not be available.";
   Debugger::ReportWarning(std::string(ss.GetString()), debugger_id,
                           &m_optimization_warning);
 }
 
 void Module::ReportWarningUnsupportedLanguage(
     LanguageType language, std::optional<lldb::user_id_t> debugger_id) {
bool Module::GetIsDynamicLinkEditor() {
   return false;
 }
 
 uint32_t Module::Hash() {
   std::string identifier;
   llvm::raw_string_ostream id_strm(identifier);
   id_strm << m_arch.GetTriple().str() << '-' << m_file.GetPath();
   if (m_object_name)
-    id_strm << '(' << m_object_name.GetStringRef() << ')';
+    id_strm << '(' << m_object_name << ')';
   if (m_object_offset > 0)
     id_strm << m_object_offset;
   const auto mtime = llvm::sys::toTimeT(m_object_mod_time);
   if (mtime > 0)
     id_strm << mtime;
   return llvm::djbHash(id_strm.str());
 }
 
 std::string Module::GetCacheKey() {
   std::string key;
   llvm::raw_string_ostream strm(key);
   strm << m_arch.GetTriple().str() << '-' << m_file.GetFilename();
   if (m_object_name)
-    strm << '(' << m_object_name.GetStringRef() << ')';
+    strm << '(' << m_object_name << ')';
   strm << '-' << llvm::format_hex(Hash(), 10);
   return strm.str();
 }
 
 DataFileCache *Module::GetIndexCache() {
   if (!ModuleList::GetGlobalModuleListProperties().GetEnableLLDBIndexCache())
     return nullptr;
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
   static DataFileCache *g_data_file_cache =
       new DataFileCache(ModuleList::GetGlobalModuleListProperties()
                             .GetLLDBIndexCachePath()
                             .GetPath());
   return g_data_file_cache;
 }