[lldb] Turn lldb_private::Status into a value type. (#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.

14 files changed, 202 insertions, 184 deletions

diff --git a/lldb/source/API/SBBreakpoint.cpp b/lldb/source/API/SBBreakpoint.cpp
index 728fe04..3e9c010 100644
--- a/lldb/source/API/SBBreakpoint.cpp
+++ b/lldb/source/API/SBBreakpoint.cpp
@@ -540,17 +540,18 @@ SBError SBBreakpoint::AddLocation(SBAddress &address) {
   SBError error;
 
   if (!address.IsValid()) {
-    error.SetErrorString("Can't add an invalid address.");
+    error = Status::FromErrorString("Can't add an invalid address.");
     return error;
   }
 
   if (!bkpt_sp) {
-    error.SetErrorString("No breakpoint to add a location to.");
+    error = Status::FromErrorString("No breakpoint to add a location to.");
     return error;
   }
 
   if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
-    error.SetErrorString("Only a scripted resolver can add locations.");
+    error =
+        Status::FromErrorString("Only a scripted resolver can add locations.");
     return error;
   }
 
@@ -560,8 +561,8 @@ SBError SBBreakpoint::AddLocation(SBAddress &address) {
     StreamString s;
     address.get()->Dump(&s, &bkpt_sp->GetTarget(),
                         Address::DumpStyleModuleWithFileAddress);
-    error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
-                                   s.GetData());
+    error = Status::FromErrorStringWithFormat(
+        "Address: %s didn't pass the filter.", s.GetData());
   }
   return error;
 }
@@ -623,7 +624,7 @@ SBError SBBreakpoint::SetScriptCallbackFunction(
                                                    ->GetObjectSP());
     sb_error.SetError(error);
   } else
-    sb_error.SetErrorString("invalid breakpoint");
+    sb_error = Status::FromErrorString("invalid breakpoint");
 
   return sb_error;
 }
@@ -646,7 +647,7 @@ SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
                                            /*is_callback=*/false);
     sb_error.SetError(error);
   } else
-    sb_error.SetErrorString("invalid breakpoint");
+    sb_error = Status::FromErrorString("invalid breakpoint");
 
   return sb_error;
 }
@@ -671,7 +672,7 @@ SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
     bkpt_sp->GetTarget().AddNameToBreakpoint(bkpt_sp, new_name, error);
     status.SetError(error);
   } else {
-    status.SetErrorString("invalid breakpoint");
+    status = Status::FromErrorString("invalid breakpoint");
   }
 
   return status;
diff --git a/lldb/source/API/SBBreakpointLocation.cpp b/lldb/source/API/SBBreakpointLocation.cpp
index fad9a40..e5c96b8 100644
--- a/lldb/source/API/SBBreakpointLocation.cpp
+++ b/lldb/source/API/SBBreakpointLocation.cpp
@@ -241,7 +241,7 @@ SBError SBBreakpointLocation::SetScriptCallbackFunction(
                                                    ->GetObjectSP());
       sb_error.SetError(error);
     } else
-      sb_error.SetErrorString("invalid breakpoint");
+      sb_error = Status::FromErrorString("invalid breakpoint");
 
     return sb_error;
 }
@@ -266,7 +266,7 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
                                            /*is_callback=*/false);
     sb_error.SetError(error);
   } else
-    sb_error.SetErrorString("invalid breakpoint");
+    sb_error = Status::FromErrorString("invalid breakpoint");
 
   return sb_error;
 }
diff --git a/lldb/source/API/SBBreakpointName.cpp b/lldb/source/API/SBBreakpointName.cpp
index 5c7c0a8..7dc8dee 100644
--- a/lldb/source/API/SBBreakpointName.cpp
+++ b/lldb/source/API/SBBreakpointName.cpp
@@ -562,7 +562,7 @@ SBError SBBreakpointName::SetScriptCallbackFunction(
   SBError sb_error;
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name) {
-    sb_error.SetErrorString("unrecognized breakpoint name");
+    sb_error = Status::FromErrorString("unrecognized breakpoint name");
     return sb_error;
   }
 
diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp
index fb035a3..7250157 100644
--- a/lldb/source/API/SBDebugger.cpp
+++ b/lldb/source/API/SBDebugger.cpp
@@ -198,18 +198,21 @@ lldb::SBError SBDebugger::InitializeWithErrorHandling() {
         if (init_func(debugger_sb))
           return dynlib;
         else
-          error.SetErrorString("plug-in refused to load "
-                               "(lldb::PluginInitialize(lldb::SBDebugger) "
-                               "returned false)");
+          error = Status::FromErrorString(
+              "plug-in refused to load "
+              "(lldb::PluginInitialize(lldb::SBDebugger) "
+              "returned false)");
       } else {
-        error.SetErrorString("plug-in is missing the required initialization: "
-                             "lldb::PluginInitialize(lldb::SBDebugger)");
+        error = Status::FromErrorString(
+            "plug-in is missing the required initialization: "
+            "lldb::PluginInitialize(lldb::SBDebugger)");
       }
     } else {
       if (FileSystem::Instance().Exists(spec))
-        error.SetErrorString("this file does not represent a loadable dylib");
+        error = Status::FromErrorString(
+            "this file does not represent a loadable dylib");
       else
-        error.SetErrorString("no such file");
+        error = Status::FromErrorString("no such file");
     }
     return llvm::sys::DynamicLibrary();
   };
@@ -370,18 +373,18 @@ SBError SBDebugger::SetInputString(const char *data) {
   LLDB_INSTRUMENT_VA(this, data);
   SBError sb_error;
   if (data == nullptr) {
-    sb_error.SetErrorString("String data is null");
+    sb_error = Status::FromErrorString("String data is null");
     return sb_error;
   }
 
   size_t size = strlen(data);
   if (size == 0) {
-    sb_error.SetErrorString("String data is empty");
+    sb_error = Status::FromErrorString("String data is empty");
     return sb_error;
   }
 
   if (!m_opaque_sp) {
-    sb_error.SetErrorString("invalid debugger");
+    sb_error = Status::FromErrorString("invalid debugger");
     return sb_error;
   }
 
@@ -397,11 +400,11 @@ SBError SBDebugger::SetInputFile(SBFile file) {
 
   SBError error;
   if (!m_opaque_sp) {
-    error.ref().SetErrorString("invalid debugger");
+    error.ref() = Status::FromErrorString("invalid debugger");
     return error;
   }
   if (!file) {
-    error.ref().SetErrorString("invalid file");
+    error.ref() = Status::FromErrorString("invalid file");
     return error;
   }
   m_opaque_sp->SetInputFile(file.m_opaque_sp);
@@ -427,11 +430,11 @@ SBError SBDebugger::SetOutputFile(SBFile file) {
   LLDB_INSTRUMENT_VA(this, file);
   SBError error;
   if (!m_opaque_sp) {
-    error.ref().SetErrorString("invalid debugger");
+    error.ref() = Status::FromErrorString("invalid debugger");
     return error;
   }
   if (!file) {
-    error.ref().SetErrorString("invalid file");
+    error.ref() = Status::FromErrorString("invalid file");
     return error;
   }
   m_opaque_sp->SetOutputFile(file.m_opaque_sp);
@@ -452,11 +455,11 @@ SBError SBDebugger::SetErrorFile(SBFile file) {
   LLDB_INSTRUMENT_VA(this, file);
   SBError error;
   if (!m_opaque_sp) {
-    error.ref().SetErrorString("invalid debugger");
+    error.ref() = Status::FromErrorString("invalid debugger");
     return error;
   }
   if (!file) {
-    error.ref().SetErrorString("invalid file");
+    error.ref() = Status::FromErrorString("invalid file");
     return error;
   }
   m_opaque_sp->SetErrorFile(file.m_opaque_sp);
@@ -845,7 +848,7 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
     if (sb_error.Success())
       sb_target.SetSP(target_sp);
   } else {
-    sb_error.SetErrorString("invalid debugger");
+    sb_error = Status::FromErrorString("invalid debugger");
   }
 
   Log *log = GetLog(LLDBLog::API);
@@ -913,7 +916,8 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
             *m_opaque_sp, filename, arch, eLoadDependentsYes, platform_sp,
             target_sp);
       else
-        error.SetErrorStringWithFormat("invalid arch_cstr: %s", arch_cstr);
+        error = Status::FromErrorStringWithFormat("invalid arch_cstr: %s",
+                                                  arch_cstr);
     }
     if (error.Success())
       sb_target.SetSP(target_sp);
@@ -1301,7 +1305,7 @@ SBError SBDebugger::RunREPL(lldb::LanguageType language,
   if (m_opaque_sp)
     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
   else
-    error.SetErrorString("invalid debugger");
+    error = Status::FromErrorString("invalid debugger");
   return error;
 }
 
@@ -1352,8 +1356,8 @@ SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
                                           var_name, value);
   } else {
-    error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
-                                   debugger_instance_name);
+    error = Status::FromErrorStringWithFormat(
+        "invalid debugger instance name '%s'", debugger_instance_name);
   }
   if (error.Fail())
     sb_error.SetError(error);
@@ -1521,12 +1525,12 @@ SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
       if (PlatformSP platform_sp = platforms.GetOrCreate(platform_name_cstr))
         platforms.SetSelectedPlatform(platform_sp);
       else
-        sb_error.ref().SetErrorString("platform not found");
+        sb_error.ref() = Status::FromErrorString("platform not found");
     } else {
-      sb_error.ref().SetErrorString("invalid platform name");
+      sb_error.ref() = Status::FromErrorString("invalid platform name");
     }
   } else {
-    sb_error.ref().SetErrorString("invalid debugger");
+    sb_error.ref() = Status::FromErrorString("invalid debugger");
   }
   return sb_error;
 }
diff --git a/lldb/source/API/SBError.cpp b/lldb/source/API/SBError.cpp
index 2eb9e92..30d9ccc 100644
--- a/lldb/source/API/SBError.cpp
+++ b/lldb/source/API/SBError.cpp
@@ -11,6 +11,7 @@
 #include "lldb/API/SBStream.h"
 #include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/VASPrintf.h"
 
 #include <cstdarg>
 
@@ -107,7 +108,7 @@ void SBError::SetError(uint32_t err, ErrorType type) {
   LLDB_INSTRUMENT_VA(this, err, type);
 
   CreateIfNeeded();
-  m_opaque_up->SetError(err, type);
+  *m_opaque_up = Status(err, type);
 }
 
 void SBError::SetError(const Status &lldb_error) {
@@ -119,30 +120,36 @@ void SBError::SetErrorToErrno() {
   LLDB_INSTRUMENT_VA(this);
 
   CreateIfNeeded();
-  m_opaque_up->SetErrorToErrno();
+  *m_opaque_up = Status::FromErrno();
 }
 
 void SBError::SetErrorToGenericError() {
   LLDB_INSTRUMENT_VA(this);
 
   CreateIfNeeded();
-  m_opaque_up->SetErrorToGenericError();
+  *m_opaque_up = Status(std::string("generic error"));
 }
 
 void SBError::SetErrorString(const char *err_str) {
   LLDB_INSTRUMENT_VA(this, err_str);
 
   CreateIfNeeded();
-  m_opaque_up->SetErrorString(err_str);
+  *m_opaque_up = Status::FromErrorString(err_str);
 }
 
 int SBError::SetErrorStringWithFormat(const char *format, ...) {
   CreateIfNeeded();
+  std::string string;
   va_list args;
   va_start(args, format);
-  int num_chars = m_opaque_up->SetErrorStringWithVarArg(format, args);
+  if (format != nullptr && format[0]) {
+    llvm::SmallString<1024> buf;
+    VASprintf(buf, format, args);
+    string = std::string(buf.str());
+    *m_opaque_up = Status(std::move(string));
+  }
   va_end(args);
-  return num_chars;
+  return string.size();
 }
 
 bool SBError::IsValid() const {
diff --git a/lldb/source/API/SBFile.cpp b/lldb/source/API/SBFile.cpp
index 0db859c3..6237087 100644
--- a/lldb/source/API/SBFile.cpp
+++ b/lldb/source/API/SBFile.cpp
@@ -59,7 +59,7 @@ SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
 
   SBError error;
   if (!m_opaque_sp) {
-    error.SetErrorString("invalid SBFile");
+    error = Status::FromErrorString("invalid SBFile");
     *bytes_read = 0;
   } else {
     Status status = m_opaque_sp->Read(buf, num_bytes);
@@ -75,7 +75,7 @@ SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
 
   SBError error;
   if (!m_opaque_sp) {
-    error.SetErrorString("invalid SBFile");
+    error = Status::FromErrorString("invalid SBFile");
     *bytes_written = 0;
   } else {
     Status status = m_opaque_sp->Write(buf, num_bytes);
@@ -90,7 +90,7 @@ SBError SBFile::Flush() {
 
   SBError error;
   if (!m_opaque_sp) {
-    error.SetErrorString("invalid SBFile");
+    error = Status::FromErrorString("invalid SBFile");
   } else {
     Status status = m_opaque_sp->Flush();
     error.SetError(status);
diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp
index 2689ecb..b1360e8 100644
--- a/lldb/source/API/SBFrame.cpp
+++ b/lldb/source/API/SBFrame.cpp
@@ -1031,8 +1031,8 @@ SBValue SBFrame::EvaluateExpression(const char *expr) {
     return EvaluateExpression(expr, options);
   } else {
     Status error;
-    error.SetErrorString("can't evaluate expressions when the "
-                           "process is running.");
+    error = Status::FromErrorString("can't evaluate expressions when the "
+                                    "process is running.");
     ValueObjectSP error_val_sp = ValueObjectConstResult::Create(nullptr, error);
     result.SetSP(error_val_sp, false);
   }
@@ -1127,14 +1127,14 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
       }
     } else {
       Status error;
-      error.SetErrorString("can't evaluate expressions when the "
-                           "process is running.");
+      error = Status::FromErrorString("can't evaluate expressions when the "
+                                      "process is running.");
       expr_value_sp = ValueObjectConstResult::Create(nullptr, error);
       expr_result.SetSP(expr_value_sp, false);
     }
   } else {
       Status error;
-      error.SetErrorString("sbframe object is not valid.");
+      error = Status::FromErrorString("sbframe object is not valid.");
       expr_value_sp = ValueObjectConstResult::Create(nullptr, error);
       expr_result.SetSP(expr_value_sp, false);
   }
diff --git a/lldb/source/API/SBPlatform.cpp b/lldb/source/API/SBPlatform.cpp
index 3623fd3..2f0f925 100644
--- a/lldb/source/API/SBPlatform.cpp
+++ b/lldb/source/API/SBPlatform.cpp
@@ -386,7 +386,7 @@ SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
     args.AppendArgument(connect_options.GetURL());
     sb_error.ref() = platform_sp->ConnectRemote(args);
   } else {
-    sb_error.SetErrorString("invalid platform");
+    sb_error = Status::FromErrorString("invalid platform");
   }
   return sb_error;
 }
@@ -503,7 +503,7 @@ SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
   if (platform_sp) {
     sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());
   } else {
-    sb_error.SetErrorString("invalid platform");
+    sb_error = Status::FromErrorString("invalid platform");
   }
   return sb_error;
 }
@@ -523,10 +523,8 @@ SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
       return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
     }
 
-    Status error;
-    error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
-                                   src.ref().GetPath().c_str());
-    return error;
+    return Status::FromErrorStringWithFormat(
+        "'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
   });
 }
 
@@ -537,8 +535,8 @@ SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
       return platform_sp->Install(src.ref(), dst.ref());
 
     Status error;
-    error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
-                                   src.ref().GetPath().c_str());
+    error = Status::FromErrorStringWithFormat(
+        "'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
     return error;
   });
 }
@@ -549,7 +547,7 @@ SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
       [&](const lldb::PlatformSP &platform_sp) {
         const char *command = shell_command.GetCommand();
         if (!command)
-          return Status("invalid shell command (empty)");
+          return Status::FromErrorString("invalid shell command (empty)");
 
         if (shell_command.GetWorkingDirectory() == nullptr) {
           std::string platform_working_dir =
@@ -592,11 +590,11 @@ SBProcess SBPlatform::Attach(SBAttachInfo &attach_info,
       return SBProcess(process_sp);
     }
 
-    error.SetErrorString("not connected");
+    error = Status::FromErrorString("not connected");
     return {};
   }
 
-  error.SetErrorString("invalid platform");
+  error = Status::FromErrorString("invalid platform");
   return {};
 }
 
@@ -606,11 +604,11 @@ SBProcessInfoList SBPlatform::GetAllProcesses(SBError &error) {
       ProcessInstanceInfoList list = platform_sp->GetAllProcesses();
       return SBProcessInfoList(list);
     }
-    error.SetErrorString("not connected");
+    error = Status::FromErrorString("not connected");
     return {};
   }
 
-  error.SetErrorString("invalid platform");
+  error = Status::FromErrorString("invalid platform");
   return {};
 }
 
@@ -629,9 +627,9 @@ SBError SBPlatform::ExecuteConnected(
     if (platform_sp->IsConnected())
       sb_error.ref() = func(platform_sp);
     else
-      sb_error.SetErrorString("not connected");
+      sb_error = Status::FromErrorString("not connected");
   } else
-    sb_error.SetErrorString("invalid platform");
+    sb_error = Status::FromErrorString("invalid platform");
 
   return sb_error;
 }
@@ -645,7 +643,7 @@ SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
     sb_error.ref() =
         platform_sp->MakeDirectory(FileSpec(path), file_permissions);
   } else {
-    sb_error.SetErrorString("invalid platform");
+    sb_error = Status::FromErrorString("invalid platform");
   }
   return sb_error;
 }
@@ -672,7 +670,7 @@ SBError SBPlatform::SetFilePermissions(const char *path,
     sb_error.ref() =
         platform_sp->SetFilePermissions(FileSpec(path), file_permissions);
   } else {
-    sb_error.SetErrorString("invalid platform");
+    sb_error = Status::FromErrorString("invalid platform");
   }
   return sb_error;
 }
diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
index b88f897..3eed51f 100644
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -152,10 +152,11 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
         launch_info.GetEnvironment() = Environment(envp);
       error.SetError(process_sp->Launch(launch_info));
     } else {
-      error.SetErrorString("must be in eStateConnected to call RemoteLaunch");
+      error = Status::FromErrorString(
+          "must be in eStateConnected to call RemoteLaunch");
     }
   } else {
-    error.SetErrorString("unable to attach pid");
+    error = Status::FromErrorString("unable to attach pid");
   }
 
   return error.Success();
@@ -174,11 +175,11 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
       attach_info.SetProcessID(pid);
       error.SetError(process_sp->Attach(attach_info));
     } else {
-      error.SetErrorString(
+      error = Status::FromErrorString(
           "must be in eStateConnected to call RemoteAttachToProcessWithID");
     }
   } else {
-    error.SetErrorString("unable to attach pid");
+    error = Status::FromErrorString("unable to attach pid");
   }
 
   return error.Success();
@@ -577,7 +578,7 @@ SBError SBProcess::Continue() {
     else
       sb_error.ref() = process_sp->ResumeSynchronous(nullptr);
   } else
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
 
   return sb_error;
 }
@@ -592,7 +593,7 @@ SBError SBProcess::Destroy() {
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Destroy(false));
   } else
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
 
   return sb_error;
 }
@@ -607,7 +608,7 @@ SBError SBProcess::Stop() {
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Halt());
   } else
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
 
   return sb_error;
 }
@@ -622,7 +623,7 @@ SBError SBProcess::Kill() {
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Destroy(true));
   } else
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
 
   return sb_error;
 }
@@ -645,7 +646,7 @@ SBError SBProcess::Detach(bool keep_stopped) {
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Detach(keep_stopped));
   } else
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
 
   return sb_error;
 }
@@ -660,7 +661,7 @@ SBError SBProcess::Signal(int signo) {
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Signal(signo));
   } else
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
 
   return sb_error;
 }
@@ -819,12 +820,12 @@ lldb::SBAddressRangeList SBProcess::FindRangesInMemory(
 
   ProcessSP process_sp(GetSP());
   if (!process_sp) {
-    error.SetErrorString("SBProcess is invalid");
+    error = Status::FromErrorString("SBProcess is invalid");
     return matches;
   }
   Process::StopLocker stop_locker;
   if (!stop_locker.TryLock(&process_sp->GetRunLock())) {
-    error.SetErrorString("process is running");
+    error = Status::FromErrorString("process is running");
     return matches;
   }
   std::lock_guard<std::recursive_mutex> guard(
@@ -843,13 +844,13 @@ lldb::addr_t SBProcess::FindInMemory(const void *buf, uint64_t size,
   ProcessSP process_sp(GetSP());
 
   if (!process_sp) {
-    error.SetErrorString("SBProcess is invalid");
+    error = Status::FromErrorString("SBProcess is invalid");
     return LLDB_INVALID_ADDRESS;
   }
 
   Process::StopLocker stop_locker;
   if (!stop_locker.TryLock(&process_sp->GetRunLock())) {
-    error.SetErrorString("process is running");
+    error = Status::FromErrorString("process is running");
     return LLDB_INVALID_ADDRESS;
   }
 
@@ -864,7 +865,7 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
   LLDB_INSTRUMENT_VA(this, addr, dst, dst_len, sb_error);
 
   if (!dst) {
-    sb_error.SetErrorStringWithFormat(
+    sb_error = Status::FromErrorStringWithFormat(
         "no buffer provided to read %zu bytes into", dst_len);
     return 0;
   }
@@ -880,10 +881,10 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
           process_sp->GetTarget().GetAPIMutex());
       bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
 
   return bytes_read;
@@ -903,10 +904,10 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
       bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size,
                                                      sb_error.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
   return bytes_read;
 }
@@ -925,10 +926,10 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
       value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
                                                         sb_error.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
   return value;
 }
@@ -946,10 +947,10 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
           process_sp->GetTarget().GetAPIMutex());
       ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
   return ptr;
 }
@@ -970,7 +971,7 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
       bytes_written =
           process_sp->WriteMemory(addr, src, src_len, sb_error.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   }
 
@@ -1045,10 +1046,11 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
     if (actual_num) {
       num = *actual_num;
     } else {
-      sb_error.SetErrorString("Unable to determine number of watchpoints");
+      sb_error =
+          Status::FromErrorString("Unable to determine number of watchpoints");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
   return num;
 }
@@ -1075,10 +1077,10 @@ uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
       return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec,
                                     *sb_remote_image_spec, sb_error.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("process is invalid");
+    sb_error = Status::FromErrorString("process is invalid");
   }
   return LLDB_INVALID_IMAGE_TOKEN;
 }
@@ -1109,10 +1111,10 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
         loaded_path = loaded_spec;
       return token;
     } else {
-      error.SetErrorString("process is running");
+      error = Status::FromErrorString("process is running");
     }
   } else {
-    error.SetErrorString("process is invalid");
+    error = Status::FromErrorString("process is invalid");
   }
 
   return LLDB_INVALID_IMAGE_TOKEN;
@@ -1132,10 +1134,10 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
       sb_error.SetError(
           platform_sp->UnloadImage(process_sp.get(), image_token));
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else
-    sb_error.SetErrorString("invalid process");
+    sb_error = Status::FromErrorString("invalid process");
   return sb_error;
 }
 
@@ -1151,10 +1153,10 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
           process_sp->GetTarget().GetAPIMutex());
       sb_error.SetError(process_sp->SendEventData(event_data));
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else
-    sb_error.SetErrorString("invalid process");
+    sb_error = Status::FromErrorString("invalid process");
   return sb_error;
 }
 
@@ -1243,7 +1245,7 @@ lldb::SBError SBProcess::SaveCore(SBSaveCoreOptions &options) {
   lldb::SBError error;
   ProcessSP process_sp(GetSP());
   if (!process_sp) {
-    error.SetErrorString("SBProcess is invalid");
+    error = Status::FromErrorString("SBProcess is invalid");
     return error;
   }
 
@@ -1251,7 +1253,7 @@ lldb::SBError SBProcess::SaveCore(SBSaveCoreOptions &options) {
       process_sp->GetTarget().GetAPIMutex());
 
   if (process_sp->GetState() != eStateStopped) {
-    error.SetErrorString("the process is not stopped");
+    error = Status::FromErrorString("the process is not stopped");
     return error;
   }
 
@@ -1276,10 +1278,10 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
       sb_error.ref() =
           process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
   return sb_error;
 }
@@ -1429,10 +1431,10 @@ lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
           process_sp->GetTarget().GetAPIMutex());
       addr = process_sp->AllocateMemory(size, permissions, sb_error.ref());
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
   return addr;
 }
@@ -1450,10 +1452,10 @@ lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
       Status error = process_sp->DeallocateMemory(ptr);
       sb_error.SetError(error);
     } else {
-      sb_error.SetErrorString("process is running");
+      sb_error = Status::FromErrorString("process is running");
     }
   } else {
-    sb_error.SetErrorString("SBProcess is invalid");
+    sb_error = Status::FromErrorString("SBProcess is invalid");
   }
   return sb_error;
 }
diff --git a/lldb/source/API/SBStructuredData.cpp b/lldb/source/API/SBStructuredData.cpp
index 78afdc6..801ebf4 100644
--- a/lldb/source/API/SBStructuredData.cpp
+++ b/lldb/source/API/SBStructuredData.cpp
@@ -92,7 +92,7 @@ lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
   };
 
   if (!json_obj || llvm::is_contained(unsupported_type, json_obj->GetType()))
-    error.SetErrorString("Invalid Syntax");
+    error = Status::FromErrorString("Invalid Syntax");
   return error;
 }
 
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp
index 2c33629..e927cb8 100644
--- a/lldb/source/API/SBTarget.cpp
+++ b/lldb/source/API/SBTarget.cpp
@@ -85,8 +85,9 @@ static Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
       // listener, so if a valid listener is supplied, we need to error out to
       // let the client know.
       if (attach_info.GetListener())
-        return Status("process is connected and already has a listener, pass "
-                      "empty listener");
+        return Status::FromErrorString(
+            "process is connected and already has a listener, pass "
+            "empty listener");
     }
   }
 
@@ -452,7 +453,7 @@ lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
         if (platform_sp->GetProcessInfo(attach_pid, instance_info)) {
           attach_info.SetUserID(instance_info.GetEffectiveUserID());
         } else {
-          error.ref().SetErrorStringWithFormat(
+          error.ref() = Status::FromErrorStringWithFormat(
               "no process found with process ID %" PRIu64, attach_pid);
           return sb_process;
         }
@@ -1655,7 +1656,7 @@ SBError SBTarget::SetLabel(const char *label) {
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return Status("Couldn't get internal target object.");
+    return Status::FromErrorString("Couldn't get internal target object.");
 
   return Status(target_sp->SetLabel(label));
 }
@@ -2323,8 +2324,8 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
           target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
         } else {
           Status error;
-          error.SetErrorString("can't evaluate expressions when the "
-                               "process is running.");
+          error = Status::FromErrorString("can't evaluate expressions when the "
+                                          "process is running.");
           expr_value_sp = ValueObjectConstResult::Create(nullptr, error);
         }
       } else {
diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp
index 140a292..9286813 100644
--- a/lldb/source/API/SBThread.cpp
+++ b/lldb/source/API/SBThread.cpp
@@ -499,13 +499,13 @@ SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
 
   Process *process = exe_ctx.GetProcessPtr();
   if (!process) {
-    sb_error.SetErrorString("No process in SBThread::ResumeNewPlan");
+    sb_error = Status::FromErrorString("No process in SBThread::ResumeNewPlan");
     return sb_error;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
   if (!thread) {
-    sb_error.SetErrorString("No thread in SBThread::ResumeNewPlan");
+    sb_error = Status::FromErrorString("No thread in SBThread::ResumeNewPlan");
     return sb_error;
   }
 
@@ -541,7 +541,7 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
     return;
   }
 
@@ -588,7 +588,7 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line,
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
     return;
   }
 
@@ -625,7 +625,7 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line,
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
-    error.SetErrorString(new_plan_status.AsCString());
+    error = Status::FromErrorString(new_plan_status.AsCString());
 }
 
 void SBThread::StepOut() {
@@ -642,7 +642,7 @@ void SBThread::StepOut(SBError &error) {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
     return;
   }
 
@@ -660,7 +660,7 @@ void SBThread::StepOut(SBError &error) {
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
-    error.SetErrorString(new_plan_status.AsCString());
+    error = Status::FromErrorString(new_plan_status.AsCString());
 }
 
 void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
@@ -677,14 +677,14 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!sb_frame.IsValid()) {
-    error.SetErrorString("passed invalid SBFrame object");
+    error = Status::FromErrorString("passed invalid SBFrame object");
     return;
   }
 
   StackFrameSP frame_sp(sb_frame.GetFrameSP());
 
   if (!exe_ctx.HasThreadScope()) {
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
     return;
   }
 
@@ -692,7 +692,7 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
   bool stop_other_threads = false;
   Thread *thread = exe_ctx.GetThreadPtr();
   if (sb_frame.GetThread().GetThreadID() != thread->GetID()) {
-    error.SetErrorString("passed a frame from another thread");
+    error = Status::FromErrorString("passed a frame from another thread");
     return;
   }
 
@@ -704,7 +704,7 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
-    error.SetErrorString(new_plan_status.AsCString());
+    error = Status::FromErrorString(new_plan_status.AsCString());
 }
 
 void SBThread::StepInstruction(bool step_over) {
@@ -721,7 +721,7 @@ void SBThread::StepInstruction(bool step_over, SBError &error) {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
     return;
   }
 
@@ -733,7 +733,7 @@ void SBThread::StepInstruction(bool step_over, SBError &error) {
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
-    error.SetErrorString(new_plan_status.AsCString());
+    error = Status::FromErrorString(new_plan_status.AsCString());
 }
 
 void SBThread::RunToAddress(lldb::addr_t addr) {
@@ -750,7 +750,7 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
     return;
   }
 
@@ -768,7 +768,7 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
-    error.SetErrorString(new_plan_status.AsCString());
+    error = Status::FromErrorString(new_plan_status.AsCString());
 }
 
 SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
@@ -788,7 +788,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
     Thread *thread = exe_ctx.GetThreadPtr();
 
     if (line == 0) {
-      sb_error.SetErrorString("invalid line argument");
+      sb_error = Status::FromErrorString("invalid line argument");
       return sb_error;
     }
 
@@ -804,7 +804,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
 
     SymbolContext frame_sc;
     if (!frame_sp) {
-      sb_error.SetErrorString("no valid frames in thread to step");
+      sb_error = Status::FromErrorString("no valid frames in thread to step");
       return sb_error;
     }
 
@@ -814,7 +814,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
         eSymbolContextLineEntry | eSymbolContextSymbol);
 
     if (frame_sc.comp_unit == nullptr) {
-      sb_error.SetErrorStringWithFormat(
+      sb_error = Status::FromErrorStringWithFormat(
           "frame %u doesn't have debug information", frame_sp->GetFrameIndex());
       return sb_error;
     }
@@ -827,7 +827,8 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
       if (frame_sc.line_entry.IsValid())
         step_file_spec = frame_sc.line_entry.GetFile();
       else {
-        sb_error.SetErrorString("invalid file argument or no file for frame");
+        sb_error = Status::FromErrorString(
+            "invalid file argument or no file for frame");
         return sb_error;
       }
     }
@@ -865,10 +866,11 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
     if (step_over_until_addrs.empty()) {
       if (all_in_function) {
         step_file_spec.GetPath(path, sizeof(path));
-        sb_error.SetErrorStringWithFormat("No line entries for %s:%u", path,
-                                          line);
+        sb_error = Status::FromErrorStringWithFormat(
+            "No line entries for %s:%u", path, line);
       } else
-        sb_error.SetErrorString("step until target not in current function");
+        sb_error = Status::FromErrorString(
+            "step until target not in current function");
     } else {
       Status new_plan_status;
       ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepUntil(
@@ -879,10 +881,10 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
       if (new_plan_status.Success())
         sb_error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
       else
-        sb_error.SetErrorString(new_plan_status.AsCString());
+        sb_error = Status::FromErrorString(new_plan_status.AsCString());
     }
   } else {
-    sb_error.SetErrorString("this SBThread object is invalid");
+    sb_error = Status::FromErrorString("this SBThread object is invalid");
   }
   return sb_error;
 }
@@ -913,7 +915,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
     return error;
   }
 
@@ -925,7 +927,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
       false, script_class_name, obj_sp, false, new_plan_status);
 
   if (new_plan_status.Fail()) {
-    error.SetErrorString(new_plan_status.AsCString());
+    error = Status::FromErrorString(new_plan_status.AsCString());
     return error;
   }
 
@@ -935,7 +937,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
-    error.SetErrorString(new_plan_status.AsCString());
+    error = Status::FromErrorString(new_plan_status.AsCString());
 
   return error;
 }
@@ -949,7 +951,7 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
-    sb_error.SetErrorString("this SBThread object is invalid");
+    sb_error = Status::FromErrorString("this SBThread object is invalid");
     return sb_error;
   }
 
@@ -1015,10 +1017,10 @@ bool SBThread::Suspend(SBError &error) {
       exe_ctx.GetThreadPtr()->SetResumeState(eStateSuspended);
       result = true;
     } else {
-      error.SetErrorString("process is running");
+      error = Status::FromErrorString("process is running");
     }
   } else
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
   return result;
 }
 
@@ -1043,10 +1045,10 @@ bool SBThread::Resume(SBError &error) {
       exe_ctx.GetThreadPtr()->SetResumeState(eStateRunning, override_suspend);
       result = true;
     } else {
-      error.SetErrorString("process is running");
+      error = Status::FromErrorString("process is running");
     }
   } else
-    error.SetErrorString("this SBThread object is invalid");
+    error = Status::FromErrorString("this SBThread object is invalid");
   return result;
 }
 
@@ -1245,7 +1247,7 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format,
 
   SBError error;
   if (!format) {
-    error.SetErrorString("The provided SBFormat object is invalid");
+    error = Status::FromErrorString("The provided SBFormat object is invalid");
     return error;
   }
 
@@ -1259,7 +1261,7 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format,
     }
   }
 
-  error.SetErrorStringWithFormat(
+  error = Status::FromErrorStringWithFormat(
       "It was not possible to generate a thread description with the given "
       "format string '%s'",
       format.GetFormatEntrySP()->string.c_str());
diff --git a/lldb/source/API/SBTrace.cpp b/lldb/source/API/SBTrace.cpp
index da31d17..c8a2b2d 100644
--- a/lldb/source/API/SBTrace.cpp
+++ b/lldb/source/API/SBTrace.cpp
@@ -36,7 +36,7 @@ SBTrace SBTrace::LoadTraceFromFile(SBError &error, SBDebugger &debugger,
       debugger.ref(), trace_description_file.ref());
 
   if (!trace_or_err) {
-    error.SetErrorString(toString(trace_or_err.takeError()).c_str());
+    error = Status::FromErrorString(toString(trace_or_err.takeError()).c_str());
     return SBTrace();
   }
 
@@ -47,11 +47,11 @@ SBTraceCursor SBTrace::CreateNewCursor(SBError &error, SBThread &thread) {
   LLDB_INSTRUMENT_VA(this, error, thread);
 
   if (!m_opaque_sp) {
-    error.SetErrorString("error: invalid trace");
+    error = Status::FromErrorString("error: invalid trace");
     return SBTraceCursor();
   }
   if (!thread.get()) {
-    error.SetErrorString("error: invalid thread");
+    error = Status::FromErrorString("error: invalid thread");
     return SBTraceCursor();
   }
 
@@ -59,7 +59,8 @@ SBTraceCursor SBTrace::CreateNewCursor(SBError &error, SBThread &thread) {
           m_opaque_sp->CreateNewCursor(*thread.get())) {
     return SBTraceCursor(std::move(*trace_cursor_sp));
   } else {
-    error.SetErrorString(llvm::toString(trace_cursor_sp.takeError()).c_str());
+    error = Status::FromErrorString(
+        llvm::toString(trace_cursor_sp.takeError()).c_str());
     return SBTraceCursor();
   }
 }
@@ -72,12 +73,13 @@ SBFileSpec SBTrace::SaveToDisk(SBError &error, const SBFileSpec &bundle_dir,
   SBFileSpec file_spec;
 
   if (!m_opaque_sp)
-    error.SetErrorString("error: invalid trace");
+    error = Status::FromErrorString("error: invalid trace");
   else if (Expected<FileSpec> desc_file =
                m_opaque_sp->SaveToDisk(bundle_dir.ref(), compact))
     file_spec.SetFileSpec(*desc_file);
   else
-    error.SetErrorString(llvm::toString(desc_file.takeError()).c_str());
+    error =
+        Status::FromErrorString(llvm::toString(desc_file.takeError()).c_str());
 
   return file_spec;
 }
@@ -94,10 +96,10 @@ SBError SBTrace::Start(const SBStructuredData &configuration) {
   LLDB_INSTRUMENT_VA(this, configuration);
   SBError error;
   if (!m_opaque_sp)
-    error.SetErrorString("error: invalid trace");
+    error = Status::FromErrorString("error: invalid trace");
   else if (llvm::Error err =
                m_opaque_sp->Start(configuration.m_impl_up->GetObjectSP()))
-    error.SetErrorString(llvm::toString(std::move(err)).c_str());
+    error = Status::FromErrorString(llvm::toString(std::move(err)).c_str());
   return error;
 }
 
@@ -107,12 +109,12 @@ SBError SBTrace::Start(const SBThread &thread,
 
   SBError error;
   if (!m_opaque_sp)
-    error.SetErrorString("error: invalid trace");
+    error = Status::FromErrorString("error: invalid trace");
   else {
     if (llvm::Error err =
             m_opaque_sp->Start(std::vector<lldb::tid_t>{thread.GetThreadID()},
                                configuration.m_impl_up->GetObjectSP()))
-      error.SetErrorString(llvm::toString(std::move(err)).c_str());
+      error = Status::FromErrorString(llvm::toString(std::move(err)).c_str());
   }
 
   return error;
@@ -122,9 +124,9 @@ SBError SBTrace::Stop() {
   LLDB_INSTRUMENT_VA(this);
   SBError error;
   if (!m_opaque_sp)
-    error.SetErrorString("error: invalid trace");
+    error = Status::FromErrorString("error: invalid trace");
   else if (llvm::Error err = m_opaque_sp->Stop())
-    error.SetErrorString(llvm::toString(std::move(err)).c_str());
+    error = Status::FromErrorString(llvm::toString(std::move(err)).c_str());
   return error;
 }
 
@@ -132,9 +134,9 @@ SBError SBTrace::Stop(const SBThread &thread) {
   LLDB_INSTRUMENT_VA(this, thread);
   SBError error;
   if (!m_opaque_sp)
-    error.SetErrorString("error: invalid trace");
+    error = Status::FromErrorString("error: invalid trace");
   else if (llvm::Error err = m_opaque_sp->Stop({thread.GetThreadID()}))
-    error.SetErrorString(llvm::toString(std::move(err)).c_str());
+    error = Status::FromErrorString(llvm::toString(std::move(err)).c_str());
   return error;
 }
 
diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index 9667048..df0e82b 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -107,7 +107,7 @@ public:
                             std::unique_lock<std::recursive_mutex> &lock,
                             Status &error) {
     if (!m_valobj_sp) {
-      error.SetErrorString("invalid value object");
+      error = Status::FromErrorString("invalid value object");
       return m_valobj_sp;
     }
 
@@ -128,7 +128,7 @@ public:
       // We don't allow people to play around with ValueObject if the process
       // is running. If you want to look at values, pause the process, then
       // look.
-      error.SetErrorString("process must be stopped.");
+      error = Status::FromErrorString("process must be stopped.");
       return ValueObjectSP();
     }
 
@@ -145,7 +145,7 @@ public:
     }
 
     if (!value_sp)
-      error.SetErrorString("invalid value object");
+      error = Status::FromErrorString("invalid value object");
     if (!m_name.IsEmpty())
       value_sp->SetName(m_name);
 
@@ -272,8 +272,8 @@ SBError SBValue::GetError() {
   if (value_sp)
     sb_error.SetError(value_sp->GetError());
   else
-    sb_error.SetErrorStringWithFormat("error: %s",
-                                      locker.GetError().AsCString());
+    sb_error = Status::FromErrorStringWithFormat("error: %s",
+                                                 locker.GetError().AsCString());
 
   return sb_error;
 }
@@ -467,8 +467,8 @@ bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
   if (value_sp) {
     success = value_sp->SetValueFromCString(value_str, error.ref());
   } else
-    error.SetErrorStringWithFormat("Could not get value: %s",
-                                   locker.GetError().AsCString());
+    error = Status::FromErrorStringWithFormat("Could not get value: %s",
+                                              locker.GetError().AsCString());
 
   return success;
 }
@@ -876,11 +876,11 @@ int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
     uint64_t ret_val = fail_value;
     ret_val = value_sp->GetValueAsSigned(fail_value, &success);
     if (!success)
-      error.SetErrorString("could not resolve value");
+      error = Status::FromErrorString("could not resolve value");
     return ret_val;
   } else
-    error.SetErrorStringWithFormat("could not get SBValue: %s",
-                                   locker.GetError().AsCString());
+    error = Status::FromErrorStringWithFormat("could not get SBValue: %s",
+                                              locker.GetError().AsCString());
 
   return fail_value;
 }
@@ -896,11 +896,11 @@ uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
     uint64_t ret_val = fail_value;
     ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
     if (!success)
-      error.SetErrorString("could not resolve value");
+      error = Status::FromErrorString("could not resolve value");
     return ret_val;
   } else
-    error.SetErrorStringWithFormat("could not get SBValue: %s",
-                                   locker.GetError().AsCString());
+    error = Status::FromErrorStringWithFormat("could not get SBValue: %s",
+                                              locker.GetError().AsCString());
 
   return fail_value;
 }
@@ -1079,7 +1079,7 @@ lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
   if (!m_opaque_sp || (!m_opaque_sp->IsValid()
       && (m_opaque_sp->GetRootSP()
           && !m_opaque_sp->GetRootSP()->GetError().Fail()))) {
-    locker.GetError().SetErrorString("No value");
+    locker.GetError() = Status::FromErrorString("No value");
     return ValueObjectSP();
   }
   return locker.GetLockedSP(*m_opaque_sp.get());
@@ -1384,7 +1384,7 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) {
     DataExtractor *data_extractor = data.get();
 
     if (!data_extractor) {
-      error.SetErrorString("No data to set");
+      error = Status::FromErrorString("No data to set");
       ret = false;
     } else {
       Status set_error;
@@ -1392,13 +1392,13 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) {
       value_sp->SetData(*data_extractor, set_error);
 
       if (!set_error.Success()) {
-        error.SetErrorStringWithFormat("Couldn't set data: %s",
-                                       set_error.AsCString());
+        error = Status::FromErrorStringWithFormat("Couldn't set data: %s",
+                                                  set_error.AsCString());
         ret = false;
       }
     }
   } else {
-    error.SetErrorStringWithFormat(
+    error = Status::FromErrorStringWithFormat(
         "Couldn't set data: could not get SBValue: %s",
         locker.GetError().AsCString());
     ret = false;
@@ -1491,10 +1491,11 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
       }
     }
   } else if (target_sp) {
-    error.SetErrorStringWithFormat("could not get SBValue: %s",
-                                   locker.GetError().AsCString());
+    error = Status::FromErrorStringWithFormat("could not get SBValue: %s",
+                                              locker.GetError().AsCString());
   } else {
-    error.SetErrorString("could not set watchpoint, a target is required");
+    error = Status::FromErrorString(
+        "could not set watchpoint, a target is required");
   }
 
   return sb_watchpoint;