[lldb][NFC] Remove all uses of StringRef::withNullAsEmpty in LLDB

[teemperor]

Summary

A long time ago LLDB wanted to start using StringRef instead of C-Strings/ConstString but
was blocked by the fact that the StringRef constructor that takes a C-string was asserting
that the C-string isn't a nullptr. To workaround this, D24697 introduced a special function
called withNullAsEmpty and that's what LLDB (and only LLDB) started to use to build
StringRefs from C-strings.

A bit later it seems that withNullAsEmpty was declared too awkward to use and instead
the assert in the StringRef constructor got removed (see D24904). The rest of LLDB was
then converted to StringRef by just calling the now perfectly usable implicit constructor.

However, all the calls to withNullAsEmpty just remained and are now just strange
artefacts in the code base that just look out of place. It's also curiously a LLDB-exclusive
function and no other project ever called it since it's introduction half a decade ago.

This patch removes all uses of withNullAsEmpty. The follow up will be to remove the
function from StringRef.

[JDevlieghere]

🚢 it

lldb/include/lldb/Interpreter/OptionValueRegex.h

 #include "lldb/Interpreter/OptionValue.h"
 #include "lldb/Utility/RegularExpression.h"
 
 namespace lldb_private {
 
 class OptionValueRegex : public Cloneable<OptionValueRegex, OptionValue> {
 public:
   OptionValueRegex(const char *value = nullptr)
-      : m_regex(llvm::StringRef::withNullAsEmpty(value)),
-        m_default_regex_str(llvm::StringRef::withNullAsEmpty(value).str()) {}
+      : m_regex(value), m_default_regex_str(value) {}
 
   ~OptionValueRegex() override = default;
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeRegex; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,

lldb/include/lldb/Interpreter/OptionValueString.h

public:
 
   // Subclass specific functions
 
   Flags &GetOptions() { return m_options; }
 
   const Flags &GetOptions() const { return m_options; }
 
   const char *operator=(const char *value) {
-    SetCurrentValue(llvm::StringRef::withNullAsEmpty(value));
+    SetCurrentValue(value);
     return m_current_value.c_str();
   }
 
   const char *GetCurrentValue() const { return m_current_value.c_str(); }
   llvm::StringRef GetCurrentValueAsRef() const { return m_current_value; }
 
   const char *GetDefaultValue() const { return m_default_value.c_str(); }
   llvm::StringRef GetDefaultValueAsRef() const { return m_default_value; }

lldb/source/API/SBDebugger.cpp

const char *SBDebugger::GetPrompt() const {
   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
                       : nullptr);
 }
 
 void SBDebugger::SetPrompt(const char *prompt) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
 
   if (m_opaque_sp)
-    m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
+    m_opaque_sp->SetPrompt(llvm::StringRef(prompt));
 }
 
 const char *SBDebugger::GetReproducerPath() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
 
   return (m_opaque_sp
               ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
               : nullptr);

lldb/source/API/SBLanguageRuntime.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 lldb::LanguageType
 SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
   LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
                             GetLanguageTypeFromString, (const char *), string);
 
-  return Language::GetLanguageTypeFromString(
-      llvm::StringRef::withNullAsEmpty(string));
+  return Language::GetLanguageTypeFromString(llvm::StringRef(string));
 }
 
 const char *
 SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) {
   LLDB_RECORD_STATIC_METHOD(const char *, SBLanguageRuntime,
                             GetNameForLanguageType, (lldb::LanguageType),
                             language);
 

lldb/source/API/SBPlatform.cpp

 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
                      (lldb::SBPlatformConnectOptions &), connect_options);
 
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp && connect_options.GetURL()) {
     Args args;
-    args.AppendArgument(
-        llvm::StringRef::withNullAsEmpty(connect_options.GetURL()));
+    args.AppendArgument(connect_options.GetURL());
     sb_error.ref() = platform_sp->ConnectRemote(args);
   } else {
     sb_error.SetErrorString("invalid platform");
   }
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 void SBPlatform::DisconnectRemote() {

lldb/source/API/SBTypeCategory.cpp

bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
   if (!type_name.IsValid())
     return false;
 
   if (!format.IsValid())
     return false;
 
   if (type_name.IsRegex())
     m_opaque_sp->GetRegexTypeFormatsContainer()->Add(
-        RegularExpression(
-            llvm::StringRef::withNullAsEmpty(type_name.GetName())),
-        format.GetSP());
+        RegularExpression(type_name.GetName()), format.GetSP());
   else
     m_opaque_sp->GetTypeFormatsContainer()->Add(
         ConstString(type_name.GetName()), format.GetSP());
 
   return true;
 }
 
 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
for (uint32_t j = 0; j < num_debuggers; j++) {
           }
         }
       }
     }
   }
 
   if (type_name.IsRegex())
     m_opaque_sp->GetRegexTypeSummariesContainer()->Add(
-        RegularExpression(
-            llvm::StringRef::withNullAsEmpty(type_name.GetName())),
-        summary.GetSP());
+        RegularExpression(type_name.GetName()), summary.GetSP());
   else
     m_opaque_sp->GetTypeSummariesContainer()->Add(
         ConstString(type_name.GetName()), summary.GetSP());
 
   return true;
 }
 
 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
   if (!type_name.IsValid())
     return false;
 
   if (!filter.IsValid())
     return false;
 
   if (type_name.IsRegex())
     m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
-        RegularExpression(
-            llvm::StringRef::withNullAsEmpty(type_name.GetName())),
-        filter.GetSP());
+        RegularExpression(type_name.GetName()), filter.GetSP());
   else
     m_opaque_sp->GetTypeFiltersContainer()->Add(
         ConstString(type_name.GetName()), filter.GetSP());
 
   return true;
 }
 
 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
for (uint32_t j = 0; j < num_debuggers; j++) {
           }
         }
       }
     }
   }
 
   if (type_name.IsRegex())
     m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(
-        RegularExpression(
-            llvm::StringRef::withNullAsEmpty(type_name.GetName())),
-        synth.GetSP());
+        RegularExpression(type_name.GetName()), synth.GetSP());
   else
     m_opaque_sp->GetTypeSyntheticsContainer()->Add(
         ConstString(type_name.GetName()), synth.GetSP());
 
   return true;
 }
 
 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {

lldb/source/Breakpoint/BreakpointResolverName.cpp

 BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
     const char *name_cstr, FunctionNameType name_type_mask,
     LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset,
     bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_class_name(), m_regex(), m_match_type(type), m_language(language),
       m_skip_prologue(skip_prologue) {
   if (m_match_type == Breakpoint::Regexp) {
-    m_regex = RegularExpression(llvm::StringRef::withNullAsEmpty(name_cstr));
+    m_regex = RegularExpression(name_cstr);
     if (!m_regex.IsValid()) {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
       if (log)
         log->Warning("function name regexp: \"%s\" did not compile.",
                      name_cstr);
     }
   } else {

lldb/source/Commands/CommandObjectFrame.cpp

HandleArgumentCompletion(CompletionRequest &request,
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eVariablePathCompletion,
         request, nullptr);
   }
 
 protected:
   llvm::StringRef GetScopeString(VariableSP var_sp) {
     if (!var_sp)
-      return llvm::StringRef::withNullAsEmpty(nullptr);
+      return llvm::StringRef();
 
     switch (var_sp->GetScope()) {
     case eValueTypeVariableGlobal:
       return "GLOBAL: ";
     case eValueTypeVariableStatic:
       return "STATIC: ";
     case eValueTypeVariableArgument:
       return "ARG: ";
     case eValueTypeVariableLocal:
       return "LOCAL: ";
     case eValueTypeVariableThreadLocal:
       return "THREAD: ";
     default:
       break;
     }
 
-    return llvm::StringRef::withNullAsEmpty(nullptr);
+    return llvm::StringRef();
   }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     // No need to check "frame" for validity as eCommandRequiresFrame ensures
     // it is valid
     StackFrame *frame = m_exe_ctx.GetFramePtr();
 
     Stream &s = result.GetOutputStream();

lldb/source/Commands/CommandObjectTarget.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (argc > 0) {
       for (const Args::ArgEntry &arg : args) {
         VariableList variable_list;
         ValueObjectList valobj_list;
 
         size_t matches = 0;
         bool use_var_name = false;
         if (m_option_variable.use_regex) {
-          RegularExpression regex(
-              llvm::StringRef::withNullAsEmpty(arg.c_str()));
+          RegularExpression regex(arg.ref());
           if (!regex.IsValid()) {
             result.GetErrorStream().Printf(
                 "error: invalid regular expression: '%s'\n", arg.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
           }
           use_var_name = true;
           target->GetImages().FindGlobalVariables(regex, UINT32_MAX,

lldb/source/Commands/CommandObjectType.cpp

if (m_options.m_category_regex.OptionWasSet()) {
             m_options.m_category_regex.GetCurrentValueAsRef().str().c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
 
     if (argc == 1) {
       const char *arg = command.GetArgumentAtIndex(0);
-      formatter_regex = std::make_unique<RegularExpression>(
-          llvm::StringRef::withNullAsEmpty(arg));
+      formatter_regex = std::make_unique<RegularExpression>(arg);
       if (!formatter_regex->IsValid()) {
         result.AppendErrorWithFormat("syntax error in regular expression '%s'",
                                      arg);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     } else {
       DataVisualization::Categories::ForEach(
           [&category_regex, &category_closure](
               const lldb::TypeCategoryImplSP &category) -> bool {
             if (category_regex) {
               bool escape = true;
               if (category->GetName() == category_regex->GetText()) {
                 escape = false;
-              } else if (category_regex->Execute(
-                             llvm::StringRef::withNullAsEmpty(
-                                 category->GetName()))) {
+              } else if (category_regex->Execute(category->GetName())) {
                 escape = false;
               }
 
               if (escape)
                 return true;
             }
 
             category_closure(category);

 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
 
     std::unique_ptr<RegularExpression> regex;
 
     if (argc == 1) {
       const char *arg = command.GetArgumentAtIndex(0);
-      regex = std::make_unique<RegularExpression>(
-          llvm::StringRef::withNullAsEmpty(arg));
+      regex = std::make_unique<RegularExpression>(arg);
       if (!regex->IsValid()) {
         result.AppendErrorWithFormat(
             "syntax error in category regular expression '%s'", arg);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     } else if (argc != 0) {
       result.AppendErrorWithFormat("%s takes 0 or one arg.\n",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     DataVisualization::Categories::ForEach(
         [&regex, &result](const lldb::TypeCategoryImplSP &category_sp) -> bool {
           if (regex) {
             bool escape = true;
             if (regex->GetText() == category_sp->GetName()) {
               escape = false;
-            } else if (regex->Execute(llvm::StringRef::withNullAsEmpty(
-                           category_sp->GetName()))) {
+            } else if (regex->Execute(category_sp->GetName())) {
               escape = false;
             }
 
             if (escape)
               return true;
           }
 
           result.GetOutputStream().Printf(

lldb/source/Interpreter/CommandInterpreter.cpp

 }
 
 void CommandInterpreter::GetLLDBCommandsFromIOHandler(
     const char *prompt, IOHandlerDelegate &delegate, void *baton) {
   Debugger &debugger = GetDebugger();
   IOHandlerSP io_handler_sp(
       new IOHandlerEditline(debugger, IOHandler::Type::CommandList,
                             "lldb", // Name of input reader for history
-                            llvm::StringRef::withNullAsEmpty(prompt), // Prompt
-                            llvm::StringRef(), // Continuation prompt
-                            true,              // Get multiple lines
+                            llvm::StringRef(prompt), // Prompt
+                            llvm::StringRef(),       // Continuation prompt
+                            true,                    // Get multiple lines
                             debugger.GetUseColor(),
                             0,         // Don't show line numbers
                             delegate,  // IOHandlerDelegate
                             nullptr)); // FileShadowCollector
 
   if (io_handler_sp) {
     io_handler_sp->SetUserData(baton);
     debugger.RunIOHandlerAsync(io_handler_sp);
   }
 }
 
 void CommandInterpreter::GetPythonCommandsFromIOHandler(
     const char *prompt, IOHandlerDelegate &delegate, void *baton) {
   Debugger &debugger = GetDebugger();
   IOHandlerSP io_handler_sp(
       new IOHandlerEditline(debugger, IOHandler::Type::PythonCode,
                             "lldb-python", // Name of input reader for history
-                            llvm::StringRef::withNullAsEmpty(prompt), // Prompt
-                            llvm::StringRef(), // Continuation prompt
-                            true,              // Get multiple lines
+                            llvm::StringRef(prompt), // Prompt
+                            llvm::StringRef(),       // Continuation prompt
+                            true,                    // Get multiple lines
                             debugger.GetUseColor(),
                             0,         // Don't show line numbers
                             delegate,  // IOHandlerDelegate
                             nullptr)); // FileShadowCollector
 
   if (io_handler_sp) {
     io_handler_sp->SetUserData(baton);
     debugger.RunIOHandlerAsync(io_handler_sp);

lldb/source/Interpreter/OptionValue.cpp

case 1u << eTypeUInt64:
     value_sp = std::make_shared<OptionValueUInt64>();
     break;
   case 1u << eTypeUUID:
     value_sp = std::make_shared<OptionValueUUID>();
     break;
   }
 
   if (value_sp)
-    error = value_sp->SetValueFromString(
-        llvm::StringRef::withNullAsEmpty(value_cstr), eVarSetOperationAssign);
+    error = value_sp->SetValueFromString(value_cstr, eVarSetOperationAssign);
   else
     error.SetErrorString("unsupported type mask");
   return value_sp;
 }
 
 bool OptionValue::DumpQualifiedName(Stream &strm) const {
   bool dumped_something = false;
   lldb::OptionValueSP m_parent_sp(m_parent_wp.lock());

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     std::unique_ptr<RegularExpression> regex_up;
     switch (command.GetArgumentCount()) {
     case 0:
       break;
     case 1: {
-      regex_up = std::make_unique<RegularExpression>(
-          llvm::StringRef::withNullAsEmpty(command.GetArgumentAtIndex(0)));
+      regex_up =
+          std::make_unique<RegularExpression>(command.GetArgumentAtIndex(0));
       if (!regex_up->IsValid()) {
         result.AppendError(
             "invalid argument - please provide a valid regular expression");
         result.SetStatus(lldb::eReturnStatusFailed);
         return false;
       }
       break;
     }

lldb/source/Target/ThreadPlanStepInRange.cpp

bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) {
   } else {
     m_no_more_plans = false;
     m_sub_plan_sp->SetPrivate(true);
     return false;
   }
 }
 
 void ThreadPlanStepInRange::SetAvoidRegexp(const char *name) {
-  auto name_ref = llvm::StringRef::withNullAsEmpty(name);
   if (m_avoid_regexp_up)
-    *m_avoid_regexp_up = RegularExpression(name_ref);
+    *m_avoid_regexp_up = RegularExpression(name);
   else
-    m_avoid_regexp_up = std::make_unique<RegularExpression>(name_ref);
+    m_avoid_regexp_up = std::make_unique<RegularExpression>(name);
 }
 
 void ThreadPlanStepInRange::SetDefaultFlagValue(uint32_t new_value) {
   // TODO: Should we test this for sanity?
   ThreadPlanStepInRange::s_default_flag_values = new_value;
 }
 
 bool ThreadPlanStepInRange::FrameMatchesAvoidCriteria() {