Rename Error -> Status.

This renames the LLDB error class to Status, as discussed
on the lldb-dev mailing list.

A change of this magnitude cannot easily be done without
find and replace, but that has potential to catch unwanted
occurrences of common strings such as "Error".  Every effort
was made to find all the obvious things such as the word "Error"
appearing in a string, etc, but it's possible there are still
some lingering occurences left around.  Hopefully nothing too
serious.

llvm-svn: 302872

10 files changed, 78 insertions, 77 deletions

diff --git a/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.cpp b/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.cpp
index b79359ba966..ac9e65c3c10 100644
--- a/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.cpp
+++ b/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.cpp
@@ -19,9 +19,9 @@
 #include "lldb/Host/windows/ProcessLauncherWindows.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 
@@ -60,11 +60,11 @@ DebuggerThread::DebuggerThread(DebugDelegateSP debug_delegate)
 
 DebuggerThread::~DebuggerThread() { ::CloseHandle(m_debugging_ended_event); }
 
-Error DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info) {
+Status DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   LLDB_LOG(log, "launching '{0}'", launch_info.GetExecutableFile().GetPath());
 
-  Error error;
+  Status error;
   DebugLaunchContext *context = new DebugLaunchContext(this, launch_info);
   HostThread slave_thread(ThreadLauncher::LaunchThread(
       "lldb.plugin.process-windows.slave[?]", DebuggerThreadLaunchRoutine,
@@ -76,12 +76,12 @@ Error DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info) {
   return error;
 }
 
-Error DebuggerThread::DebugAttach(lldb::pid_t pid,
-                                  const ProcessAttachInfo &attach_info) {
+Status DebuggerThread::DebugAttach(lldb::pid_t pid,
+                                   const ProcessAttachInfo &attach_info) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   LLDB_LOG(log, "attaching to '{0}'", pid);
 
-  Error error;
+  Status error;
   DebugAttachContext *context = new DebugAttachContext(this, pid, attach_info);
   HostThread slave_thread(ThreadLauncher::LaunchThread(
       "lldb.plugin.process-windows.slave[?]", DebuggerThreadAttachRoutine,
@@ -120,7 +120,7 @@ lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(
   LLDB_LOG(log, "preparing to launch '{0}' on background thread.",
            launch_info.GetExecutableFile().GetPath());
 
-  Error error;
+  Status error;
   ProcessLauncherWindows launcher;
   HostProcess process(launcher.LaunchProcess(launch_info, error));
   // If we couldn't create the process, notify waiters immediately.  Otherwise
@@ -152,7 +152,7 @@ lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(
            pid);
 
   if (!DebugActiveProcess((DWORD)pid)) {
-    Error error(::GetLastError(), eErrorTypeWin32);
+    Status error(::GetLastError(), eErrorTypeWin32);
     m_debug_delegate->OnDebuggerError(error, 0);
     return 0;
   }
@@ -167,8 +167,8 @@ lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(
   return 0;
 }
 
-Error DebuggerThread::StopDebugging(bool terminate) {
-  Error error;
+Status DebuggerThread::StopDebugging(bool terminate) {
+  Status error;
 
   lldb::pid_t pid = m_process.GetProcessId();
 
@@ -515,7 +515,7 @@ DebuggerThread::HandleRipEvent(const RIP_INFO &info, DWORD thread_id) {
   LLDB_LOG(log, "encountered error {0} (type={1}) in process {2} thread {3}",
            info.dwError, info.dwType, m_process.GetProcessId(), thread_id);
 
-  Error error(info.dwError, eErrorTypeWin32);
+  Status error(info.dwError, eErrorTypeWin32);
   m_debug_delegate->OnDebuggerError(error, info.dwType);
 
   return DBG_CONTINUE;
diff --git a/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.h b/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.h
index ef4b47bab8c..fcf36f7dec9 100644
--- a/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.h
+++ b/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.h
@@ -32,8 +32,8 @@ public:
   DebuggerThread(DebugDelegateSP debug_delegate);
   virtual ~DebuggerThread();
 
-  Error DebugLaunch(const ProcessLaunchInfo &launch_info);
-  Error DebugAttach(lldb::pid_t pid, const ProcessAttachInfo &attach_info);
+  Status DebugLaunch(const ProcessLaunchInfo &launch_info);
+  Status DebugAttach(lldb::pid_t pid, const ProcessAttachInfo &attach_info);
 
   HostProcess GetProcess() const { return m_process; }
   HostThread GetMainThread() const { return m_main_thread; }
@@ -41,7 +41,7 @@ public:
     return m_active_exception;
   }
 
-  Error StopDebugging(bool terminate);
+  Status StopDebugging(bool terminate);
 
   void ContinueAsyncException(ExceptionResult result);
 
diff --git a/lldb/source/Plugins/Process/Windows/Common/IDebugDelegate.h b/lldb/source/Plugins/Process/Windows/Common/IDebugDelegate.h
index e88e0ada053..73c285f1ecc 100644
--- a/lldb/source/Plugins/Process/Windows/Common/IDebugDelegate.h
+++ b/lldb/source/Plugins/Process/Windows/Common/IDebugDelegate.h
@@ -16,7 +16,7 @@
 #include <string>
 
 namespace lldb_private {
-class Error;
+class Status;
 class HostThread;
 
 //----------------------------------------------------------------------
@@ -39,7 +39,7 @@ public:
                          lldb::addr_t module_addr) = 0;
   virtual void OnUnloadDll(lldb::addr_t module_addr) = 0;
   virtual void OnDebugString(const std::string &string) = 0;
-  virtual void OnDebuggerError(const Error &error, uint32_t type) = 0;
+  virtual void OnDebuggerError(const Status &error, uint32_t type) = 0;
 };
 }
 
diff --git a/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.cpp b/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.cpp
index 600aef37250..92aa7e2678b 100644
--- a/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.cpp
+++ b/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.cpp
@@ -62,7 +62,7 @@ void LocalDebugDelegate::OnDebugString(const std::string &string) {
     process->OnDebugString(string);
 }
 
-void LocalDebugDelegate::OnDebuggerError(const Error &error, uint32_t type) {
+void LocalDebugDelegate::OnDebuggerError(const Status &error, uint32_t type) {
   if (ProcessWindowsSP process = GetProcessPointer())
     process->OnDebuggerError(error, type);
 }
diff --git a/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.h b/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.h
index 819854a1e63..2cb479ccce8 100644
--- a/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.h
+++ b/lldb/source/Plugins/Process/Windows/Common/LocalDebugDelegate.h
@@ -55,7 +55,7 @@ public:
                  lldb::addr_t module_addr) override;
   void OnUnloadDll(lldb::addr_t module_addr) override;
   void OnDebugString(const std::string &message) override;
-  void OnDebuggerError(const Error &error, uint32_t type) override;
+  void OnDebuggerError(const Status &error, uint32_t type) override;
 
 private:
   ProcessWindowsSP GetProcessPointer();
diff --git a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp
index 56a98a8eef6..a1c9cfaed41 100644
--- a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp
+++ b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp
@@ -87,7 +87,7 @@ public:
 
   ~ProcessWindowsData() { ::CloseHandle(m_initial_stop_event); }
 
-  Error m_launch_error;
+  Status m_launch_error;
   DebuggerThreadSP m_debugger;
   StopInfoSP m_pending_stop_info;
   HANDLE m_initial_stop_event = nullptr;
@@ -132,18 +132,18 @@ ProcessWindows::ProcessWindows(lldb::TargetSP target_sp,
 
 ProcessWindows::~ProcessWindows() {}
 
-size_t ProcessWindows::GetSTDOUT(char *buf, size_t buf_size, Error &error) {
+size_t ProcessWindows::GetSTDOUT(char *buf, size_t buf_size, Status &error) {
   error.SetErrorString("GetSTDOUT unsupported on Windows");
   return 0;
 }
 
-size_t ProcessWindows::GetSTDERR(char *buf, size_t buf_size, Error &error) {
+size_t ProcessWindows::GetSTDERR(char *buf, size_t buf_size, Status &error) {
   error.SetErrorString("GetSTDERR unsupported on Windows");
   return 0;
 }
 
 size_t ProcessWindows::PutSTDIN(const char *buf, size_t buf_size,
-                                Error &error) {
+                                Status &error) {
   error.SetErrorString("PutSTDIN unsupported on Windows");
   return 0;
 }
@@ -157,30 +157,30 @@ lldb_private::ConstString ProcessWindows::GetPluginName() {
 
 uint32_t ProcessWindows::GetPluginVersion() { return 1; }
 
-Error ProcessWindows::EnableBreakpointSite(BreakpointSite *bp_site) {
+Status ProcessWindows::EnableBreakpointSite(BreakpointSite *bp_site) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_BREAKPOINTS);
   LLDB_LOG(log, "bp_site = {0:x}, id={1}, addr={2:x}", bp_site,
            bp_site->GetID(), bp_site->GetLoadAddress());
 
-  Error error = EnableSoftwareBreakpoint(bp_site);
+  Status error = EnableSoftwareBreakpoint(bp_site);
   if (!error.Success())
     LLDB_LOG(log, "error: {0}", error);
   return error;
 }
 
-Error ProcessWindows::DisableBreakpointSite(BreakpointSite *bp_site) {
+Status ProcessWindows::DisableBreakpointSite(BreakpointSite *bp_site) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_BREAKPOINTS);
   LLDB_LOG(log, "bp_site = {0:x}, id={1}, addr={2:x}", bp_site,
            bp_site->GetID(), bp_site->GetLoadAddress());
 
-  Error error = DisableSoftwareBreakpoint(bp_site);
+  Status error = DisableSoftwareBreakpoint(bp_site);
 
   if (!error.Success())
     LLDB_LOG(log, "error: {0}", error);
   return error;
 }
 
-Error ProcessWindows::DoDetach(bool keep_stopped) {
+Status ProcessWindows::DoDetach(bool keep_stopped) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   DebuggerThreadSP debugger_thread;
   StateType private_state;
@@ -196,13 +196,13 @@ Error ProcessWindows::DoDetach(bool keep_stopped) {
     if (!m_session_data) {
       LLDB_LOG(log, "state = {0}, but there is no active session.",
                private_state);
-      return Error();
+      return Status();
     }
 
     debugger_thread = m_session_data->m_debugger;
   }
 
-  Error error;
+  Status error;
   if (private_state != eStateExited && private_state != eStateDetached) {
     LLDB_LOG(log, "detaching from process {0} while state = {1}.",
              debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(),
@@ -226,8 +226,8 @@ Error ProcessWindows::DoDetach(bool keep_stopped) {
   return error;
 }
 
-Error ProcessWindows::DoLaunch(Module *exe_module,
-                               ProcessLaunchInfo &launch_info) {
+Status ProcessWindows::DoLaunch(Module *exe_module,
+                                ProcessLaunchInfo &launch_info) {
   // Even though m_session_data is accessed here, it is before a debugger thread
   // has been
   // kicked off.  So there's no race conditions, and it shouldn't be necessary
@@ -235,7 +235,7 @@ Error ProcessWindows::DoLaunch(Module *exe_module,
   // the mutex.
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
-  Error result;
+  Status result;
   if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) {
     StreamString stream;
     stream.Printf("ProcessWindows unable to launch '%s'.  ProcessWindows can "
@@ -265,7 +265,7 @@ Error ProcessWindows::DoLaunch(Module *exe_module,
   }
 
   HostProcess process;
-  Error error = WaitForDebuggerConnection(debugger, process);
+  Status error = WaitForDebuggerConnection(debugger, process);
   if (error.Fail()) {
     LLDB_LOG(log, "failed launching '{0}'. {1}",
              launch_info.GetExecutableFile().GetPath(), error);
@@ -288,8 +288,9 @@ Error ProcessWindows::DoLaunch(Module *exe_module,
   return result;
 }
 
-Error ProcessWindows::DoAttachToProcessWithID(
-    lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
+Status
+ProcessWindows::DoAttachToProcessWithID(lldb::pid_t pid,
+                                        const ProcessAttachInfo &attach_info) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   m_session_data.reset(
       new ProcessWindowsData(!attach_info.GetContinueOnceAttached()));
@@ -300,7 +301,7 @@ Error ProcessWindows::DoAttachToProcessWithID(
   m_session_data->m_debugger = debugger;
 
   DWORD process_id = static_cast<DWORD>(pid);
-  Error error = debugger->DebugAttach(process_id, attach_info);
+  Status error = debugger->DebugAttach(process_id, attach_info);
   if (error.Fail()) {
     LLDB_LOG(
         log,
@@ -331,10 +332,10 @@ Error ProcessWindows::DoAttachToProcessWithID(
   return error;
 }
 
-Error ProcessWindows::DoResume() {
+Status ProcessWindows::DoResume() {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   llvm::sys::ScopedLock lock(m_mutex);
-  Error error;
+  Status error;
 
   StateType private_state = GetPrivateState();
   if (private_state == eStateStopped || private_state == eStateCrashed) {
@@ -369,7 +370,7 @@ Error ProcessWindows::DoResume() {
   return error;
 }
 
-Error ProcessWindows::DoDestroy() {
+Status ProcessWindows::DoDestroy() {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   DebuggerThreadSP debugger_thread;
   StateType private_state;
@@ -386,13 +387,13 @@ Error ProcessWindows::DoDestroy() {
     if (!m_session_data) {
       LLDB_LOG(log, "warning: state = {0}, but there is no active session.",
                private_state);
-      return Error();
+      return Status();
     }
 
     debugger_thread = m_session_data->m_debugger;
   }
 
-  Error error;
+  Status error;
   if (private_state != eStateExited && private_state != eStateDetached) {
     LLDB_LOG(log, "Shutting down process {0} while state = {1}.",
              debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(),
@@ -411,9 +412,9 @@ Error ProcessWindows::DoDestroy() {
   return error;
 }
 
-Error ProcessWindows::DoHalt(bool &caused_stop) {
+Status ProcessWindows::DoHalt(bool &caused_stop) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
-  Error error;
+  Status error;
   StateType state = GetPrivateState();
   if (state == eStateStopped)
     caused_stop = false;
@@ -623,7 +624,7 @@ bool ProcessWindows::IsAlive() {
 }
 
 size_t ProcessWindows::DoReadMemory(lldb::addr_t vm_addr, void *buf,
-                                    size_t size, Error &error) {
+                                    size_t size, Status &error) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
   llvm::sys::ScopedLock lock(m_mutex);
 
@@ -645,7 +646,7 @@ size_t ProcessWindows::DoReadMemory(lldb::addr_t vm_addr, void *buf,
 }
 
 size_t ProcessWindows::DoWriteMemory(lldb::addr_t vm_addr, const void *buf,
-                                     size_t size, Error &error) {
+                                     size_t size, Status &error) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
   llvm::sys::ScopedLock lock(m_mutex);
   LLDB_LOG(log, "attempting to write {0} bytes into address {1:x}", size,
@@ -669,10 +670,10 @@ size_t ProcessWindows::DoWriteMemory(lldb::addr_t vm_addr, const void *buf,
   return bytes_written;
 }
 
-Error ProcessWindows::GetMemoryRegionInfo(lldb::addr_t vm_addr,
-                                          MemoryRegionInfo &info) {
+Status ProcessWindows::GetMemoryRegionInfo(lldb::addr_t vm_addr,
+                                           MemoryRegionInfo &info) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
-  Error error;
+  Status error;
   llvm::sys::ScopedLock lock(m_mutex);
   info.Clear();
 
@@ -807,7 +808,7 @@ void ProcessWindows::OnDebuggerConnected(lldb::addr_t image_base) {
 
     FileSpec executable_file(file_name, true);
     ModuleSpec module_spec(executable_file);
-    Error error;
+    Status error;
     module = GetTarget().GetSharedModule(module_spec, &error);
     if (!module) {
       return;
@@ -931,7 +932,7 @@ void ProcessWindows::OnLoadDll(const ModuleSpec &module_spec,
   // GetSharedModule() with
   // a new module will add it to the module list and return a corresponding
   // ModuleSP.
-  Error error;
+  Status error;
   ModuleSP module = GetTarget().GetSharedModule(module_spec, &error);
   bool load_addr_changed = false;
   module->SetLoadAddress(GetTarget(), module_addr, false, load_addr_changed);
@@ -955,7 +956,7 @@ void ProcessWindows::OnUnloadDll(lldb::addr_t module_addr) {
 
 void ProcessWindows::OnDebugString(const std::string &string) {}
 
-void ProcessWindows::OnDebuggerError(const Error &error, uint32_t type) {
+void ProcessWindows::OnDebuggerError(const Status &error, uint32_t type) {
   llvm::sys::ScopedLock lock(m_mutex);
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
 
@@ -981,9 +982,9 @@ void ProcessWindows::OnDebuggerError(const Error &error, uint32_t type) {
   }
 }
 
-Error ProcessWindows::WaitForDebuggerConnection(DebuggerThreadSP debugger,
-                                                HostProcess &process) {
-  Error result;
+Status ProcessWindows::WaitForDebuggerConnection(DebuggerThreadSP debugger,
+                                                 HostProcess &process) {
+  Status result;
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS |
                                             WINDOWS_LOG_BREAKPOINTS);
   LLDB_LOG(log, "Waiting for loader breakpoint.");
@@ -996,7 +997,7 @@ Error ProcessWindows::WaitForDebuggerConnection(DebuggerThreadSP debugger,
     process = debugger->GetProcess();
     return m_session_data->m_launch_error;
   } else
-    return Error(::GetLastError(), eErrorTypeWin32);
+    return Status(::GetLastError(), eErrorTypeWin32);
 }
 
 // The Windows page protection bits are NOT independent masks that can be
diff --git a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h
index f2db102299a..ed3938beb34 100644
--- a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h
+++ b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h
@@ -12,7 +12,7 @@
 
 // Other libraries and framework includes
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/Error.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-forward.h"
 
 #include "llvm/Support/Mutex.h"
@@ -48,25 +48,25 @@ public:
 
   ~ProcessWindows();
 
-  size_t GetSTDOUT(char *buf, size_t buf_size, Error &error) override;
-  size_t GetSTDERR(char *buf, size_t buf_size, Error &error) override;
-  size_t PutSTDIN(const char *buf, size_t buf_size, Error &error) override;
+  size_t GetSTDOUT(char *buf, size_t buf_size, Status &error) override;
+  size_t GetSTDERR(char *buf, size_t buf_size, Status &error) override;
+  size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) override;
 
   // lldb_private::Process overrides
   ConstString GetPluginName() override;
   uint32_t GetPluginVersion() override;
 
-  Error EnableBreakpointSite(BreakpointSite *bp_site) override;
-  Error DisableBreakpointSite(BreakpointSite *bp_site) override;
+  Status EnableBreakpointSite(BreakpointSite *bp_site) override;
+  Status DisableBreakpointSite(BreakpointSite *bp_site) override;
 
-  Error DoDetach(bool keep_stopped) override;
-  Error DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
-  Error DoAttachToProcessWithID(
+  Status DoDetach(bool keep_stopped) override;
+  Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
+  Status DoAttachToProcessWithID(
       lldb::pid_t pid,
       const lldb_private::ProcessAttachInfo &attach_info) override;
-  Error DoResume() override;
-  Error DoDestroy() override;
-  Error DoHalt(bool &caused_stop) override;
+  Status DoResume() override;
+  Status DoDestroy() override;
+  Status DoHalt(bool &caused_stop) override;
 
   void DidLaunch() override;
   void DidAttach(lldb_private::ArchSpec &arch_spec) override;
@@ -81,11 +81,11 @@ public:
   bool IsAlive() override;
 
   size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
-                      Error &error) override;
+                      Status &error) override;
   size_t DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size,
-                       Error &error) override;
-  Error GetMemoryRegionInfo(lldb::addr_t vm_addr,
-                            MemoryRegionInfo &info) override;
+                       Status &error) override;
+  Status GetMemoryRegionInfo(lldb::addr_t vm_addr,
+                             MemoryRegionInfo &info) override;
 
   lldb::addr_t GetImageInfoAddress() override;
 
@@ -100,11 +100,11 @@ public:
                  lldb::addr_t module_addr) override;
   void OnUnloadDll(lldb::addr_t module_addr) override;
   void OnDebugString(const std::string &string) override;
-  void OnDebuggerError(const Error &error, uint32_t type) override;
+  void OnDebuggerError(const Status &error, uint32_t type) override;
 
 private:
-  Error WaitForDebuggerConnection(DebuggerThreadSP debugger,
-                                  HostProcess &process);
+  Status WaitForDebuggerConnection(DebuggerThreadSP debugger,
+                                   HostProcess &process);
 
   // These decode the page protection bits.
   static bool IsPageReadable(uint32_t protect);
diff --git a/lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.cpp b/lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.cpp
index bfed3044910..b3f507128f8 100644
--- a/lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.cpp
+++ b/lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.cpp
@@ -10,7 +10,7 @@
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/Error.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 
 #include "ProcessWindowsLog.h"
diff --git a/lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp b/lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp
index 53fe1d90249..e64bade5ff9 100644
--- a/lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp
+++ b/lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp
@@ -10,7 +10,7 @@
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
-#include "lldb/Utility/Error.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 
 #include "RegisterContextWindows_x64.h"
diff --git a/lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp b/lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp
index 8127606583c..f56836de4a6 100644
--- a/lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp
+++ b/lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp
@@ -10,7 +10,7 @@
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
-#include "lldb/Utility/Error.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 
 #include "ProcessWindowsLog.h"