[lldb] Turn lldb_private::Status into a value type. (llvm#106163)

This patch removes all of the Set.* methods from Status.

This cleanup is part of a series of patches that make it harder use the
anti-pattern of keeping a long-lives Status object around and updating
it while dropping any errors it contains on the floor.

This patch is largely NFC, the more interesting next steps this enables
is to:
1. remove Status.Clear()
2. assert that Status::operator=() never overwrites an error
3. remove Status::operator=()

Note that step (2) will bring 90% of the benefits for users, and step
(3) will dramatically clean up the error handling code in various
places. In the end my goal is to convert all APIs that are of the form

`    ResultTy DoFoo(Status& error)
`
to

`    llvm::Expected<ResultTy> DoFoo()
`
How to read this patch?

The interesting changes are in Status.h and Status.cpp, all other
changes are mostly

` perl -pi -e 's/\.SetErrorString/ = Status::FromErrorString/g' $(git
grep -l SetErrorString lldb/source)
`
plus the occasional manual cleanup.

Author: adrian-prantl

lldb/bindings/python/python-wrapper.swig

@@ -306,11 +306,11 @@ PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedStopH
     const char *session_dictionary_name, const StructuredDataImpl &args_impl,
     Status &error) {
   if (python_class_name == NULL || python_class_name[0] == '\0') {
-    error.SetErrorString("Empty class name.");
+    error = Status::FromErrorString("Empty class name.");
     return PythonObject();
   }
   if (!session_dictionary_name) {
-    error.SetErrorString("No session dictionary");
+    error = Status::FromErrorString("No session dictionary");
     return PythonObject();
   }
 
@@ -322,7 +322,7 @@ PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedStopH
       python_class_name, dict);
 
   if (!pfunc.IsAllocated()) {
-    error.SetErrorStringWithFormat("Could not find class: %s.",
+    error = Status::FromErrorStringWithFormat("Could not find class: %s.",
                                    python_class_name);
     return PythonObject();
   }
@@ -337,23 +337,25 @@ PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedStopH
       if (auto args_info = callback_func.GetArgInfo()) {
         size_t num_args = (*args_info).max_positional_args;
         if (num_args != 2) {
-          error.SetErrorStringWithFormat(
+          error = Status::FromErrorStringWithFormat(
               "Wrong number of args for "
               "handle_stop callback, should be 2 (excluding self), got: %zu",
               num_args);
           return PythonObject();
         } else
           return result;
       } else {
-        error.SetErrorString("Couldn't get num arguments for handle_stop "
-                             "callback.");
+        error = Status::FromErrorString(
+            "Couldn't get num arguments for handle_stop "
+            "callback.");
         return PythonObject();
       }
       return result;
     } else {
-      error.SetErrorStringWithFormat("Class \"%s\" is missing the required "
-                                     "handle_stop callback.",
-                                     python_class_name);
+      error = Status::FromErrorStringWithFormat(
+          "Class \"%s\" is missing the required "
+          "handle_stop callback.",
+          python_class_name);
     }
   }
   return PythonObject();

lldb/include/lldb/Core/StructuredDataImpl.h

@@ -50,38 +50,28 @@ class StructuredDataImpl {
   }
 
   Status GetAsJSON(Stream &stream) const {
-    Status error;
-
-    if (!m_data_sp) {
-      error.SetErrorString("No structured data.");
-      return error;
-    }
+    if (!m_data_sp)
+      return Status::FromErrorString("No structured data.");
 
     llvm::json::OStream s(stream.AsRawOstream());
     m_data_sp->Serialize(s);
-    return error;
+    return Status();
   }
 
   Status GetDescription(Stream &stream) const {
-    Status error;
-
-    if (!m_data_sp) {
-      error.SetErrorString("Cannot pretty print structured data: "
-                           "no data to print.");
-      return error;
-    }
+    if (!m_data_sp)
+      return Status::FromErrorString("Cannot pretty print structured data: "
+                                     "no data to print.");
 
     // Grab the plugin
     lldb::StructuredDataPluginSP plugin_sp = m_plugin_wp.lock();
 
     // If there's no plugin, call underlying data's dump method:
     if (!plugin_sp) {
-      if (!m_data_sp) {
-        error.SetErrorString("No data to describe.");
-        return error;
-      }
+      if (!m_data_sp)
+        return Status::FromErrorString("No data to describe.");
       m_data_sp->GetDescription(stream);
-      return error;
+      return Status();
     }
     // Get the data's description.
     return plugin_sp->GetDescription(m_data_sp, stream);

lldb/include/lldb/Interpreter/Interfaces/ScriptedInterface.h

@@ -48,7 +48,7 @@ class ScriptedInterface {
           llvm::Twine(llvm::Twine(" (") + llvm::Twine(detailed_error) +
                       llvm::Twine(")"))
               .str();
-    error.SetErrorString(full_error_message);
+    error = Status(std::move(full_error_message));
     return {};
   }
 

lldb/include/lldb/Interpreter/Interfaces/ScriptedPlatformInterface.h

@@ -31,15 +31,18 @@ class ScriptedPlatformInterface : virtual public ScriptedInterface {
   }
 
   virtual Status AttachToProcess(lldb::ProcessAttachInfoSP attach_info) {
-    return Status("ScriptedPlatformInterface cannot attach to a process");
+    return Status::FromErrorString(
+        "ScriptedPlatformInterface cannot attach to a process");
   }
 
   virtual Status LaunchProcess(lldb::ProcessLaunchInfoSP launch_info) {
-    return Status("ScriptedPlatformInterface cannot launch process");
+    return Status::FromErrorString(
+        "ScriptedPlatformInterface cannot launch process");
   }
 
   virtual Status KillProcess(lldb::pid_t pid) {
-    return Status("ScriptedPlatformInterface cannot kill process");
+    return Status::FromErrorString(
+        "ScriptedPlatformInterface cannot kill process");
   }
 };
 } // namespace lldb_private

lldb/include/lldb/Interpreter/Interfaces/ScriptedProcessInterface.h

@@ -29,23 +29,28 @@ class ScriptedProcessInterface : virtual public ScriptedInterface {
   virtual StructuredData::DictionarySP GetCapabilities() { return {}; }
 
   virtual Status Attach(const ProcessAttachInfo &attach_info) {
-    return Status("ScriptedProcess did not attach");
+    return Status::FromErrorString("ScriptedProcess did not attach");
   }
 
-  virtual Status Launch() { return Status("ScriptedProcess did not launch"); }
+  virtual Status Launch() {
+    return Status::FromErrorString("ScriptedProcess did not launch");
+  }
 
-  virtual Status Resume() { return Status("ScriptedProcess did not resume"); }
+  virtual Status Resume() {
+    return Status::FromErrorString("ScriptedProcess did not resume");
+  }
 
   virtual std::optional<MemoryRegionInfo>
   GetMemoryRegionContainingAddress(lldb::addr_t address, Status &error) {
-    error.SetErrorString("ScriptedProcess have no memory region.");
+    error = Status::FromErrorString("ScriptedProcess have no memory region.");
     return {};
   }
 
   virtual StructuredData::DictionarySP GetThreadsInfo() { return {}; }
 
   virtual bool CreateBreakpoint(lldb::addr_t addr, Status &error) {
-    error.SetErrorString("ScriptedProcess don't support creating breakpoints.");
+    error = Status::FromErrorString(
+        "ScriptedProcess don't support creating breakpoints.");
     return {};
   }
 

lldb/include/lldb/Interpreter/OptionValue.h

@@ -119,7 +119,8 @@ class OptionValue {
   virtual lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
                                           llvm::StringRef name,
                                           Status &error) const {
-    error.SetErrorStringWithFormatv("'{0}' is not a valid subvalue", name);
+    error = Status::FromErrorStringWithFormatv("'{0}' is not a valid subvalue",
+                                               name);
     return lldb::OptionValueSP();
   }
 

lldb/include/lldb/Interpreter/ScriptInterpreter.h

@@ -176,25 +176,19 @@ class ScriptInterpreter : public PluginInterface {
   virtual Status ExecuteMultipleLines(
       const char *in_string,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
-    Status error;
-    error.SetErrorString("not implemented");
-    return error;
+    return Status::FromErrorString("not implemented");
   }
 
   virtual Status
   ExportFunctionDefinitionToInterpreter(StringList &function_def) {
-    Status error;
-    error.SetErrorString("not implemented");
-    return error;
+    return Status::FromErrorString("not implemented");
   }
 
   virtual Status GenerateBreakpointCommandCallbackData(StringList &input,
                                                        std::string &output,
                                                        bool has_extra_args,
                                                        bool is_callback) {
-    Status error;
-    error.SetErrorString("not implemented");
-    return error;
+    return Status::FromErrorString("not implemented");
   }
 
   virtual bool GenerateWatchpointCommandCallbackData(StringList &input,
@@ -280,8 +274,9 @@ class ScriptInterpreter : public PluginInterface {
   virtual StructuredData::GenericSP
   CreateScriptedStopHook(lldb::TargetSP target_sp, const char *class_name,
                          const StructuredDataImpl &args_data, Status &error) {
-    error.SetErrorString("Creating scripted stop-hooks with the current "
-                         "script interpreter is not supported.");
+    error =
+        Status::FromErrorString("Creating scripted stop-hooks with the current "
+                                "script interpreter is not supported.");
     return StructuredData::GenericSP();
   }
 
@@ -308,9 +303,7 @@ class ScriptInterpreter : public PluginInterface {
   virtual Status GenerateFunction(const char *signature,
                                   const StringList &input,
                                   bool is_callback) {
-    Status error;
-    error.SetErrorString("unimplemented");
-    return error;
+    return Status::FromErrorString("not implemented");
   }
 
   virtual void CollectDataForBreakpointCommandCallback(
@@ -329,18 +322,14 @@ class ScriptInterpreter : public PluginInterface {
   virtual Status SetBreakpointCommandCallback(BreakpointOptions &bp_options,
                                               const char *callback_text,
                                               bool is_callback) {
-    Status error;
-    error.SetErrorString("unimplemented");
-    return error;
+    return Status::FromErrorString("not implemented");
   }
 
   /// This one is for deserialization:
   virtual Status SetBreakpointCommandCallback(
       BreakpointOptions &bp_options,
       std::unique_ptr<BreakpointOptions::CommandData> &data_up) {
-    Status error;
-    error.SetErrorString("unimplemented");
-    return error;
+    return Status::FromErrorString("not implemented");
   }
 
   Status SetBreakpointCommandCallbackFunction(
@@ -352,9 +341,7 @@ class ScriptInterpreter : public PluginInterface {
   SetBreakpointCommandCallbackFunction(BreakpointOptions &bp_options,
                                        const char *function_name,
                                        StructuredData::ObjectSP extra_args_sp) {
-    Status error;
-    error.SetErrorString("unimplemented");
-    return error;
+    return Status::FromErrorString("not implemented");
   }
 
   /// Set a one-liner as the callback for the watchpoint.
@@ -453,33 +440,33 @@ class ScriptInterpreter : public PluginInterface {
   virtual bool RunScriptFormatKeyword(const char *impl_function,
                                       Process *process, std::string &output,
                                       Status &error) {
-    error.SetErrorString("unimplemented");
+    error = Status::FromErrorString("unimplemented");
     return false;
   }
 
   virtual bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
                                       std::string &output, Status &error) {
-    error.SetErrorString("unimplemented");
+    error = Status::FromErrorString("unimplemented");
     return false;
   }
 
   virtual bool RunScriptFormatKeyword(const char *impl_function, Target *target,
                                       std::string &output, Status &error) {
-    error.SetErrorString("unimplemented");
+    error = Status::FromErrorString("unimplemented");
     return false;
   }
 
   virtual bool RunScriptFormatKeyword(const char *impl_function,
                                       StackFrame *frame, std::string &output,
                                       Status &error) {
-    error.SetErrorString("unimplemented");
+    error = Status::FromErrorString("unimplemented");
     return false;
   }
 
   virtual bool RunScriptFormatKeyword(const char *impl_function,
                                       ValueObject *value, std::string &output,
                                       Status &error) {
-    error.SetErrorString("unimplemented");
+    error = Status::FromErrorString("unimplemented");
     return false;
   }