Make the Error class constructor protected

[mehdi_amini]

Summary

This is forcing to use Error::success(), which is in a wide majority
of cases a lot more readable.

[lhames]

LGTM. Thanks for this - it's a lot of leg-work!

• Lang.

[pcc]

llvm/include/llvm/Support/Error.h

160

Might want to update this comment.

lldb/include/lldb/Target/Process.h

#endif
   /// Called before attaching to a process.
   ///
   /// Allow Process plug-ins to execute some code before attaching a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillAttachToProcessWithID(lldb::pid_t pid) { return Error(); }
+  virtual Error WillAttachToProcessWithID(lldb::pid_t pid) {
+    return Error::success();
+  }
 
   //------------------------------------------------------------------
   /// Called before attaching to a process.
   ///
   /// Allow Process plug-ins to execute some code before attaching a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
   virtual Error WillAttachToProcessWithName(const char *process_name,
                                             bool wait_for_launch) {
-    return Error();
+    return Error::success();
   }
 
   //------------------------------------------------------------------
   /// Attach to a remote system via a URL
   ///
   /// @param[in] strm
   ///     A stream where output intended for the user
   ///     (if the driver has a way to display that) generated during
#endif
   /// Called before launching to a process.
   ///
   /// Allow Process plug-ins to execute some code before launching a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillLaunch(Module *module) { return Error(); }
+  virtual Error WillLaunch(Module *module) { return Error::success(); }
 
   //------------------------------------------------------------------
   /// Launch a new process.
   ///
   /// Launch a new process by spawning a new process using
   /// \a exe_module's file as the file to launch. Launch details are
   /// provided in \a launch_info.
   ///
#endif
   /// Called before resuming to a process.
   ///
   /// Allow Process plug-ins to execute some code before resuming a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillResume() { return Error(); }
+  virtual Error WillResume() { return Error::success(); }
 
   //------------------------------------------------------------------
   /// Resumes all of a process's threads as configured using the
   /// Thread run control functions.
   ///
   /// Threads for a process should be updated with one of the run
   /// control actions (resume, step, or suspend) that they should take
   /// when the process is resumed. If no run control action is given
#endif
   /// Called before halting to a process.
   ///
   /// Allow Process plug-ins to execute some code before halting a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillHalt() { return Error(); }
+  virtual Error WillHalt() { return Error::success(); }
 
   //------------------------------------------------------------------
   /// Halts a running process.
   ///
   /// DoHalt must produce one and only one stop StateChanged event if it
   /// actually
   /// stops the process.  If the stop happens through some natural event (for
   /// instance a SIGSTOP), then forwarding that event will do.  Otherwise, you
#endif
   /// Called before detaching from a process.
   ///
   /// Allow Process plug-ins to execute some code before detaching
   /// from a process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillDetach() { return Error(); }
+  virtual Error WillDetach() { return Error::success(); }
 
   //------------------------------------------------------------------
   /// Detaches from a running or stopped process.
   ///
   /// @return
   ///     Returns \b true if the process successfully detaches, \b
   ///     false otherwise.
   //------------------------------------------------------------------
#endif
   /// Allow Process plug-ins to execute some code before sending a
   /// signal to a process.
   ///
   /// @return
   ///     Returns no error if it is safe to proceed with a call to
   ///     Process::DoSignal(int), otherwise an error describing what
   ///     prevents the signal from being sent.
   //------------------------------------------------------------------
-  virtual Error WillSignal() { return Error(); }
+  virtual Error WillSignal() { return Error::success(); }
 
   //------------------------------------------------------------------
   /// Sends a process a UNIX signal \a signal.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
   virtual Error DoSignal(int signal) {
     Error error;
     error.SetErrorStringWithFormat(
         "error: %s does not support sending signals to processes",
         GetPluginName().GetCString());
     return error;
   }
 
-  virtual Error WillDestroy() { return Error(); }
+  virtual Error WillDestroy() { return Error::success(); }
 
   virtual Error DoDestroy() = 0;
 
   virtual void DidDestroy() {}
 
   virtual bool DestroyRequiresHalt() { return true; }
 
   //------------------------------------------------------------------

lldb/source/Commands/CommandObjectDisassemble.cpp

void CommandObjectDisassemble::CommandOptions::OptionParsingStarting(
   arch.Clear();
   some_location_specified = false;
 }
 
 Error CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
     ExecutionContext *execution_context) {
   if (!some_location_specified)
     current_function = true;
-  return Error();
+  return Error::success();
 }
 
 llvm::ArrayRef<OptionDefinition>
 CommandObjectDisassemble::CommandOptions::GetDefinitions() {
   return llvm::makeArrayRef(g_disassemble_options);
 }
 
 //-------------------------------------------------------------------------

lldb/source/Commands/CommandObjectExpression.cpp

 static lldb_private::Error
 CanBeUsedForElementCountPrinting(ValueObject &valobj) {
   CompilerType type(valobj.GetCompilerType());
   CompilerType pointee;
   if (!type.IsPointerType(&pointee))
     return Error("as it does not refer to a pointer");
   if (pointee.IsVoidType())
     return Error("as it refers to a pointer to void");
-  return Error();
+  return Error::success();
 }
 
 bool CommandObjectExpression::EvaluateExpression(const char *expr,
                                                  Stream *output_stream,
                                                  Stream *error_stream,
                                                  CommandReturnObject *result) {
   // Don't use m_exe_ctx as this might be called asynchronously
   // after the command object DoExecute has finished when doing

lldb/source/Core/ModuleList.cpp

for (size_t idx = 0; idx < num_directories; ++idx) {
           if (module_sp->GetObjectFile()->GetType() ==
               ObjectFile::eTypeStubLibrary) {
             module_sp.reset();
           } else {
             if (did_create_ptr)
               *did_create_ptr = true;
 
             shared_module_list.ReplaceEquivalent(module_sp);
-            return Error();
+            return Error::success();
           }
         }
       } else {
         module_sp.reset();
       }
     }
   }
 

lldb/source/Host/common/NativeBreakpoint.cpp

Error NativeBreakpoint::Enable() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   if (m_enabled) {
     // We're already enabled. Just log and exit.
     if (log)
       log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
                   " already enabled, ignoring.",
                   __FUNCTION__, m_addr);
-    return Error();
+    return Error::success();
   }
 
   // Log and enable.
   if (log)
     log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64 " enabling...",
                 __FUNCTION__, m_addr);
 
   Error error = DoEnable();
Error NativeBreakpoint::Disable() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   if (!m_enabled) {
     // We're already disabled. Just log and exit.
     if (log)
       log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
                   " already disabled, ignoring.",
                   __FUNCTION__, m_addr);
-    return Error();
+    return Error::success();
   }
 
   // Log and disable.
   if (log)
     log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64 " disabling...",
                 __FUNCTION__, m_addr);
 
   Error error = DoDisable();

lldb/source/Host/common/NativeBreakpointList.cpp

Error NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
   if (iter != m_breakpoints.end()) {
     // Yes - bump up ref count.
     if (log)
       log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64
                   " -- already enabled, upping ref count",
                   __FUNCTION__, addr);
 
     iter->second->AddRef();
-    return Error();
+    return Error::success();
   }
 
   // Create a new breakpoint using the given create func.
   if (log)
     log->Printf(
         "NativeBreakpointList::%s creating breakpoint for addr = 0x%" PRIx64
         ", size_hint = %zu, hardware = %s",
         __FUNCTION__, addr, size_hint, hardware ? "true" : "false");
Error NativeBreakpointList::GetBreakpoint(lldb::addr_t addr,
   if (iter == m_breakpoints.end()) {
     // Not found!
     breakpoint_sp.reset();
     return Error("breakpoint not found");
   }
 
   // Disable it.
   breakpoint_sp = iter->second;
-  return Error();
+  return Error::success();
 }
 
 Error NativeBreakpointList::RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf,
                                                   size_t size) const {
   for (const auto &map : m_breakpoints) {
     lldb::addr_t bp_addr = map.first;
     // Breapoint not in range, ignore
     if (bp_addr < addr || addr + size <= bp_addr)
       continue;
     const auto &bp_sp = map.second;
     // Not software breakpoint, ignore
     if (!bp_sp->IsSoftwareBreakpoint())
       continue;
     auto software_bp_sp = std::static_pointer_cast<SoftwareBreakpoint>(bp_sp);
     auto opcode_addr = static_cast<char *>(buf) + bp_addr - addr;
     auto saved_opcodes = software_bp_sp->m_saved_opcodes;
     auto opcode_size = software_bp_sp->m_opcode_size;
     ::memcpy(opcode_addr, saved_opcodes, opcode_size);
   }
-  return Error();
+  return Error::success();
 }

lldb/source/Host/common/NativeProcessProtocol.cpp

Error NativeProcessProtocol::ResolveProcessArchitecture(lldb::pid_t pid,
   ModuleSpecList module_specs;
   if (!ObjectFile::GetModuleSpecifications(process_info.GetExecutableFile(), 0,
                                            0, module_specs))
     return Error("failed to get module specifications");
   lldbassert(module_specs.GetSize() == 1);
 
   arch = module_specs.GetModuleSpecRefAtIndex(0).GetArchitecture();
   if (arch.IsValid())
-    return Error();
+    return Error::success();
   else
     return Error("failed to retrieve a valid architecture from the exe module");
 }
 
 #ifndef __linux__
 // These need to be implemented to support lldb-gdb-server on a given platform.
 // Stubs are
 // provided to make the rest of the code link on non-supported platforms.

lldb/source/Host/common/NativeWatchpointList.cpp

 #include "lldb/Core/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Error NativeWatchpointList::Add(addr_t addr, size_t size, uint32_t watch_flags,
                                 bool hardware) {
   m_watchpoints[addr] = {addr, size, watch_flags, hardware};
-  return Error();
+  return Error::success();
 }
 
 Error NativeWatchpointList::Remove(addr_t addr) {
   m_watchpoints.erase(addr);
-  return Error();
+  return Error::success();
 }
 
 const NativeWatchpointList::WatchpointMap &
 NativeWatchpointList::GetWatchpointMap() const {
   return m_watchpoints;
 }

lldb/source/Host/common/SoftwareBreakpoint.cpp

if (log)
     log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
                 __FUNCTION__, addr);
 
   // Set the breakpoint and verified it was written properly.  Now
   // create a breakpoint remover that understands how to undo this
   // breakpoint.
   breakpoint_sp.reset(new SoftwareBreakpoint(process, addr, saved_opcode_bytes,
                                              bp_opcode_bytes, bp_opcode_size));
-  return Error();
+  return Error::success();
 }
 
 Error SoftwareBreakpoint::EnableSoftwareBreakpoint(
     NativeProcessProtocol &process, lldb::addr_t addr, size_t bp_opcode_size,
     const uint8_t *bp_opcode_bytes, uint8_t *saved_opcode_bytes) {
   assert(bp_opcode_size <= MAX_TRAP_OPCODE_SIZE &&
          "bp_opcode_size out of valid range");
   assert(bp_opcode_bytes && "bp_opcode_bytes is NULL");
return Error("SoftwareBreakpoint::%s: verification of software breakpoint "
                  "after writing when setting breakpoint at 0x%" PRIx64,
                  __FUNCTION__, addr);
   }
 
   if (log)
     log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
                 __FUNCTION__, addr);
 
-  return Error();
+  return Error::success();
 }
 
 // -------------------------------------------------------------------
 // instance-level members
 // -------------------------------------------------------------------
 
 SoftwareBreakpoint::SoftwareBreakpoint(NativeProcessProtocol &process,
                                        lldb::addr_t addr,

lldb/source/Host/posix/FileSystem.cpp

if (::mkdir(file_spec.GetCString(), file_permissions) == -1) {
         // made successfully
         if (::mkdir(file_spec.GetCString(), file_permissions) == -1) {
           error.SetErrorToErrno();
         }
         return error;
       } break;
       case EEXIST: {
         if (file_spec.IsDirectory())
-          return Error(); // It is a directory and it already exists
+          return Error::success(); // It is a directory and it already exists
       } break;
       }
     }
     return error;
   }
   return Error("empty path");
 }
 
Error FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst) {
   if (realpath(resolved_path, real_path) == nullptr) {
     Error err;
     err.SetErrorToErrno();
     return err;
   }
 
   dst = FileSpec(real_path, false);
 
-  return Error();
+  return Error::success();
 }
 
 #if defined(__NetBSD__)
 static bool IsLocal(const struct statvfs &info) {
   return (info.f_flag & MNT_LOCAL) != 0;
 }
 #else
 static bool IsLocal(const struct statfs &info) {

lldb/source/Host/posix/MainLoopPosix.cpp

for (int sig : signals) {
 
       auto it = m_signals.find(sig);
       if (it == m_signals.end())
         continue; // Signal must have gotten unregistered in the meantime
 
       it->second.callback(*this); // Do the work
 
       if (m_terminate_request)
-        return Error();
+        return Error::success();
     }
 
     for (int fd : read_fds) {
       if (!FD_ISSET(fd, &read_fd_set))
         continue; // Not ready
 
       auto it = m_read_fds.find(fd);
       if (it == m_read_fds.end())
         continue; // File descriptor must have gotten unregistered in the
                   // meantime
 
       it->second(*this); // Do the work
 
       if (m_terminate_request)
-        return Error();
+        return Error::success();
     }
   }
-  return Error();
+  return Error::success();
 }

lldb/source/Host/posix/PipePosix.cpp

if (fd == -1) {
 
       std::this_thread::sleep_for(
           milliseconds(OPEN_WRITER_SLEEP_TIMEOUT_MSECS));
     } else {
       m_fds[WRITE] = fd;
     }
   }
 
-  return Error();
+  return Error::success();
 }
 
 int PipePosix::GetReadFileDescriptor() const { return m_fds[READ]; }
 
 int PipePosix::GetWriteFileDescriptor() const { return m_fds[WRITE]; }
 
 int PipePosix::ReleaseReadFileDescriptor() {
   const int fd = m_fds[READ];

lldb/source/Host/windows/LockFileWindows.cpp

Error fileLock(HANDLE file_handle, DWORD flags, const uint64_t start,
   if (!::LockFileEx(file_handle, flags, 0, len, 0, &overlapped) &&
       ::GetLastError() != ERROR_IO_PENDING)
     return Error(::GetLastError(), eErrorTypeWin32);
 
   DWORD bytes;
   if (!::GetOverlappedResult(file_handle, &overlapped, &bytes, TRUE))
     return Error(::GetLastError(), eErrorTypeWin32);
 
-  return Error();
+  return Error::success();
 }
 
 } // namespace
 
 LockFileWindows::LockFileWindows(int fd)
     : LockFileBase(fd), m_file(reinterpret_cast<HANDLE>(_get_osfhandle(fd))) {}
 
 LockFileWindows::~LockFileWindows() { Unlock(); }
Error LockFileWindows::DoUnlock() {
   if (!::UnlockFileEx(m_file, 0, m_len, 0, &overlapped) &&
       ::GetLastError() != ERROR_IO_PENDING)
     return Error(::GetLastError(), eErrorTypeWin32);
 
   DWORD bytes;
   if (!::GetOverlappedResult(m_file, &overlapped, &bytes, TRUE))
     return Error(::GetLastError(), eErrorTypeWin32);
 
-  return Error();
+  return Error::success();
 }

lldb/source/Host/windows/PipeWindows.cpp

if (is_read) {
     if (INVALID_HANDLE_VALUE == m_write)
       return Error(::GetLastError(), eErrorTypeWin32);
 
     m_write_fd = _open_osfhandle((intptr_t)m_write, _O_WRONLY);
 
     ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
   }
 
-  return Error();
+  return Error::success();
 }
 
 int PipeWindows::GetReadFileDescriptor() const { return m_read_fd; }
 
 int PipeWindows::GetWriteFileDescriptor() const { return m_write_fd; }
 
 int PipeWindows::ReleaseReadFileDescriptor() {
   if (!CanRead())
void PipeWindows::CloseWriteFileDescriptor() {
   ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
 }
 
 void PipeWindows::Close() {
   CloseReadFileDescriptor();
   CloseWriteFileDescriptor();
 }
 
-Error PipeWindows::Delete(llvm::StringRef name) { return Error(); }
+Error PipeWindows::Delete(llvm::StringRef name) { return Error::success(); }
 
 bool PipeWindows::CanRead() const { return (m_read != INVALID_HANDLE_VALUE); }
 
 bool PipeWindows::CanWrite() const { return (m_write != INVALID_HANDLE_VALUE); }
 
 HANDLE
 PipeWindows::GetReadNativeHandle() { return m_read; }
 
Error PipeWindows::ReadWithTimeout(void *buf, size_t size,
 
   // Now we call GetOverlappedResult setting bWait to false, since we've already
   // waited
   // as long as we're willing to.
   if (!GetOverlappedResult(m_read, &m_read_overlapped, &sys_bytes_read, FALSE))
     return Error(::GetLastError(), eErrorTypeWin32);
 
   bytes_read = sys_bytes_read;
-  return Error();
+  return Error::success();
 }
 
 Error PipeWindows::Write(const void *buf, size_t num_bytes,
                          size_t &bytes_written) {
   if (!CanWrite())
     return Error(ERROR_INVALID_HANDLE, eErrorTypeWin32);
 
   DWORD sys_bytes_written = 0;
   BOOL write_result = ::WriteFile(m_write, buf, num_bytes, &sys_bytes_written,
                                   &m_write_overlapped);
   if (!write_result && GetLastError() != ERROR_IO_PENDING)
     return Error(::GetLastError(), eErrorTypeWin32);
 
   BOOL result = GetOverlappedResult(m_write, &m_write_overlapped,
                                     &sys_bytes_written, TRUE);
   if (!result)
     return Error(::GetLastError(), eErrorTypeWin32);
-  return Error();
+  return Error::success();
 }

lldb/source/Interpreter/OptionGroupVariable.cpp

 
 static Error ValidateNamedSummary(const char *str, void *) {
   if (!str || !str[0])
     return Error("must specify a valid named summary");
   TypeSummaryImplSP summary_sp;
   if (DataVisualization::NamedSummaryFormats::GetSummaryFormat(
           ConstString(str), summary_sp) == false)
     return Error("must specify a valid named summary");
-  return Error();
+  return Error::success();
 }
 
 static Error ValidateSummaryString(const char *str, void *) {
   if (!str || !str[0])
     return Error("must specify a non-empty summary string");
-  return Error();
+  return Error::success();
 }
 
 OptionGroupVariable::OptionGroupVariable(bool show_frame_options)
     : OptionGroup(), include_frame_options(show_frame_options),
       summary(ValidateNamedSummary), summary_string(ValidateSummaryString) {}
 
 OptionGroupVariable::~OptionGroupVariable() {}
 

lldb/source/Interpreter/OptionValueString.cpp

 
 Error OptionValueString::SetCurrentValue(llvm::StringRef value) {
   if (m_validator) {
     Error error(m_validator(value.str().c_str(), m_validator_baton));
     if (error.Fail())
       return error;
   }
   m_current_value.assign(value);
-  return Error();
+  return Error::success();
 }
 
 Error OptionValueString::AppendToCurrentValue(const char *value) {
   if (value && value[0]) {
     if (m_validator) {
       std::string new_value(m_current_value);
       new_value.append(value);
       Error error(m_validator(value, m_validator_baton));
       if (error.Fail())
         return error;
       m_current_value.assign(new_value);
     } else
       m_current_value.append(value);
   }
-  return Error();
+  return Error::success();
 }

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

if (executable.get() != target.GetExecutableModulePointer()) {
     const bool get_dependent_images = false;
     target.SetExecutableModule(executable, get_dependent_images);
   }
 
   return executable;
 }
 
 // AD: Needs to be updated?
-Error DynamicLoaderHexagonDYLD::CanLoadImage() { return Error(); }
+Error DynamicLoaderHexagonDYLD::CanLoadImage() { return Error::success(); }
 
 void DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module,
                                                     addr_t link_map_addr,
                                                     addr_t base_addr,
                                                     bool base_addr_is_offset) {
   Target &target = m_process->GetTarget();
   const SectionList *sections = GetSectionListFromModule(module);
 

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (log)
       log->Printf("DynamicLoaderPOSIXDYLD::%s about to call ProbeEntry()",
                   __FUNCTION__);
     ProbeEntry();
 
     m_process->GetTarget().ModulesDidLoad(module_list);
   }
 }
 
-Error DynamicLoaderPOSIXDYLD::CanLoadImage() { return Error(); }
+Error DynamicLoaderPOSIXDYLD::CanLoadImage() { return Error::success(); }
 
 void DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module,
                                                   addr_t link_map_addr,
                                                   addr_t base_addr,
                                                   bool base_addr_is_offset) {
   m_loaded_modules[module] = link_map_addr;
   UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
 }

lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
 
   return nullptr;
 }
 
 void DynamicLoaderWindowsDYLD::DidAttach() {}
 
 void DynamicLoaderWindowsDYLD::DidLaunch() {}
 
-Error DynamicLoaderWindowsDYLD::CanLoadImage() { return Error(); }
+Error DynamicLoaderWindowsDYLD::CanLoadImage() { return Error::success(); }
 
 ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }
 
 ThreadPlanSP
 DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
                                                        bool stop) {
   return ThreadPlanSP();
 }

lldb/source/Plugins/Platform/Android/AdbClient.cpp

Error AdbClient::internalShell(const char *command, uint32_t timeout_ms,
   // output starts with /system/bin/sh: most likely command failed.
   static const char *kShellPrefix = "/system/bin/sh:";
   if (output_buf.size() > strlen(kShellPrefix)) {
     if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix)))
       return Error("Shell command %s failed: %s", command,
                    std::string(output_buf.begin(), output_buf.end()).c_str());
   }
 
-  return Error();
+  return Error::success();
 }
 
 Error AdbClient::Shell(const char *command, uint32_t timeout_ms,
                        std::string *output) {
   std::vector<char> output_buffer;
   auto error = internalShell(command, timeout_ms, output_buffer);
   if (error.Fail())
     return error;
Error AdbClient::ShellToFile(const char *command, uint32_t timeout_ms,
   std::ofstream dst(output_filename, std::ios::out | std::ios::binary);
   if (!dst.is_open())
     return Error("Unable to open local file %s", output_filename.c_str());
 
   dst.write(&output_buffer[0], output_buffer.size());
   dst.close();
   if (!dst)
     return Error("Failed to write file %s", output_filename.c_str());
-  return Error();
+  return Error::success();
 }
 
 std::unique_ptr<AdbClient::SyncService>
 AdbClient::GetSyncService(Error &error) {
   std::unique_ptr<SyncService> sync_service;
   error = StartSync();
   if (error.Success())
     sync_service.reset(new SyncService(std::move(m_conn)));
if (!command)
     return Error("Failed to get response command");
   const char *command_str = static_cast<const char *>(command);
   if (strncmp(command_str, kSTAT, stat_len))
     return Error("Got invalid stat command: %s", command_str);
 
   mode = extractor.GetU32(&offset);
   size = extractor.GetU32(&offset);
   mtime = extractor.GetU32(&offset);
-  return Error();
+  return Error::success();
 }
 
 Error AdbClient::SyncService::PullFile(const FileSpec &remote_file,
                                        const FileSpec &local_file) {
   return executeCommand([this, &remote_file, &local_file]() {
     return internalPullFile(remote_file, local_file);
   });
 }
if (response_id == kDATA) {
     std::string error_message(data_len, 0);
     error = ReadAllBytes(&error_message[0], data_len);
     if (error.Fail())
       return Error("Failed to read pull error message: %s", error.AsCString());
     return Error("Failed to pull file: %s", error_message.c_str());
   } else
     return Error("Pull failed with unknown response: %s", response_id.c_str());
 
-  return Error();
+  return Error::success();
 }
 
 Error AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) {
   return ::ReadAllBytes(*m_conn, buffer, size);
 }

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

Error PlatformFreeBSD::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformFreeBSD::PlatformFreeBSD(bool is_host)
     : Platform(is_host), m_remote_platform_sp() {}
 

lldb/source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

Error PlatformKalimba::ResolveExecutable(
   }
 
   return error;
 }
 
 Error PlatformKalimba::GetFileWithUUID(const FileSpec & /*platform_file*/,
                                        const UUID * /*uuid_ptr*/,
                                        FileSpec & /*local_file*/) {
-  return Error();
+  return Error::success();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformKalimba::PlatformKalimba(bool is_host)
     : Platform(is_host), // This is the local host platform
       m_remote_platform_sp() {}

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

Error PlatformLinux::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformLinux::PlatformLinux(bool is_host)
     : PlatformPOSIX(is_host) // This is the local host platform
 {}

lldb/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

if (device.GetState() != CoreSimulatorSupport::Device::State::Booted) {
     if (boot_err.Fail())
       return boot_err;
   }
 
   auto spawned = device.Spawn(launch_info);
 
   if (spawned) {
     launch_info.SetProcessID(spawned.GetPID());
-    return Error();
+    return Error::success();
   } else
     return spawned.GetError();
 #else
   Error err;
   err.SetErrorString(UNSUPPORTED_ERROR);
   return err;
 #endif
 }
#else
   err.SetErrorString(UNSUPPORTED_ERROR);
   return err;
 #endif
 }
 
 Error PlatformAppleSimulator::DisconnectRemote() {
 #if defined(__APPLE__)
   m_device.reset();
-  return Error();
+  return Error::success();
 #else
   Error err;
   err.SetErrorString(UNSUPPORTED_ERROR);
   return err;
 #endif
 }
 
 lldb::ProcessSP PlatformAppleSimulator::DebugProcess(

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (!cache_path.empty()) {
             log->Printf("[%s] module %s/%s was rsynced and is now there",
                         (IsHost() ? "host" : "remote"),
                         module_spec.GetFileSpec().GetDirectory().AsCString(),
                         module_spec.GetFileSpec().GetFilename().AsCString());
           ModuleSpec local_spec(module_cache_spec,
                                 module_spec.GetArchitecture());
           module_sp.reset(new Module(local_spec));
           module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
-          return Error();
+          return Error::success();
         }
       }
 
       // try to find the module in the cache
       if (module_cache_spec.Exists()) {
         // get the local and remote MD5 and compare
         if (m_remote_platform_sp) {
           // when going over the *slow* GDB remote transfer mechanism we first
if (!cache_path.empty()) {
         module_sp.reset(new Module(local_spec));
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
         if (log)
           log->Printf("[%s] module %s/%s was found in the cache",
                       (IsHost() ? "host" : "remote"),
                       module_spec.GetFileSpec().GetDirectory().AsCString(),
                       module_spec.GetFileSpec().GetFilename().AsCString());
-        return Error();
+        return Error::success();
       }
 
       // bring in the remote module file
       if (log)
         log->Printf("[%s] module %s/%s needs to come in remotely",
                     (IsHost() ? "host" : "remote"),
                     module_spec.GetFileSpec().GetDirectory().AsCString(),
                     module_spec.GetFileSpec().GetFilename().AsCString());
       Error err = BringInRemoteFile(this, module_spec, module_cache_spec);
       if (err.Fail())
         return err;
       if (module_cache_spec.Exists()) {
         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
         if (log)
           log->Printf("[%s] module %s/%s is now cached and fine",
                       (IsHost() ? "host" : "remote"),
                       module_spec.GetFileSpec().GetDirectory().AsCString(),
                       module_spec.GetFileSpec().GetFilename().AsCString());
         ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
         module_sp.reset(new Module(local_spec));
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
-        return Error();
+        return Error::success();
       } else
         return Error("unable to obtain valid module file");
     } else
       return Error("no cache path");
   } else
     return Error("unable to resolve module");
 }
 

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

Error PlatformMacOSX::GetSymbolFile(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 lldb_private::Error
 PlatformMacOSX::GetFileWithUUID(const lldb_private::FileSpec &platform_file,
                                 const lldb_private::UUID *uuid_ptr,
                                 lldb_private::FileSpec &local_file) {
   if (IsRemote() && m_remote_platform_sp) {
     std::string local_os_build;
 #if !defined(__linux__)
     HostInfo::GetOSBuildString(local_os_build);
 #endif
     std::string remote_os_build;
     m_remote_platform_sp->GetOSBuildString(remote_os_build);
     if (local_os_build.compare(remote_os_build) == 0) {
       // same OS version: the local file is good enough
       local_file = platform_file;
-      return Error();
+      return Error::success();
     } else {
       // try to find the file in the cache
       std::string cache_path(GetLocalCacheDirectory());
       std::string module_path(platform_file.GetPath());
       cache_path.append(module_path);
       FileSpec module_cache_spec(cache_path, false);
       if (module_cache_spec.Exists()) {
         local_file = module_cache_spec;
-        return Error();
+        return Error::success();
       }
       // bring in the remote module file
       FileSpec module_cache_folder =
           module_cache_spec.CopyByRemovingLastPathComponent();
       // try to make the local directory first
       Error err = FileSystem::MakeDirectory(module_cache_folder,
                                             eFilePermissionsDirectoryDefault);
       if (err.Fail())
         return err;
       err = GetFile(platform_file, module_cache_spec);
       if (err.Fail())
         return err;
       if (module_cache_spec.Exists()) {
         local_file = module_cache_spec;
-        return Error();
+        return Error::success();
       } else
         return Error("unable to obtain valid module file");
     }
   }
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 bool PlatformMacOSX::GetSupportedArchitectureAtIndex(uint32_t idx,
                                                      ArchSpec &arch) {
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   return ARMGetSupportedArchitectureAtIndex(idx, arch);
 #else
   return x86GetSupportedArchitectureAtIndex(idx, arch);

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

Error PlatformNetBSD::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformNetBSD::PlatformNetBSD(bool is_host)
     : Platform(is_host), m_remote_platform_sp() {}
 

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 lldb_private::Error
 PlatformPOSIX::PutFile(const lldb_private::FileSpec &source,
                        const lldb_private::FileSpec &destination, uint32_t uid,
                        uint32_t gid) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
   if (IsHost()) {
     if (FileSpec::Equal(source, destination, true))
-      return Error();
+      return Error::success();
     // cp src dst
     // chown uid:gid dst
     std::string src_path(source.GetPath());
     if (src_path.empty())
       return Error("unable to get file path for source");
     std::string dst_path(destination.GetPath());
     if (dst_path.empty())
       return Error("unable to get file path for destination");
     StreamString command;
     command.Printf("cp %s %s", src_path.c_str(), dst_path.c_str());
     int status;
     RunShellCommand(command.GetData(), NULL, &status, NULL, NULL, 10);
     if (status != 0)
       return Error("unable to perform copy");
     if (uid == UINT32_MAX && gid == UINT32_MAX)
-      return Error();
+      return Error::success();
     if (chown_file(this, dst_path.c_str(), uid, gid) != 0)
       return Error("unable to perform chown");
-    return Error();
+    return Error::success();
   } else if (m_remote_platform_sp) {
     if (GetSupportsRSync()) {
       std::string src_path(source.GetPath());
       if (src_path.empty())
         return Error("unable to get file path for source");
       std::string dst_path(destination.GetPath());
       if (dst_path.empty())
         return Error("unable to get file path for destination");
if (GetSupportsRSync()) {
       if (log)
         log->Printf("[PutFile] Running command: %s\n", command.GetData());
       int retcode;
       Host::RunShellCommand(command.GetData(), NULL, &retcode, NULL, NULL, 60);
       if (retcode == 0) {
         // Don't chown a local file for a remote system
         //                if (chown_file(this,dst_path.c_str(),uid,gid) != 0)
         //                    return Error("unable to perform chown");
-        return Error();
+        return Error::success();
       }
       // if we are still here rsync has failed - let's try the slow way before
       // giving up
     }
   }
   return Platform::PutFile(source, destination, uid, gid);
 }
 
if (FileSpec::Equal(source, destination, true))
                    "path: no operation performed");
     // cp src dst
     StreamString cp_command;
     cp_command.Printf("cp %s %s", src_path.c_str(), dst_path.c_str());
     int status;
     RunShellCommand(cp_command.GetData(), NULL, &status, NULL, NULL, 10);
     if (status != 0)
       return Error("unable to perform copy");
-    return Error();
+    return Error::success();
   } else if (m_remote_platform_sp) {
     if (GetSupportsRSync()) {
       StreamString command;
       if (GetIgnoresRemoteHostname()) {
         if (!GetRSyncPrefix())
           command.Printf("rsync %s %s %s", GetRSyncOpts(), src_path.c_str(),
                          dst_path.c_str());
         else
           command.Printf("rsync %s %s%s %s", GetRSyncOpts(), GetRSyncPrefix(),
                          src_path.c_str(), dst_path.c_str());
       } else
         command.Printf("rsync %s %s:%s %s", GetRSyncOpts(),
                        m_remote_platform_sp->GetHostname(), src_path.c_str(),
                        dst_path.c_str());
       if (log)
         log->Printf("[GetFile] Running command: %s\n", command.GetData());
       int retcode;
       Host::RunShellCommand(command.GetData(), NULL, &retcode, NULL, NULL, 60);
       if (retcode == 0)
-        return Error();
+        return Error::success();
       // If we are here, rsync has failed - let's try the slow way before giving
       // up
     }
     // open src and dst
     // read/write, read/write, read/write, ...
     // close src
     // close dst
     if (log)
Error PlatformPOSIX::EvaluateLibdlExpression(
   ExpressionResults result =
       UserExpression::Evaluate(exe_ctx, expr_options, expr_cstr, expr_prefix,
                                result_valobj_sp, expr_error);
   if (result != eExpressionCompleted)
     return expr_error;
 
   if (result_valobj_sp->GetError().Fail())
     return result_valobj_sp->GetError();
-  return Error();
+  return Error::success();
 }
 
 uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
                                     const lldb_private::FileSpec &remote_file,
                                     lldb_private::Error &error) {
   char path[PATH_MAX];
   remote_file.GetPath(path, sizeof(path));
 
if (result_valobj_sp->GetError().Fail())
     return result_valobj_sp->GetError();
 
   Scalar scalar;
   if (result_valobj_sp->ResolveValue(scalar)) {
     if (scalar.UInt(1))
       return Error("expression failed: \"%s\"", expr.GetData());
     process->ResetImageToken(image_token);
   }
-  return Error();
+  return Error::success();
 }
 
 lldb::ProcessSP PlatformPOSIX::ConnectProcess(const char *connect_url,
                                               const char *plugin_name,
                                               lldb_private::Debugger &debugger,
                                               lldb_private::Target *target,
                                               lldb_private::Error &error) {
   if (m_remote_platform_sp)

lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp

Error PlatformWindows::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 Error PlatformWindows::GetSharedModule(
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,
     bool *did_create_ptr) {
   Error error;
   module_sp.reset();

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

bool PlatformRemoteGDBServer::GetModuleSpec(const FileSpec &module_file_spec,
   return true;
 }
 
 Error PlatformRemoteGDBServer::GetFileWithUUID(const FileSpec &platform_file,
                                                const UUID *uuid_ptr,
                                                FileSpec &local_file) {
   // Default to the local case
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformRemoteGDBServer::PlatformRemoteGDBServer()
     : Platform(false), // This is a remote platform
       m_gdb_client() {}
error.SetErrorStringWithFormat("'A' packet returned an error: %i",
                                    arg_packet_err);
   }
   return error;
 }
 
 Error PlatformRemoteGDBServer::KillProcess(const lldb::pid_t pid) {
   if (!KillSpawnedProcess(pid))
     return Error("failed to kill remote spawned process");
-  return Error();
+  return Error::success();
 }
 
 lldb::ProcessSP PlatformRemoteGDBServer::DebugProcess(
     ProcessLaunchInfo &launch_info, Debugger &debugger,
     Target *target, // Can be NULL, if NULL create a new target, else use
                     // existing one
     Error &error) {
   lldb::ProcessSP process_sp;

lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

Error ProcessFreeBSD::DoResume() {
   if (log)
     log->Printf("process %" PRIu64 " resuming (%s)", GetID(),
                 do_step ? "step" : "continue");
   if (do_step)
     m_monitor->SingleStep(GetID(), m_resume_signo);
   else
     m_monitor->Resume(GetID(), m_resume_signo);
 
-  return Error();
+  return Error::success();
 }
 
 bool ProcessFreeBSD::UpdateThreadList(ThreadList &old_thread_list,
                                       ThreadList &new_thread_list) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   if (log)
     log->Printf("ProcessFreeBSD::%s (pid = %" PRIu64 ")", __FUNCTION__,
                 GetID());

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

Error NativeProcessLinux::SetupSoftwareSingleStepping(
   else {
     // No size hint is given for the next breakpoint
     error = SetSoftwareBreakpoint(next_pc, 0);
   }
 
   // If setting the breakpoint fails because next_pc is out of
   // the address space, ignore it and let the debugee segfault.
   if (error.GetError() == EIO || error.GetError() == EFAULT) {
-    return Error();
+    return Error::success();
   } else if (error.Fail())
     return error;
 
   m_threads_stepping_with_breakpoint.insert({thread.GetID(), next_pc});
 
-  return Error();
+  return Error::success();
 }
 
 bool NativeProcessLinux::SupportHardwareSingleStepping() const {
   if (m_arch.GetMachine() == llvm::Triple::arm ||
       m_arch.GetMachine() == llvm::Triple::mips64 ||
       m_arch.GetMachine() == llvm::Triple::mips64el ||
       m_arch.GetMachine() == llvm::Triple::mips ||
       m_arch.GetMachine() == llvm::Triple::mipsel)
for (auto thread_sp : m_threads) {
     default:
       return Error("NativeProcessLinux::%s (): unexpected state %s specified "
                    "for pid %" PRIu64 ", tid %" PRIu64,
                    __FUNCTION__, StateAsCString(action->state), GetID(),
                    thread_sp->GetID());
     }
   }
 
-  return Error();
+  return Error::success();
 }
 
 Error NativeProcessLinux::Halt() {
   Error error;
 
   if (kill(GetID(), SIGSTOP) != 0)
     error.SetErrorToErrno();
 
if (log)
     log->Printf("NativeProcessLinux::%s pid %" PRIu64 " %s tid %" PRIu64
                 " chosen for interrupt target",
                 __FUNCTION__, GetID(),
                 running_thread_sp ? "running" : "stopped",
                 deferred_signal_thread_sp->GetID());
 
   StopRunningThreads(deferred_signal_thread_sp->GetID());
 
-  return Error();
+  return Error::success();
 }
 
 Error NativeProcessLinux::Kill() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
   if (log)
     log->Printf("NativeProcessLinux::%s called for PID %" PRIu64, __FUNCTION__,
                 GetID());
 
ParseMemoryRegionInfoFromProcMapsLine(const std::string &maps_line,
   line_extractor.SkipSpaces();           // Skip the separator
   line_extractor.GetU64(0, 10);          // Read the inode number
 
   line_extractor.SkipSpaces();
   const char *name = line_extractor.Peek();
   if (name)
     memory_region_info.SetName(name);
 
-  return Error();
+  return Error::success();
 }
 
 Error NativeProcessLinux::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                               MemoryRegionInfo &range_info) {
   // FIXME review that the final memory region returned extends to the end of
   // the virtual address space,
   // with no perms if it is not mapped.
 
if (permissions & lldb::ePermissionsExecutable)
     prot |= eMmapProtExec;
 
   // TODO implement this directly in NativeProcessLinux
   // (and lift to NativeProcessPOSIX if/when that class is
   // refactored out).
   if (InferiorCallMmap(this, addr, 0, size, prot,
                        eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
     m_addr_to_mmap_size[addr] = size;
-    return Error();
+    return Error::success();
   } else {
     addr = LLDB_INVALID_ADDRESS;
     return Error("unable to allocate %" PRIu64
                  " bytes of memory with permissions %s",
                  size, GetPermissionsAsCString(permissions));
   }
 #endif
 }
Error NativeProcessLinux::GetSoftwareBreakpointPCOffset(
   // set per architecture.  Need ARM, MIPS support here.
   static const uint8_t g_i386_opcode[] = {0xCC};
   static const uint8_t g_s390x_opcode[] = {0x00, 0x01};
 
   switch (m_arch.GetMachine()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     actual_opcode_size = static_cast<uint32_t>(sizeof(g_i386_opcode));
-    return Error();
+    return Error::success();
 
   case llvm::Triple::systemz:
     actual_opcode_size = static_cast<uint32_t>(sizeof(g_s390x_opcode));
-    return Error();
+    return Error::success();
 
   case llvm::Triple::arm:
   case llvm::Triple::aarch64:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
     // On these architectures the PC don't get updated for breakpoint hits
     actual_opcode_size = 0;
-    return Error();
+    return Error::success();
 
   default:
     assert(false && "CPU type not supported!");
     return Error("CPU type not supported");
   }
 }
 
 Error NativeProcessLinux::SetBreakpoint(lldb::addr_t addr, uint32_t size,
Error NativeProcessLinux::GetSoftwareBreakpointTrapOpcode(
   static const uint8_t g_mips64el_opcode[] = {0x0d, 0x00, 0x00, 0x00};
   static const uint8_t g_s390x_opcode[] = {0x00, 0x01};
   static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
 
   switch (m_arch.GetMachine()) {
   case llvm::Triple::aarch64:
     trap_opcode_bytes = g_aarch64_opcode;
     actual_opcode_size = sizeof(g_aarch64_opcode);
-    return Error();
+    return Error::success();
 
   case llvm::Triple::arm:
     switch (trap_opcode_size_hint) {
     case 2:
       trap_opcode_bytes = g_thumb_breakpoint_opcode;
       actual_opcode_size = sizeof(g_thumb_breakpoint_opcode);
-      return Error();
+      return Error::success();
     case 4:
       trap_opcode_bytes = g_arm_breakpoint_opcode;
       actual_opcode_size = sizeof(g_arm_breakpoint_opcode);
-      return Error();
+      return Error::success();
     default:
       assert(false && "Unrecognised trap opcode size hint!");
       return Error("Unrecognised trap opcode size hint!");
     }
 
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     trap_opcode_bytes = g_i386_opcode;
     actual_opcode_size = sizeof(g_i386_opcode);
-    return Error();
+    return Error::success();
 
   case llvm::Triple::mips:
   case llvm::Triple::mips64:
     trap_opcode_bytes = g_mips64_opcode;
     actual_opcode_size = sizeof(g_mips64_opcode);
-    return Error();
+    return Error::success();
 
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64el:
     trap_opcode_bytes = g_mips64el_opcode;
     actual_opcode_size = sizeof(g_mips64el_opcode);
-    return Error();
+    return Error::success();
 
   case llvm::Triple::systemz:
     trap_opcode_bytes = g_s390x_opcode;
     actual_opcode_size = sizeof(g_s390x_opcode);
-    return Error();
+    return Error::success();
 
   default:
     assert(false && "CPU type not supported!");
     return Error("CPU type not supported");
   }
 }
 
 #if 0
if (ProcessVmReadvSupported()) {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
       log->Printf("NativeProcessLinux::%s using process_vm_readv to read %zd "
                   "bytes from inferior address 0x%" PRIx64 ": %s",
                   __FUNCTION__, size, addr,
                   success ? "Success" : strerror(errno));
 
     if (success)
-      return Error();
+      return Error::success();
     // else
     //     the call failed for some reason, let's retry the read using ptrace
     //     api.
   }
 
   unsigned char *dst = static_cast<unsigned char *>(buf);
   size_t remainder;
   long data;
if (log && ProcessPOSIXLog::AtTopNestLevel() &&
                   __FUNCTION__, addr, uint64_t(print_dst), uint64_t(data));
     }
     addr += k_ptrace_word_size;
     dst += k_ptrace_word_size;
   }
 
   if (log)
     ProcessPOSIXLog::DecNestLevel();
-  return Error();
+  return Error::success();
 }
 
 Error NativeProcessLinux::ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf,
                                                 size_t size,
                                                 size_t &bytes_read) {
   Error error = ReadMemory(addr, buf, size, bytes_read);
   if (error.Fail())
     return error;

 
 Error NativeProcessLinux::GetEventMessage(lldb::tid_t tid,
                                           unsigned long *message) {
   return PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message);
 }
 
 Error NativeProcessLinux::Detach(lldb::tid_t tid) {
   if (tid == LLDB_INVALID_THREAD_ID)
-    return Error();
+    return Error::success();
 
   return PtraceWrapper(PTRACE_DETACH, tid);
 }
 
 bool NativeProcessLinux::HasThreadNoLock(lldb::tid_t thread_id) {
   for (auto thread_sp : m_threads) {
     assert(thread_sp && "thread list should not contain NULL threads");
     if (thread_sp->GetID() == thread_id) {
Error NativeProcessLinux::FixupBreakpointPCAsNeeded(NativeThreadLinux &thread) {
   error = m_breakpoint_list.GetBreakpoint(breakpoint_addr, breakpoint_sp);
   if (!error.Success() || !breakpoint_sp) {
     // We didn't find one at a software probe location.  Nothing to do.
     if (log)
       log->Printf(
           "NativeProcessLinux::%s pid %" PRIu64
           " no lldb breakpoint found at current pc with adjustment: 0x%" PRIx64,
           __FUNCTION__, GetID(), breakpoint_addr);
-    return Error();
+    return Error::success();
   }
 
   // If the breakpoint is not a software breakpoint, nothing to do.
   if (!breakpoint_sp->IsSoftwareBreakpoint()) {
     if (log)
       log->Printf("NativeProcessLinux::%s pid %" PRIu64
                   " breakpoint found at 0x%" PRIx64
                   ", not software, nothing to adjust",
                   __FUNCTION__, GetID(), breakpoint_addr);
-    return Error();
+    return Error::success();
   }
 
   //
   // We have a software breakpoint and need to adjust the PC.
   //
 
   // Sanity check.
   if (breakpoint_size == 0) {
     // Nothing to do!  How did we get here?
     if (log)
       log->Printf(
           "NativeProcessLinux::%s pid %" PRIu64
           " breakpoint found at 0x%" PRIx64
           ", it is software, but the size is zero, nothing to do (unexpected)",
           __FUNCTION__, GetID(), breakpoint_addr);
-    return Error();
+    return Error::success();
   }
 
   // Change the program counter.
   if (log)
     log->Printf("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64
                 ": changing PC from 0x%" PRIx64 " to 0x%" PRIx64,
                 __FUNCTION__, GetID(), thread.GetID(), initial_pc_addr,
                 breakpoint_addr);
ProcFileReader::ProcessLineByLine(
         found = true;
         return false; // we are done
       });
 
   if (!found)
     return Error("Module file (%s) not found in /proc/%" PRIu64 "/maps file!",
                  module_file_spec.GetFilename().AsCString(), GetID());
 
-  return Error();
+  return Error::success();
 }
 
 Error NativeProcessLinux::GetFileLoadAddress(const llvm::StringRef &file_name,
                                              lldb::addr_t &load_addr) {
   load_addr = LLDB_INVALID_ADDRESS;
   Error error = ProcFileReader::ProcessLineByLine(
       GetID(), "maps", [&](const std::string &line) -> bool {
         StringRef maps_row(line);

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

default:
       return Error("unhandled register data size %" PRIu32,
                    reg_info->byte_size);
     }
 
     Error error = WriteFPR();
     if (error.Fail())
       return error;
 
-    return Error();
+    return Error::success();
   }
 
   return Error("failed - register wasn't recognized to be a GPR or an FPR, "
                "write strategy unknown");
 }
 
 Error NativeRegisterContextLinux_arm::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
if (m_hwp_regs[i].control & 0x01) {
         m_hwp_regs[i].control = tempControl;
         m_hwp_regs[i].address = tempAddr;
 
         return error;
       }
     }
   }
 
-  return Error();
+  return Error::success();
 }
 
 uint32_t NativeRegisterContextLinux_arm::GetWatchpointSize(uint32_t wp_index) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
 
   if (log)
     log->Printf("NativeRegisterContextLinux_arm::%s()", __FUNCTION__);
 
Error NativeRegisterContextLinux_arm::GetWatchpointHitIndex(
 
   for (wp_index = 0; wp_index < m_max_hwp_supported; ++wp_index) {
     watch_size = GetWatchpointSize(wp_index);
     watch_addr = m_hwp_regs[wp_index].address;
 
     if (WatchpointIsEnabled(wp_index) && trap_addr >= watch_addr &&
         trap_addr < watch_addr + watch_size) {
       m_hwp_regs[wp_index].hit_addr = trap_addr;
-      return Error();
+      return Error::success();
     }
   }
 
   wp_index = LLDB_INVALID_INDEX32;
-  return Error();
+  return Error::success();
 }
 
 lldb::addr_t
 NativeRegisterContextLinux_arm::GetWatchpointAddress(uint32_t wp_index) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
 
   if (log)
     log->Printf("NativeRegisterContextLinux_arm::%s()", __FUNCTION__);
NativeRegisterContextLinux_arm::GetWatchpointHitAddress(uint32_t wp_index) {
   else
     return LLDB_INVALID_ADDRESS;
 }
 
 Error NativeRegisterContextLinux_arm::ReadHardwareDebugInfo() {
   Error error;
 
   if (!m_refresh_hwdebug_info) {
-    return Error();
+    return Error::success();
   }
 
   unsigned int cap_val;
 
   error = NativeProcessLinux::PtraceWrapper(PTRACE_GETHBPREGS, m_thread.GetID(),
                                             nullptr, &cap_val,
                                             sizeof(unsigned int));
 
Error NativeRegisterContextLinux_arm::DoReadRegisterValue(
   if (offset + sizeof(uint32_t) > sizeof(m_gpr_arm))
     return Error("Register isn't fit into the size of the GPR area");
 
   Error error = DoReadGPR(m_gpr_arm, sizeof(m_gpr_arm));
   if (error.Fail())
     return error;
 
   value.SetUInt32(m_gpr_arm[offset / sizeof(uint32_t)]);
-  return Error();
+  return Error::success();
 }
 
 Error NativeRegisterContextLinux_arm::DoWriteRegisterValue(
     uint32_t offset, const char *reg_name, const RegisterValue &value) {
   // PTRACE_POKEUSER don't work in the aarch64 linux kernel used on android
   // devices (always return
   // "Bad address"). To avoid using PTRACE_POKEUSER we read out the full GPR
   // register set, modify

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

default:
       return Error("unhandled register data size %" PRIu32,
                    reg_info->byte_size);
     }
 
     Error error = WriteFPR();
     if (error.Fail())
       return error;
 
-    return Error();
+    return Error::success();
   }
 
   return Error("failed - register wasn't recognized to be a GPR or an FPR, "
                "write strategy unknown");
 }
 
 Error NativeRegisterContextLinux_arm64::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
if (m_hwp_regs[i].control & 0x01) {
         m_hwp_regs[i].control = tempControl;
         m_hwp_regs[i].address = tempAddr;
 
         return error;
       }
     }
   }
 
-  return Error();
+  return Error::success();
 }
 
 uint32_t
 NativeRegisterContextLinux_arm64::GetWatchpointSize(uint32_t wp_index) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
 
   if (log)
     log->Printf("NativeRegisterContextLinux_arm64::%s()", __FUNCTION__);
Error NativeRegisterContextLinux_arm64::GetWatchpointHitIndex(
 
   for (wp_index = 0; wp_index < m_max_hwp_supported; ++wp_index) {
     watch_size = GetWatchpointSize(wp_index);
     watch_addr = m_hwp_regs[wp_index].address;
 
     if (WatchpointIsEnabled(wp_index) && trap_addr >= watch_addr &&
         trap_addr < watch_addr + watch_size) {
       m_hwp_regs[wp_index].hit_addr = trap_addr;
-      return Error();
+      return Error::success();
     }
   }
 
   wp_index = LLDB_INVALID_INDEX32;
-  return Error();
+  return Error::success();
 }
 
 lldb::addr_t
 NativeRegisterContextLinux_arm64::GetWatchpointAddress(uint32_t wp_index) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
 
   if (log)
     log->Printf("NativeRegisterContextLinux_arm64::%s()", __FUNCTION__);
NativeRegisterContextLinux_arm64::GetWatchpointHitAddress(uint32_t wp_index) {
   if (WatchpointIsEnabled(wp_index))
     return m_hwp_regs[wp_index].hit_addr;
   else
     return LLDB_INVALID_ADDRESS;
 }
 
 Error NativeRegisterContextLinux_arm64::ReadHardwareDebugInfo() {
   if (!m_refresh_hwdebug_info) {
-    return Error();
+    return Error::success();
   }
 
   ::pid_t tid = m_thread.GetID();
 
   int regset = NT_ARM_HW_WATCH;
   struct iovec ioVec;
   struct user_hwdebug_state dreg_state;
   Error error;

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

for (wp_index = 0; wp_index < num_hw_wps; ++wp_index) {
     Error error = IsWatchpointHit(wp_index, is_hit);
     if (error.Fail()) {
       wp_index = LLDB_INVALID_INDEX32;
     } else if (is_hit) {
       return error;
     }
   }
   wp_index = LLDB_INVALID_INDEX32;
-  return Error();
+  return Error::success();
 }
 
 Error NativeRegisterContextLinux_mips64::IsWatchpointVacant(uint32_t wp_index,
                                                             bool &is_vacant) {
   is_vacant = false;
   return Error("MIPS TODO: "
                "NativeRegisterContextLinux_mips64::IsWatchpointVacant not "
                "implemented");

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp

case 4:
       break;
     case 8:
       reg_value.SetUInt64(*(uint64_t *)src);
       break;
     default:
       assert(false && "Unhandled data size.");
       return Error("unhandled byte size: %" PRIu32, reg_info->byte_size);
     }
-    return Error();
+    return Error::success();
   }
 
   if (IsFPR(reg)) {
     s390_fp_regs fp_regs;
     Error error = DoReadFPR(&fp_regs, sizeof(fp_regs));
     if (error.Fail())
       return error;
 
     // byte_offset is just the offset within FPR, not the whole user area.
     uint8_t *src = (uint8_t *)&fp_regs + reg_info->byte_offset;
     assert(reg_info->byte_offset + reg_info->byte_size <= sizeof(fp_regs));
     switch (reg_info->byte_size) {
     case 4:
       reg_value.SetUInt32(*(uint32_t *)src);
       break;
     case 8:
       reg_value.SetUInt64(*(uint64_t *)src);
       break;
     default:
       assert(false && "Unhandled data size.");
       return Error("unhandled byte size: %" PRIu32, reg_info->byte_size);
     }
-    return Error();
+    return Error::success();
   }
 
   if (reg == lldb_last_break_s390x) {
     uint64_t last_break;
     Error error = DoReadRegisterSet(NT_S390_LAST_BREAK, &last_break, 8);
     if (error.Fail())
       return error;
 
     reg_value.SetUInt64(last_break);
-    return Error();
+    return Error::success();
   }
 
   if (reg == lldb_system_call_s390x) {
     uint32_t system_call;
     Error error = DoReadRegisterSet(NT_S390_SYSTEM_CALL, &system_call, 4);
     if (error.Fail())
       return error;
 
     reg_value.SetUInt32(system_call);
-    return Error();
+    return Error::success();
   }
 
   return Error("failed - register wasn't recognized");
 }
 
 Error NativeRegisterContextLinux_s390x::WriteRegister(
     const RegisterInfo *reg_info, const RegisterValue &reg_value) {
   if (!reg_info)
Error NativeRegisterContextLinux_s390x::IsWatchpointHit(uint32_t wp_index,
                                                         bool &is_hit) {
   per_lowcore_bits per_lowcore;
 
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Error("Watchpoint index out of range");
 
   if (m_watchpoint_addr == LLDB_INVALID_ADDRESS) {
     is_hit = false;
-    return Error();
+    return Error::success();
   }
 
   Error error = PeekUserArea(offsetof(user_regs_struct, per_info.lowcore),
                              &per_lowcore, sizeof(per_lowcore));
   if (error.Fail()) {
     is_hit = false;
     return error;
   }
 
   is_hit = (per_lowcore.perc_storage_alteration == 1 &&
             per_lowcore.perc_store_real_address == 0);
 
   if (is_hit) {
     // Do not report this watchpoint again.
     memset(&per_lowcore, 0, sizeof(per_lowcore));
     PokeUserArea(offsetof(user_regs_struct, per_info.lowcore), &per_lowcore,
                  sizeof(per_lowcore));
   }
 
-  return Error();
+  return Error::success();
 }
 
 Error NativeRegisterContextLinux_s390x::GetWatchpointHitIndex(
     uint32_t &wp_index, lldb::addr_t trap_addr) {
   uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
   for (wp_index = 0; wp_index < num_hw_wps; ++wp_index) {
     bool is_hit;
     Error error = IsWatchpointHit(wp_index, is_hit);
     if (error.Fail()) {
       wp_index = LLDB_INVALID_INDEX32;
       return error;
     } else if (is_hit) {
       return error;
     }
   }
   wp_index = LLDB_INVALID_INDEX32;
-  return Error();
+  return Error::success();
 }
 
 Error NativeRegisterContextLinux_s390x::IsWatchpointVacant(uint32_t wp_index,
                                                            bool &is_vacant) {
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Error("Watchpoint index out of range");
 
   is_vacant = m_watchpoint_addr == LLDB_INVALID_ADDRESS;
 
-  return Error();
+  return Error::success();
 }
 
 bool NativeRegisterContextLinux_s390x::ClearHardwareWatchpoint(
     uint32_t wp_index) {
   per_struct per_info;
 
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return false;
if (error.Fail())
     return false;
 
   m_watchpoint_addr = LLDB_INVALID_ADDRESS;
   return true;
 }
 
 Error NativeRegisterContextLinux_s390x::ClearAllHardwareWatchpoints() {
   if (ClearHardwareWatchpoint(0))
-    return Error();
+    return Error::success();
   return Error("Clearing all hardware watchpoints failed.");
 }
 
 uint32_t NativeRegisterContextLinux_s390x::SetHardwareWatchpoint(
     lldb::addr_t addr, size_t size, uint32_t watch_flags) {
   per_struct per_info;
 
   if (watch_flags != 0x1)

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

if (IsAVX(reg_index)) {
       if (!CopyYMMtoXSTATE(reg_index, GetByteOrder()))
         return Error("CopyYMMtoXSTATE() failed");
     }
 
     if (IsMPX(reg_index)) {
       if (!CopyMPXtoXSTATE(reg_index))
         return Error("CopyMPXtoXSTATE() failed");
     }
-    return Error();
+    return Error::success();
   }
   return Error("failed - register wasn't recognized to be a GPR or an FPR, "
                "write strategy unknown");
 }
 
 Error NativeRegisterContextLinux_x86_64::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
   Error error;
for (wp_index = 0; wp_index < num_hw_wps; ++wp_index) {
     if (error.Fail()) {
       wp_index = LLDB_INVALID_INDEX32;
       return error;
     } else if (is_hit) {
       return error;
     }
   }
   wp_index = LLDB_INVALID_INDEX32;
-  return Error();
+  return Error::success();
 }
 
 Error NativeRegisterContextLinux_x86_64::IsWatchpointVacant(uint32_t wp_index,
                                                             bool &is_vacant) {
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Error("Watchpoint index out of range");
 
   RegisterValue reg_value;

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

NativeRegisterContextSP NativeThreadLinux::GetRegisterContext() {
   return m_reg_context_sp;
 }
 
 Error NativeThreadLinux::SetWatchpoint(lldb::addr_t addr, size_t size,
                                        uint32_t watch_flags, bool hardware) {
   if (!hardware)
     return Error("not implemented");
   if (m_state == eStateLaunching)
-    return Error();
+    return Error::success();
   Error error = RemoveWatchpoint(addr);
   if (error.Fail())
     return error;
   NativeRegisterContextSP reg_ctx = GetRegisterContext();
   uint32_t wp_index = reg_ctx->SetHardwareWatchpoint(addr, size, watch_flags);
   if (wp_index == LLDB_INVALID_INDEX32)
     return Error("Setting hardware watchpoint failed.");
   m_watchpoint_index_map.insert({addr, wp_index});
-  return Error();
+  return Error::success();
 }
 
 Error NativeThreadLinux::RemoveWatchpoint(lldb::addr_t addr) {
   auto wp = m_watchpoint_index_map.find(addr);
   if (wp == m_watchpoint_index_map.end())
-    return Error();
+    return Error::success();
   uint32_t wp_index = wp->second;
   m_watchpoint_index_map.erase(wp);
   if (GetRegisterContext()->ClearHardwareWatchpoint(wp_index))
-    return Error();
+    return Error::success();
   return Error("Clearing hardware watchpoint failed.");
 }
 
 Error NativeThreadLinux::Resume(uint32_t signo) {
   const StateType new_state = StateType::eStateRunning;
   MaybeLogStateChange(new_state);
   m_state = new_state;
 

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 lldb_private::DynamicLoader *ProcessKDP::GetDynamicLoader() {
   if (m_dyld_ap.get() == NULL)
     m_dyld_ap.reset(DynamicLoader::FindPlugin(
         this,
         m_dyld_plugin_name.IsEmpty() ? NULL : m_dyld_plugin_name.GetCString()));
   return m_dyld_ap.get();
 }
 
-Error ProcessKDP::WillResume() { return Error(); }
+Error ProcessKDP::WillResume() { return Error::success(); }
 
 Error ProcessKDP::DoResume() {
   Error error;
   Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
   // Only start the async thread if we try to do any process control
   if (!m_async_thread.IsJoinable())
     StartAsyncThread();
 

lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp

StateType private_state;
 
     private_state = GetPrivateState();
 
     if (!m_session_data) {
       WINWARN_IFALL(
           WINDOWS_LOG_PROCESS,
           "DoDetach called while state = %u, but there is no active session.",
           private_state);
-      return Error();
+      return Error::success();
     }
 
     debugger_thread = m_session_data->m_debugger;
   }
 
   Error error;
   if (private_state != eStateExited && private_state != eStateDetached) {
     WINLOG_IFALL(
StateType private_state;
 
     private_state = GetPrivateState();
 
     if (!m_session_data) {
       WINWARN_IFALL(
           WINDOWS_LOG_PROCESS,
           "DoDestroy called while state = %u, but there is no active session.",
           private_state);
-      return Error();
+      return Error::success();
     }
 
     debugger_thread = m_session_data->m_debugger;
   }
 
   Error error;
   if (private_state != eStateExited && private_state != eStateDetached) {
     WINLOG_IFALL(

lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

 }
 
 void ProcessWinMiniDump::RefreshStateAfterStop() {
   if (!m_impl_up)
     return;
   return m_impl_up->RefreshStateAfterStop();
 }
 
-Error ProcessWinMiniDump::DoDestroy() { return Error(); }
+Error ProcessWinMiniDump::DoDestroy() { return Error::success(); }
 
 bool ProcessWinMiniDump::IsAlive() { return true; }
 
 bool ProcessWinMiniDump::WarnBeforeDetach() const {
   // Since this is post-mortem debugging, there's no need to warn the user
   // that quitting the debugger will terminate the process.
   return false;
 }

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

for (lldb::tid_t tid = 0; tid < num_threads; ++tid) {
     lldb::ThreadSP thread_sp(new ThreadElfCore(*this, td));
     new_thread_list.AddThread(thread_sp);
   }
   return new_thread_list.GetSize(false) > 0;
 }
 
 void ProcessElfCore::RefreshStateAfterStop() {}
 
-Error ProcessElfCore::DoDestroy() { return Error(); }
+Error ProcessElfCore::DoDestroy() { return Error::success(); }
 
 //------------------------------------------------------------------
 // Process Queries
 //------------------------------------------------------------------
 
 bool ProcessElfCore::IsAlive() { return true; }
 
 //------------------------------------------------------------------
if (permission_entry) {
     } else if (load_addr < permission_entry->GetRangeBase()) {
       region_info.GetRange().SetRangeBase(load_addr);
       region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
       region_info.SetReadable(MemoryRegionInfo::eNo);
       region_info.SetWritable(MemoryRegionInfo::eNo);
       region_info.SetExecutable(MemoryRegionInfo::eNo);
       region_info.SetMapped(MemoryRegionInfo::eNo);
     }
-    return Error();
+    return Error::success();
   }
 
   region_info.GetRange().SetRangeBase(load_addr);
   region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
   region_info.SetReadable(MemoryRegionInfo::eNo);
   region_info.SetWritable(MemoryRegionInfo::eNo);
   region_info.SetExecutable(MemoryRegionInfo::eNo);
   region_info.SetMapped(MemoryRegionInfo::eNo);
-  return Error();
+  return Error::success();
 }
 
 size_t ProcessElfCore::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                     Error &error) {
   ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
 
   if (core_objfile == NULL)
     return 0;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
     if (signo_ptr)
       *signo_ptr = signo;
     if (response.GetChar() != ',')
       return Error("malformed reply");
     std::string output;
     response.GetEscapedBinaryData(output);
     if (command_output)
       command_output->assign(output);
-    return Error();
+    return Error::success();
   }
   return Error("unable to send packet");
 }
 
 Error GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec,
                                                   uint32_t file_permissions) {
   std::string path{file_spec.GetPath(false)};
   lldb_private::StreamString stream;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 
 Error GDBRemoteCommunicationServerLLGS::SetLaunchArguments(
     const char *const args[], int argc) {
   if ((argc < 1) || !args || !args[0] || !args[0][0])
     return Error("%s: no process command line specified to launch",
                  __FUNCTION__);
 
   m_process_launch_info.SetArguments(const_cast<const char **>(args), true);
-  return Error();
+  return Error::success();
 }
 
 Error GDBRemoteCommunicationServerLLGS::SetLaunchFlags(
     unsigned int launch_flags) {
   m_process_launch_info.GetFlags().Set(launch_flags);
-  return Error();
+  return Error::success();
 }
 
 Error GDBRemoteCommunicationServerLLGS::LaunchProcess() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   if (!m_process_launch_info.GetArguments().GetArgumentCount())
     return Error("%s: no process command line specified to launch",
                  __FUNCTION__);
Error GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) {
   m_stdio_communication.SetCloseOnEOF(false);
   m_stdio_communication.SetConnection(conn_up.release());
   if (!m_stdio_communication.IsConnected()) {
     error.SetErrorString(
         "failed to set connection for inferior I/O communication");
     return error;
   }
 
-  return Error();
+  return Error::success();
 }
 
 void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() {
   // Don't forward if not connected (e.g. when attaching).
   if (!m_stdio_communication.IsConnected())
     return;
 
   Error error;

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 
 Error ProcessGDBRemote::WillResume() {
   m_continue_c_tids.clear();
   m_continue_C_tids.clear();
   m_continue_s_tids.clear();
   m_continue_S_tids.clear();
   m_jstopinfo_sp.reset();
   m_jthreadsinfo_sp.reset();
-  return Error();
+  return Error::success();
 }
 
 Error ProcessGDBRemote::DoResume() {
   Error error;
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
   if (log)
     log->Printf("ProcessGDBRemote::Resume()");
 
if (!m_gdb_comm.SendAsyncSignal(signo))
     error.SetErrorStringWithFormat("failed to send signal %i", signo);
   return error;
 }
 
 Error ProcessGDBRemote::EstablishConnectionIfNeeded(
     const ProcessInfo &process_info) {
   // Make sure we aren't already connected?
   if (m_gdb_comm.IsConnected())
-    return Error();
+    return Error::success();
 
   PlatformSP platform_sp(GetTarget().GetPlatform());
   if (platform_sp && !platform_sp->IsHost())
     return Error("Lost debug server connection");
 
   auto error = LaunchAndConnectToDebugserver(process_info);
   if (error.Fail()) {
     const char *error_string = error.AsCString();
if (log)
       log->Printf("parsing: %s", raw.c_str());
     XMLDocument doc;
 
     if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
       return Error(0, ErrorType::eErrorTypeGeneric);
 
     XMLNode root_element = doc.GetRootElement("library-list-svr4");
     if (!root_element)
-      return Error();
+      return Error::success();
 
     // main link map structure
     llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
     if (!main_lm.empty()) {
       list.m_link_map =
           StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS, 0);
     }
 
if (log)
       log->Printf("parsing: %s", raw.c_str());
     XMLDocument doc;
 
     if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
       return Error(0, ErrorType::eErrorTypeGeneric);
 
     XMLNode root_element = doc.GetRootElement("library-list");
     if (!root_element)
-      return Error();
+      return Error::success();
 
     root_element.ForEachChildElementWithName(
         "library", [log, &list](const XMLNode &library) -> bool {
           LoadedModuleInfoList::LoadedModuleInfo module;
 
           llvm::StringRef name = library.GetAttributeValue("name");
           module.set_name(name.str());
 
if (comm.GetQXferLibrariesSVR4ReadSupported()) {
 
     if (log)
       log->Printf("found %" PRId32 " modules in total",
                   (int)list.m_list.size());
   } else {
     return Error(0, ErrorType::eErrorTypeGeneric);
   }
 
-  return Error();
+  return Error::success();
 }
 
 lldb::ModuleSP ProcessGDBRemote::LoadModuleAtAddress(const FileSpec &file,
                                                      lldb::addr_t link_map,
                                                      lldb::addr_t base_addr,
                                                      bool value_is_offset) {
   DynamicLoader *loader = GetDynamicLoader();
   if (!loader)
if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
       GDBRemoteCommunication::PacketResult::Success)
     return Error("Sending qFileLoadAddress packet failed");
 
   if (response.IsErrorResponse()) {
     if (response.GetError() == 1) {
       // The file is not loaded into the inferior
       is_loaded = false;
       load_addr = LLDB_INVALID_ADDRESS;
-      return Error();
+      return Error::success();
     }
 
     return Error(
         "Fetching file load address from remote server returned an error");
   }
 
   if (response.IsNormalResponse()) {
     is_loaded = true;
     load_addr = response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
-    return Error();
+    return Error::success();
   }
 
   return Error("Unknown error happened during sending the load address packet");
 }
 
 void ProcessGDBRemote::ModulesDidLoad(ModuleList &module_list) {
   // We must call the lldb_private::Process::ModulesDidLoad () first before we
   // do anything

lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

 
 void ProcessMachCore::RefreshStateAfterStop() {
   // Let all threads recover from stopping and do any clean up based
   // on the previous thread state (if any).
   m_thread_list.RefreshStateAfterStop();
   // SetThreadStopInfo (m_last_stop_packet);
 }
 
-Error ProcessMachCore::DoDestroy() { return Error(); }
+Error ProcessMachCore::DoDestroy() { return Error::success(); }
 
 //------------------------------------------------------------------
 // Process Queries
 //------------------------------------------------------------------
 
 bool ProcessMachCore::IsAlive() { return true; }
 
 bool ProcessMachCore::WarnBeforeDetach() const { return false; }
if (permission_entry) {
     } else if (load_addr < permission_entry->GetRangeBase()) {
       region_info.GetRange().SetRangeBase(load_addr);
       region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
       region_info.SetReadable(MemoryRegionInfo::eNo);
       region_info.SetWritable(MemoryRegionInfo::eNo);
       region_info.SetExecutable(MemoryRegionInfo::eNo);
       region_info.SetMapped(MemoryRegionInfo::eNo);
     }
-    return Error();
+    return Error::success();
   }
 
   region_info.GetRange().SetRangeBase(load_addr);
   region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
   region_info.SetReadable(MemoryRegionInfo::eNo);
   region_info.SetWritable(MemoryRegionInfo::eNo);
   region_info.SetExecutable(MemoryRegionInfo::eNo);
   region_info.SetMapped(MemoryRegionInfo::eNo);
-  return Error();
+  return Error::success();
 }
 
 void ProcessMachCore::Clear() { m_thread_list.Clear(); }
 
 void ProcessMachCore::Initialize() {
   static std::once_flag g_once_flag;
 
   std::call_once(g_once_flag, []() {

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

if (m_dyld_ap.get() == nullptr)
     m_dyld_ap.reset(DynamicLoader::FindPlugin(this, nullptr));
   return m_dyld_ap.get();
 }
 
 ConstString ProcessMinidump::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t ProcessMinidump::GetPluginVersion() { return 1; }
 
-Error ProcessMinidump::DoDestroy() { return Error(); }
+Error ProcessMinidump::DoDestroy() { return Error::success(); }
 
 void ProcessMinidump::RefreshStateAfterStop() {
   if (!m_active_exception)
     return;
 
   if (m_active_exception->exception_record.exception_code ==
       MinidumpException::DumpRequested) {
     return;

lldb/source/Target/Platform.cpp

if (platform_sp) {
     GetPlatformList().push_back(platform_sp);
   }
 }
 
 Error Platform::GetFileWithUUID(const FileSpec &platform_file,
                                 const UUID *uuid_ptr, FileSpec &local_file) {
   // Default to the local case
   local_file = platform_file;
-  return Error();
+  return Error::success();
 }
 
 FileSpecList
 Platform::LocateExecutableScriptingResources(Target *target, Module &module,
                                              Stream *feedback_stream) {
   return FileSpecList();
 }
 
Error Platform::KillProcess(const lldb::pid_t pid) {
   }
 
   if (!IsHost()) {
     return Error(
         "base lldb_private::Platform class can't kill remote processes unless "
         "they are controlled by a process plugin");
   }
   Host::Kill(pid, SIGTERM);
-  return Error();
+  return Error::success();
 }
 
 lldb::ProcessSP
 Platform::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
                        Target *target, // Can be nullptr, if nullptr create a
                                        // new target, else use existing one
                        Error &error) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
Error Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
   if (module_spec.GetUUID().IsValid()) {
     resolved_module_spec.GetUUID() = module_spec.GetUUID();
   }
 
   // Trying to find a module by UUID on local file system.
   const auto error = module_resolver(resolved_module_spec);
   if (error.Fail()) {
     if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
-      return Error();
+      return Error::success();
   }
 
   return error;
 }
 
 bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
                                      lldb::ModuleSP &module_sp,
                                      bool *did_create_ptr) {

lldb/source/Target/Process.cpp

Error Process::Halt(bool clear_thread_plans, bool use_run_lock) {
   SendAsyncInterrupt();
 
   if (m_public_state.GetValue() == eStateAttaching) {
     // Don't hijack and eat the eStateExited as the code that was doing
     // the attach will be waiting for this event...
     RestoreProcessEvents();
     SetExitStatus(SIGKILL, "Cancelled async attach.");
     Destroy(false);
-    return Error();
+    return Error::success();
   }
 
   // Wait for 10 second for the process to stop.
   StateType state =
       WaitForProcessToStop(std::chrono::seconds(10), &event_sp, true,
                            halt_listener_sp, nullptr, use_run_lock);
   RestoreProcessEvents();
 
   if (state == eStateInvalid || !event_sp) {
     // We timed out and didn't get a stop event...
     return Error("Halt timed out. State = %s", StateAsCString(GetState()));
   }
 
   BroadcastEvent(event_sp);
 
-  return Error();
+  return Error::success();
 }
 
 Error Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
   Error error;
 
   // Check both the public & private states here.  If we're hung evaluating an
   // expression, for instance, then
   // the public state will be stopped, but we still need to interrupt.

lldb/source/Target/Thread.cpp

sstr.Printf("%s:%i appears multiple times in this function, selecting the "
                 file.GetFilename().AsCString(), line);
     DumpAddressList(sstr, candidates, target);
     *warnings = sstr.GetString();
   }
 
   if (!reg_ctx->SetPC(dest))
     return Error("Cannot change PC to target address.");
 
-  return Error();
+  return Error::success();
 }
 
 void Thread::DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx,
                                      bool stop_format) {
   ExecutionContext exe_ctx(shared_from_this());
   Process *process = exe_ctx.GetProcessPtr();
   if (process == nullptr)
     return;

lldb/source/Utility/ModuleCache.cpp

FileSpec JoinPath(const FileSpec &path1, const char *path2) {
   return result_spec;
 }
 
 Error MakeDirectory(const FileSpec &dir_path) {
   if (dir_path.Exists()) {
     if (!dir_path.IsDirectory())
       return Error("Invalid existing path");
 
-    return Error();
+    return Error::success();
   }
 
   return FileSystem::MakeDirectory(dir_path, eFilePermissionsDirectoryDefault);
 }
 
 FileSpec GetModuleDirectory(const FileSpec &root_dir_spec, const UUID &uuid) {
   const auto modules_dir_spec = JoinPath(root_dir_spec, kModulesSubdir);
   return JoinPath(modules_dir_spec, uuid.GetAsString().c_str());
Error CreateHostSysRootModuleLink(const FileSpec &root_dir_spec,
                                   const FileSpec &platform_module_spec,
                                   const FileSpec &local_module_spec,
                                   bool delete_existing) {
   const auto sysroot_module_path_spec =
       JoinPath(JoinPath(root_dir_spec, hostname),
                platform_module_spec.GetPath().c_str());
   if (sysroot_module_path_spec.Exists()) {
     if (!delete_existing)
-      return Error();
+      return Error::success();
 
     DecrementRefExistingModule(root_dir_spec, sysroot_module_path_spec);
   }
 
   const auto error = MakeDirectory(
       FileSpec(sysroot_module_path_spec.GetDirectory().AsCString(), false));
   if (error.Fail())
     return error;
return Error("Failed to rename file %s to %s: %s", tmp_file_path.c_str(),
                  module_file_path.GetPath().c_str(),
                  err_code.message().c_str());
 
   const auto error = CreateHostSysRootModuleLink(
       root_dir_spec, hostname, target_file, module_file_path, true);
   if (error.Fail())
     return Error("Failed to create link to %s: %s",
                  module_file_path.GetPath().c_str(), error.AsCString());
-  return Error();
+  return Error::success();
 }
 
 Error ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
                        const ModuleSpec &module_spec,
                        ModuleSP &cached_module_sp, bool *did_create_ptr) {
   const auto find_it =
       m_loaded_modules.find(module_spec.GetUUID().GetAsString());
   if (find_it != m_loaded_modules.end()) {
     cached_module_sp = (*find_it).second.lock();
     if (cached_module_sp)
-      return Error();
+      return Error::success();
     m_loaded_modules.erase(find_it);
   }
 
   const auto module_spec_dir =
       GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
   const auto module_file_path = JoinPath(
       module_spec_dir, module_spec.GetFileSpec().GetFilename().AsCString());
 
Error ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
 
   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
   if (symfile_spec.Exists())
     cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
 
   m_loaded_modules.insert(
       std::make_pair(module_spec.GetUUID().GetAsString(), cached_module_sp));
 
-  return Error();
+  return Error::success();
 }
 
 Error ModuleCache::GetAndPut(const FileSpec &root_dir_spec,
                              const char *hostname,
                              const ModuleSpec &module_spec,
                              const ModuleDownloader &module_downloader,
                              const SymfileDownloader &symfile_downloader,
                              lldb::ModuleSP &cached_module_sp,
const auto tmp_download_sym_file_spec =
       JoinPath(module_spec_dir, kTempSymFileName);
   error = symfile_downloader(cached_module_sp, tmp_download_sym_file_spec);
   llvm::FileRemover tmp_symfile_remover(tmp_download_sym_file_spec.GetPath());
   if (error.Fail())
     // Failed to download a symfile but fetching the module was successful. The
     // module might
     // contain the necessary symbols and the debugging is also possible without
     // a symfile.
-    return Error();
+    return Error::success();
 
   error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
               tmp_download_sym_file_spec,
               GetSymbolFileSpec(module_spec.GetFileSpec()));
   if (error.Fail())
     return Error("Failed to put symbol file into cache: %s", error.AsCString());
 
   tmp_symfile_remover.releaseFile();
 
   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
   cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
-  return Error();
+  return Error::success();
 }

lldb/tools/lldb-server/lldb-platform.cpp

static Error save_socket_id_to_file(const std::string &socket_id,
   }
 
   err_code = llvm::sys::fs::rename(temp_file_path.c_str(), file_spec.GetPath());
   if (err_code)
     return Error("Failed to rename file %s to %s: %s", temp_file_path.c_str(),
                  file_spec.GetPath().c_str(), err_code.message().c_str());
 
   tmp_file_remover.releaseFile();
-  return Error();
+  return Error::success();
 }
 
 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int main_platform(int argc, char *argv[]) {
   const char *progname = argv[0];
   const char *subcommand = argv[1];

lldb/unittests/Utility/ModuleCacheTest.cpp

Error error = mc.GetAndPut(
       [this, &download_called](const ModuleSpec &module_spec,
                                const FileSpec &tmp_download_file_spec) {
         download_called = true;
         EXPECT_STREQ(GetDummyRemotePath().GetCString(),
                      module_spec.GetFileSpec().GetCString());
         std::error_code ec = llvm::sys::fs::copy_file(
             s_test_executable, tmp_download_file_spec.GetCString());
         EXPECT_FALSE(ec);
-        return Error();
+        return Error::success();
       },
       [](const ModuleSP &module_sp, const FileSpec &tmp_download_file_spec) {
         return Error("Not supported.");
       },
       module_sp, &did_create);
   EXPECT_EQ(expect_download, download_called);
 
   EXPECT_TRUE(error.Success()) << "Error was: " << error.AsCString();

llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h

private:
 
     OrcRemoteTargetClient &Remote;
   };
 
   /// Create an OrcRemoteTargetClient.
   /// Channel is the ChannelT instance to communicate on. It is assumed that
   /// the channel is ready to be read from and written to.
   static Expected<OrcRemoteTargetClient> Create(ChannelT &Channel) {
-    Error Err;
+    Error Err = Error::success();
     OrcRemoteTargetClient H(Channel, Err);
     if (Err)
       return std::move(Err);
     return Expected<OrcRemoteTargetClient>(std::move(H));
   }
 
   /// Call the int(void) function at the given address in the target and return
   /// its result.
if (ExistingError)
       return std::move(ExistingError);
 
     return callST<WritePtr>(Channel, Addr, PtrVal);
   }
 
   static Error doNothing() { return Error::success(); }
 
   ChannelT &Channel;
-  Error ExistingError;
+  Error ExistingError = Error::success();
   std::string RemoteTargetTriple;
   uint32_t RemotePointerSize = 0;
   uint32_t RemotePageSize = 0;
   uint32_t RemoteTrampolineSize = 0;
   uint32_t RemoteIndirectStubSize = 0;
   ResourceIdMgr AllocatorIds, IndirectStubOwnerIds;
   Optional<RCCompileCallbackManager> CallbackManager;
 };
 
 } // end namespace remote
 } // end namespace orc
 } // end namespace llvm
 
 #undef DEBUG_TYPE
 
 #endif // LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H

llvm/include/llvm/Support/Error.h

class LLVM_NODISCARD Error {
   // handleErrors needs to be able to set the Checked flag.
   template <typename... HandlerTs>
   friend Error handleErrors(Error E, HandlerTs &&... Handlers);
 
   // Expected<T> needs to be able to steal the payload when constructed from an
   // error.
   template <typename T> friend class Expected;
 
-public:
+protected:
   /// Create a success value. Prefer using 'Error::success()' for readability
-  /// where possible.
   Error() : Payload(nullptr) {
     setPtr(nullptr);
     setChecked(false);
   }
 
+public:
   /// Create a success value. This is equivalent to calling the default
   /// constructor, but should be preferred for readability where possible.
   static Error success() { return Error(); }
 
   // Errors are not copy-constructable.
   Error(const Error &Other) = delete;
 
   /// Move-construct an error value. The newly constructed error is considered
   /// unchecked, even if the source error had been checked. The original error

llvm/lib/LTO/LTO.cpp

for (const InputFile::Symbol &Sym : Input->symbols()) {
     GlobalValue *GV = Input->Obj->getSymbolGV(Sym.I->getRawDataRefImpl());
     if (Res.Prevailing && GV)
       ThinLTO.PrevailingModuleForGUID[GV->getGUID()] =
           MBRef.getBufferIdentifier();
   }
   assert(ResI == Res.end());
 
   ThinLTO.ModuleMap[MBRef.getBufferIdentifier()] = MBRef;
-  return Error();
+  return Error::success();
 }
 
 unsigned LTO::getMaxTasks() const {
   CalledGetMaxTasks = true;
   return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
 }
 
 Error LTO::run(AddStreamFn AddStream, NativeObjectCache Cache) {
if (OldGV) {
       OldGV->eraseFromParent();
     } else {
       GV->setName(I.first);
     }
   }
 
   if (Conf.PreOptModuleHook &&
       !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
-    return Error();
+    return Error::success();
 
   if (!Conf.CodeGenOnly) {
     for (const auto &R : GlobalResolutions) {
       if (R.second.IRName.empty())
         continue;
       if (R.second.Partition != 0 &&
           R.second.Partition != GlobalResolution::External)
         continue;
 
       GlobalValue *GV =
           RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
       // Ignore symbols defined in other partitions.
       if (!GV || GV->hasLocalLinkage())
         continue;
       GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
                                               : GlobalValue::UnnamedAddr::None);
       if (R.second.Partition == 0)
         GV->setLinkage(GlobalValue::InternalLinkage);
     }
 
     if (Conf.PostInternalizeModuleHook &&
         !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
-      return Error();
+      return Error::success();
   }
   return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
                  std::move(RegularLTO.CombinedModule));
 }
 
 /// This class defines the interface to the ThinLTO backend.
 class lto::ThinBackendProc {
 protected:
Error runThinLTOBackendThread(
 
     SmallString<40> Key;
     // The module may be cached, this helps handling it.
     computeCacheKey(Key, CombinedIndex, ModuleID, ImportList, ExportList,
                     ResolvedODR, DefinedGlobals);
     if (AddStreamFn CacheAddStream = Cache(Task, Key))
       return RunThinBackend(CacheAddStream);
 
-    return Error();
+    return Error::success();
   }
 
   Error start(
       unsigned Task, MemoryBufferRef MBRef,
       const FunctionImporter::ImportMapTy &ImportList,
       const FunctionImporter::ExportSetTy &ExportList,
       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
       MapVector<StringRef, MemoryBufferRef> &ModuleMap) override {
BackendThreadPool.async(
               Err = joinErrors(std::move(*Err), std::move(E));
             else
               Err = std::move(E);
           }
         },
         MBRef, std::ref(CombinedIndex), std::ref(ImportList),
         std::ref(ExportList), std::ref(ResolvedODR), std::ref(DefinedGlobals),
         std::ref(ModuleMap));
-    return Error();
+    return Error::success();
   }
 
   Error wait() override {
     BackendThreadPool.wait();
     if (Err)
       return std::move(*Err);
     else
-      return Error();
+      return Error::success();
   }
 };
 
 ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) {
   return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
              const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
              AddStreamFn AddStream, NativeObjectCache Cache) {
     return llvm::make_unique<InProcessThinBackend>(
raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
                       sys::fs::OpenFlags::F_None);
     if (EC)
       return errorCodeToError(EC);
     WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
 
     if (ShouldEmitImportsFiles)
       return errorCodeToError(
           EmitImportsFiles(ModulePath, NewModulePath + ".imports", ImportList));
-    return Error();
+    return Error::success();
   }
 
-  Error wait() override { return Error(); }
+  Error wait() override { return Error::success(); }
 };
 
 ThinBackend lto::createWriteIndexesThinBackend(std::string OldPrefix,
                                                std::string NewPrefix,
                                                bool ShouldEmitImportsFiles,
                                                std::string LinkedObjectsFile) {
   return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
              const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
              AddStreamFn AddStream, NativeObjectCache Cache) {
     return llvm::make_unique<WriteIndexesThinBackend>(
         Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
         ShouldEmitImportsFiles, LinkedObjectsFile);
   };
 }
 
 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
                       bool HasRegularLTO) {
   if (ThinLTO.ModuleMap.empty())
-    return Error();
+    return Error::success();
 
   if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
-    return Error();
+    return Error::success();
 
   // Collect for each module the list of function it defines (GUID ->
   // Summary).
   StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
       ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
   ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
       ModuleToDefinedGVSummaries);
   // Create entries for any modules that didn't have any GV summaries

llvm/lib/LTO/LTOBackend.cpp

CombinedIndexHook = [=](const ModuleSummaryIndex &Index) {
     // Because -save-temps is a debugging feature, we report the error
     // directly and exit.
     if (EC)
       reportOpenError(Path, EC.message());
     WriteIndexToFile(Index, OS);
     return true;
   };
 
-  return Error();
+  return Error::success();
 }
 
 namespace {
 
 std::unique_ptr<TargetMachine>
 createTargetMachine(Config &Conf, StringRef TheTriple,
                     const Target *TheTarget) {
   SubtargetFeatures Features;
Error lto::backend(Config &C, AddStreamFn AddStream,
 
   std::unique_ptr<TargetMachine> TM =
       createTargetMachine(C, Mod->getTargetTriple(), *TOrErr);
 
   handleAsmUndefinedRefs(*Mod, *TM);
 
   if (!C.CodeGenOnly)
     if (!opt(C, TM.get(), 0, *Mod, /*IsThinLto=*/false))
-      return Error();
+      return Error::success();
 
   if (ParallelCodeGenParallelismLevel == 1) {
     codegen(C, TM.get(), AddStream, 0, *Mod);
   } else {
     splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel,
                  std::move(Mod));
   }
-  return Error();
+  return Error::success();
 }
 
 Error lto::thinBackend(Config &Conf, unsigned Task, AddStreamFn AddStream,
                        Module &Mod, ModuleSummaryIndex &CombinedIndex,
                        const FunctionImporter::ImportMapTy &ImportList,
                        const GVSummaryMapTy &DefinedGlobals,
                        MapVector<StringRef, MemoryBufferRef> &ModuleMap) {
   Expected<const Target *> TOrErr = initAndLookupTarget(Conf, Mod);
   if (!TOrErr)
     return TOrErr.takeError();
 
   std::unique_ptr<TargetMachine> TM =
       createTargetMachine(Conf, Mod.getTargetTriple(), *TOrErr);
 
   handleAsmUndefinedRefs(Mod, *TM);
 
   if (Conf.CodeGenOnly) {
     codegen(Conf, TM.get(), AddStream, Task, Mod);
-    return Error();
+    return Error::success();
   }
 
   if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
-    return Error();
+    return Error::success();
 
   renameModuleForThinLTO(Mod, CombinedIndex);
 
   thinLTOResolveWeakForLinkerModule(Mod, DefinedGlobals);
 
   if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
-    return Error();
+    return Error::success();
 
   if (!DefinedGlobals.empty())
     thinLTOInternalizeModule(Mod, DefinedGlobals);
 
   if (Conf.PostInternalizeModuleHook &&
       !Conf.PostInternalizeModuleHook(Task, Mod))
-    return Error();
+    return Error::success();
 
   auto ModuleLoader = [&](StringRef Identifier) {
     assert(Mod.getContext().isODRUniquingDebugTypes() &&
            "ODR Type uniquing should be enabled on the context");
     return std::move(getLazyBitcodeModule(ModuleMap[Identifier],
                                           Mod.getContext(),
                                           /*ShouldLazyLoadMetadata=*/true)
                          .get());
   };
 
   FunctionImporter Importer(CombinedIndex, ModuleLoader);
   if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
     return Err;
 
   if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
-    return Error();
+    return Error::success();
 
   if (!opt(Conf, TM.get(), Task, Mod, /*IsThinLto=*/true))
-    return Error();
+    return Error::success();
 
   codegen(Conf, TM.get(), AddStream, Task, Mod);
-  return Error();
+  return Error::success();
 }

llvm/lib/Object/Archive.cpp

if (NextLoc > Parent->Data.getBufferEnd()) {
     if (!NameOrErr) {
       consumeError(NameOrErr.takeError());
       uint64_t Offset = Data.data() - Parent->getData().data();
       return malformedError(Msg + "at offset " + Twine(Offset));
     } else
       return malformedError(Msg + NameOrErr.get());
   }
 
-  Error Err;
+  Error Err = Error::success();
   Child Ret(Parent, NextLoc, &Err);
   if (Err)
     return std::move(Err);
   return Ret;
 }
 
 uint64_t Archive::Child::getChildOffset() const {
   const char *a = Parent->Data.getBuffer().data();
Archive::Child::getAsBinary(LLVMContext *Context) const {
 
   auto BinaryOrErr = createBinary(BuffOrErr.get(), Context);
   if (BinaryOrErr)
     return std::move(*BinaryOrErr);
   return BinaryOrErr.takeError();
 }
 
 Expected<std::unique_ptr<Archive>> Archive::create(MemoryBufferRef Source) {
-  Error Err;
+  Error Err = Error::success();
   std::unique_ptr<Archive> Ret(new Archive(Source, Err));
   if (Err)
     return std::move(Err);
   return std::move(Ret);
 }
 
 void Archive::setFirstRegular(const Child &C) {
   FirstRegularData = C.Data;
if (Parent->kind() == K_GNU) {
 
     if (OffsetIndex >= MemberCount)
       return errorCodeToError(object_error::parse_failed);
 
     Offset = read32le(Offsets + OffsetIndex * 4);
   }
 
   const char *Loc = Parent->getData().begin() + Offset;
-  Error Err;
+  Error Err = Error::success();
   Child C(Parent, Loc, &Err);
   if (Err)
     return std::move(Err);
   return C;
 }
 
 Archive::Symbol Archive::Symbol::getNext() const {
   Symbol t(*this);

llvm/lib/Object/Error.cpp

 static ManagedStatic<_object_error_category> error_category;
 
 const std::error_category &object::object_category() {
   return *error_category;
 }
 
 llvm::Error llvm::object::isNotObjectErrorInvalidFileType(llvm::Error Err) {
   if (auto Err2 =
-       handleErrors(std::move(Err),
-         [](std::unique_ptr<ECError> M) {
+          handleErrors(std::move(Err), [](std::unique_ptr<ECError> M) -> Error {
             // Try to handle 'M'. If successful, return a success value from
             // the handler.
             if (M->convertToErrorCode() == object_error::invalid_file_type)
               return Error::success();
 
             // We failed to handle 'M' - return it from the handler.
             // This value will be passed back from catchErrors and
             // wind up in Err2, where it will be returned from this function.
             return Error(std::move(M));
           }))
     return Err2;
   return Err;
 }

llvm/lib/Object/MachOObjectFile.cpp

if (cmd == MachO::LC_SYMSEG ||
     return true;
   return false;
 }
 
 Expected<std::unique_ptr<MachOObjectFile>>
 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
                         bool Is64Bits, uint32_t UniversalCputype,
                         uint32_t UniversalIndex) {
-  Error Err;
+  Error Err = Error::success();
   std::unique_ptr<MachOObjectFile> Obj(
       new MachOObjectFile(std::move(Object), IsLittleEndian,
                           Is64Bits, Err, UniversalCputype,
                           UniversalIndex));
   if (Err)
     return std::move(Err);
   return std::move(Obj);
 }

llvm/lib/Object/MachOUniversal.cpp

MachOUniversalBinary::ObjectForArch::getAsArchive() const {
   MemoryBufferRef ObjBuffer(ObjectData, ObjectName);
   return Archive::create(ObjBuffer);
 }
 
 void MachOUniversalBinary::anchor() { }
 
 Expected<std::unique_ptr<MachOUniversalBinary>>
 MachOUniversalBinary::create(MemoryBufferRef Source) {
-  Error Err;
+  Error Err = Error::success();
   std::unique_ptr<MachOUniversalBinary> Ret(
       new MachOUniversalBinary(Source, Err));
   if (Err)
     return std::move(Err);
   return std::move(Ret);
 }
 
 MachOUniversalBinary::MachOUniversalBinary(MemoryBufferRef Source, Error &Err)

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

 Expected<std::unique_ptr<BinaryCoverageReader>>
 BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
                              StringRef Arch) {
   std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader());
 
   StringRef Coverage;
   uint8_t BytesInAddress;
   support::endianness Endian;
-  Error E;
-  consumeError(std::move(E));
+  Error E = Error::success();
   if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic))
     // This is a special format used for testing.
     E = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames,
                           Coverage, BytesInAddress, Endian);
   else
     E = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames,
                          Coverage, BytesInAddress, Endian, Arch);
   if (E)

llvm/tools/dsymutil/BinaryHolder.cpp

ErrorOr<std::vector<MemoryBufferRef>> BinaryHolder::GetArchiveMemberBuffers(
 
   // Remove the archive name and the parens around the archive member name.
   Filename = Filename.substr(CurArchiveName.size() + 1).drop_back();
 
   std::vector<MemoryBufferRef> Buffers;
   Buffers.reserve(CurrentArchives.size());
 
   for (const auto &CurrentArchive : CurrentArchives) {
-    Error Err;
+    Error Err = Error::success();
     for (auto Child : CurrentArchive->children(Err)) {
       if (auto NameOrErr = Child.getName()) {
         if (*NameOrErr == Filename) {
           auto ModTimeOrErr = Child.getLastModified();
           if (!ModTimeOrErr)
             return errorToErrorCode(ModTimeOrErr.takeError());
           if (Timestamp != sys::TimePoint<>() &&
               Timestamp != ModTimeOrErr.get()) {

llvm/tools/llvm-ar/llvm-ar.cpp

 
 static void performReadOperation(ArchiveOperation Operation,
                                  object::Archive *OldArchive) {
   if (Operation == Extract && OldArchive->isThin())
     fail("extracting from a thin archive is not supported");
 
   bool Filter = !Members.empty();
   {
-    Error Err;
+    Error Err = Error::success();
     for (auto &C : OldArchive->children(Err)) {
       Expected<StringRef> NameOrErr = C.getName();
       failIfError(NameOrErr.takeError());
       StringRef Name = NameOrErr.get();
 
       if (Filter) {
         auto I = find(Members, Name);
         if (I == Members.end())

 static std::vector<NewArchiveMember>
 computeNewArchiveMembers(ArchiveOperation Operation,
                          object::Archive *OldArchive) {
   std::vector<NewArchiveMember> Ret;
   std::vector<NewArchiveMember> Moved;
   int InsertPos = -1;
   StringRef PosName = sys::path::filename(RelPos);
   if (OldArchive) {
-    Error Err;
+    Error Err = Error::success();
     for (auto &Child : OldArchive->children(Err)) {
       int Pos = Ret.size();
       Expected<StringRef> NameOrErr = Child.getName();
       failIfError(NameOrErr.takeError());
       StringRef Name = NameOrErr.get();
       if (Name == PosName) {
         assert(AddAfter || AddBefore);
         if (AddBefore)
static int performOperation(ArchiveOperation Operation,
   // Create or open the archive object.
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
       MemoryBuffer::getFile(ArchiveName, -1, false);
   std::error_code EC = Buf.getError();
   if (EC && EC != errc::no_such_file_or_directory)
     fail("error opening '" + ArchiveName + "': " + EC.message() + "!");
 
   if (!EC) {
-    Error Err;
+    Error Err = Error::success();
     object::Archive Archive(Buf.get()->getMemBufferRef(), Err);
     EC = errorToErrorCode(std::move(Err));
     failIfError(EC,
                 "error loading '" + ArchiveName + "': " + EC.message() + "!");
     performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers);
     return 0;
   }
 
case MRICommand::AddLib: {
       ArchiveBuffers.push_back(std::move(*BufOrErr));
       auto LibOrErr =
           object::Archive::create(ArchiveBuffers.back()->getMemBufferRef());
       failIfError(errorToErrorCode(LibOrErr.takeError()),
                   "Could not parse library");
       Archives.push_back(std::move(*LibOrErr));
       object::Archive &Lib = *Archives.back();
       {
-        Error Err;
+        Error Err = Error::success();
         for (auto &Member : Lib.children(Err))
           addMember(NewMembers, Member);
         failIfError(std::move(Err));
       }
       break;
     }
     case MRICommand::AddMod:
       addMember(NewMembers, Rest);

llvm/tools/llvm-cxxdump/llvm-cxxdump.cpp

if (!DataDone && (SymDone || VTableDataI->first < VTableSymI->first)) {
       outs() << '\n';
       ++VTableDataI;
       continue;
     }
   }
 }
 
 static void dumpArchive(const Archive *Arc) {
-  Error Err;
+  Error Err = Error::success();
   for (auto &ArcC : Arc->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = ArcC.getAsBinary();
     if (!ChildOrErr) {
       // Ignore non-object files.
       if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) {
         std::string Buf;
         raw_string_ostream OS(Buf);
         logAllUnhandledErrors(std::move(E), OS, "");

llvm/tools/llvm-dwp/llvm-dwp.cpp

std::string buildDWODescription(StringRef Name, StringRef DWPName, StringRef DWOName) {
   }
   return Text;
 }
 
 static Error handleCompressedSection(
     std::deque<SmallString<32>> &UncompressedSections, StringRef &Name,
     StringRef &Contents) {
   if (!Name.startswith("zdebug_"))
-    return Error();
+    return Error::success();
   UncompressedSections.emplace_back();
   uint64_t OriginalSize;
   if (!zlib::isAvailable())
     return make_error<DWPError>("zlib not available");
   if (!consumeCompressedDebugSectionHeader(Contents, OriginalSize) ||
       zlib::uncompress(Contents, UncompressedSections.back(), OriginalSize) !=
           zlib::StatusOK)
     return make_error<DWPError>(
         ("failure while decompressing compressed section: '" + Name + "\'")
             .str());
   Name = Name.substr(1);
   Contents = UncompressedSections.back();
-  return Error();
+  return Error::success();
 }
 
 static Error handleSection(
     const StringMap<std::pair<MCSection *, DWARFSectionKind>> &KnownSections,
     const MCSection *StrSection, const MCSection *StrOffsetSection,
     const MCSection *TypesSection, const MCSection *CUIndexSection,
     const MCSection *TUIndexSection, const SectionRef &Section, MCStreamer &Out,
     std::deque<SmallString<32>> &UncompressedSections,
     uint32_t (&ContributionOffsets)[8], UnitIndexEntry &CurEntry,
     StringRef &CurStrSection, StringRef &CurStrOffsetSection,
     std::vector<StringRef> &CurTypesSection, StringRef &InfoSection,
     StringRef &AbbrevSection, StringRef &CurCUIndexSection,
     StringRef &CurTUIndexSection) {
   if (Section.isBSS())
-    return Error();
+    return Error::success();
 
   if (Section.isVirtual())
-    return Error();
+    return Error::success();
 
   StringRef Name;
   if (std::error_code Err = Section.getName(Name))
     return errorCodeToError(Err);
 
   Name = Name.substr(Name.find_first_not_of("._"));
 
   StringRef Contents;
   if (auto Err = Section.getContents(Contents))
     return errorCodeToError(Err);
 
   if (auto Err = handleCompressedSection(UncompressedSections, Name, Contents))
     return Err;
 
   auto SectionPair = KnownSections.find(Name);
   if (SectionPair == KnownSections.end())
-    return Error();
+    return Error::success();
 
   if (DWARFSectionKind Kind = SectionPair->second.second) {
     auto Index = Kind - DW_SECT_INFO;
     if (Kind != DW_SECT_TYPES) {
       CurEntry.Contributions[Index].Offset = ContributionOffsets[Index];
       ContributionOffsets[Index] +=
           (CurEntry.Contributions[Index].Length = Contents.size());
     }
static Error handleSection(
   else if (OutSection == CUIndexSection)
     CurCUIndexSection = Contents;
   else if (OutSection == TUIndexSection)
     CurTUIndexSection = Contents;
   else {
     Out.SwitchSection(OutSection);
     Out.EmitBytes(Contents);
   }
-  return Error();
+  return Error::success();
 }
 
 static Error
 buildDuplicateError(const std::pair<uint64_t, UnitIndexEntry> &PrevE,
                     const CompileUnitIdentifiers &ID, StringRef DWPName) {
   return make_error<DWPError>(
       std::string("Duplicate DWO ID (") + utohexstr(PrevE.first) + ") in " +
       buildDWODescription(PrevE.second.Name, PrevE.second.DWPName,
static Error write(MCStreamer &Out, ArrayRef<std::string> Inputs) {
   // Lie about the type contribution
   ContributionOffsets[DW_SECT_TYPES - DW_SECT_INFO] = 0;
   // Unlie about the info contribution
   ContributionOffsets[0] = 1;
 
   writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets,
              IndexEntries);
 
-  return Error();
+  return Error::success();
 }
 
 static int error(const Twine &Error, const Twine &Context) {
   errs() << Twine("while processing ") + Context + ":\n";
   errs() << Twine("error: ") + Error + "\n";
   return 1;
 }
 

llvm/tools/llvm-nm/llvm-nm.cpp

if (ArchiveMap) {
           StringRef SymName = I->getName();
           outs() << SymName << " in " << FileNameOrErr.get() << "\n";
         }
         outs() << "\n";
       }
     }
 
     {
-      Error Err;
+      Error Err = Error::success();
       for (auto &C : A->children(Err)) {
         Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(&Context);
         if (!ChildOrErr) {
           if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
             error(std::move(E), Filename, C);
           continue;
         }
         if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
if (!ArchAll && ArchFlags.size() != 0) {
             } else if (auto E = isNotObjectErrorInvalidFileType(
                        ObjOrErr.takeError())) {
               error(std::move(E), Filename, ArchFlags.size() > 1 ?
                     StringRef(I->getArchTypeName()) : StringRef());
               continue;
             } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                            I->getAsArchive()) {
               std::unique_ptr<Archive> &A = *AOrErr;
-              Error Err;
+              Error Err = Error::success();
               for (auto &C : A->children(Err)) {
                 Expected<std::unique_ptr<Binary>> ChildOrErr =
                     C.getAsBinary(&Context);
                 if (!ChildOrErr) {
                   if (auto E = isNotObjectErrorInvalidFileType(
                                        ChildOrErr.takeError())) {
                     error(std::move(E), Filename, C, ArchFlags.size() > 1 ?
                           StringRef(I->getArchTypeName()) : StringRef());
if (!ArchAll) {
             dumpSymbolNamesFromObject(Obj, false);
           } else if (auto E = isNotObjectErrorInvalidFileType(
                      ObjOrErr.takeError())) {
             error(std::move(E), Filename);
             return;
           } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                          I->getAsArchive()) {
             std::unique_ptr<Archive> &A = *AOrErr;
-            Error Err;
+            Error Err = Error::success();
             for (auto &C : A->children(Err)) {
               Expected<std::unique_ptr<Binary>> ChildOrErr =
                   C.getAsBinary(&Context);
               if (!ChildOrErr) {
                 if (auto E = isNotObjectErrorInvalidFileType(
                                      ChildOrErr.takeError()))
                   error(std::move(E), Filename, C);
                 continue;
for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
       } else if (auto E = isNotObjectErrorInvalidFileType(
                  ObjOrErr.takeError())) {
         error(std::move(E), Filename, moreThanOneArch ?
               StringRef(I->getArchTypeName()) : StringRef());
         continue;
       } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                   I->getAsArchive()) {
         std::unique_ptr<Archive> &A = *AOrErr;
-        Error Err;
+        Error Err = Error::success();
         for (auto &C : A->children(Err)) {
           Expected<std::unique_ptr<Binary>> ChildOrErr =
             C.getAsBinary(&Context);
           if (!ChildOrErr) {
             if (auto E = isNotObjectErrorInvalidFileType(
                                  ChildOrErr.takeError()))
               error(std::move(E), Filename, C, moreThanOneArch ?
                     StringRef(ArchitectureName) : StringRef());

llvm/tools/llvm-objdump/MachODump.cpp

if (verbose) {
     StringRef RawName = NameOrErr.get();
     outs() << RawName << "\n";
   }
 }
 
 static void printArchiveHeaders(StringRef Filename, Archive *A, bool verbose,
                                 bool print_offset,
                                 StringRef ArchitectureName = StringRef()) {
-  Error Err;
+  Error Err = Error::success();
+  ;
   for (const auto &C : A->children(Err, false))
     printArchiveChild(Filename, C, verbose, print_offset, ArchitectureName);
 
   if (Err)
     report_error(Filename, std::move(Err));
 }
 
 // ParseInputMachO() parses the named Mach-O file in Filename and handles the
if (!BinaryOrErr)
     report_error(Filename, BinaryOrErr.takeError());
   Binary &Bin = *BinaryOrErr.get().getBinary();
 
   if (Archive *A = dyn_cast<Archive>(&Bin)) {
     outs() << "Archive : " << Filename << "\n";
     if (ArchiveHeaders)
       printArchiveHeaders(Filename, A, !NonVerbose, ArchiveMemberOffsets);
 
-    Error Err;
+    Error Err = Error::success();
     for (auto &C : A->children(Err)) {
       Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
       if (!ChildOrErr) {
         if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
           report_error(Filename, C, std::move(E));
         continue;
       }
       if (MachOObjectFile *O = dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
if (!ArchAll && ArchFlags.size() != 0) {
               std::unique_ptr<Archive> &A = *AOrErr;
               outs() << "Archive : " << Filename;
               if (!ArchitectureName.empty())
                 outs() << " (architecture " << ArchitectureName << ")";
               outs() << "\n";
               if (ArchiveHeaders)
                 printArchiveHeaders(Filename, A.get(), !NonVerbose,
                                     ArchiveMemberOffsets, ArchitectureName);
-              Error Err;
+              Error Err = Error::success();
               for (auto &C : A->children(Err)) {
                 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
                 if (!ChildOrErr) {
                   if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
                     report_error(Filename, C, std::move(E), ArchitectureName);
                   continue;
                 }
                 if (MachOObjectFile *O =
if (!ArchAll) {
             continue;
           } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                          I->getAsArchive()) {
             std::unique_ptr<Archive> &A = *AOrErr;
             outs() << "Archive : " << Filename << "\n";
             if (ArchiveHeaders)
               printArchiveHeaders(Filename, A.get(), !NonVerbose,
                                   ArchiveMemberOffsets);
-            Error Err;
+            Error Err = Error::success();
             for (auto &C : A->children(Err)) {
               Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
               if (!ChildOrErr) {
                 if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
                   report_error(Filename, C, std::move(E));
                 continue;
               }
               if (MachOObjectFile *O =
for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
         std::unique_ptr<Archive> &A = *AOrErr;
         outs() << "Archive : " << Filename;
         if (!ArchitectureName.empty())
           outs() << " (architecture " << ArchitectureName << ")";
         outs() << "\n";
         if (ArchiveHeaders)
           printArchiveHeaders(Filename, A.get(), !NonVerbose,
                               ArchiveMemberOffsets, ArchitectureName);
-        Error Err;
+        Error Err = Error::success();
         for (auto &C : A->children(Err)) {
           Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
           if (!ChildOrErr) {
             if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
               report_error(Filename, C, std::move(E), ArchitectureName);
             continue;
           }
           if (MachOObjectFile *O =

llvm/tools/llvm-objdump/llvm-objdump.cpp

outs() << '\n'
            << "\n\n";
 
   if (SymbolTable)
     printCOFFSymbolTable(I);
 }
 
 /// @brief Dump each object file in \a a;
 static void DumpArchive(const Archive *a) {
-  Error Err;
+  Error Err = Error::success();
   for (auto &C : a->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
     if (!ChildOrErr) {
       if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
         report_error(a->getFileName(), C, std::move(E));
       continue;
     }
     if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get()))

llvm/tools/llvm-readobj/llvm-readobj.cpp

if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
   }
   if (opts::PrintStackMap)
     Dumper->printStackMap();
 }
 
 /// @brief Dumps each object file in \a Arc;
 static void dumpArchive(const Archive *Arc) {
-  Error Err;
+  Error Err = Error::success();
   for (auto &Child : Arc->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
     if (!ChildOrErr) {
       if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) {
         std::string Buf;
         raw_string_ostream OS(Buf);
         logAllUnhandledErrors(ChildOrErr.takeError(), OS, "");
         OS.flush();

llvm/tools/llvm-size/llvm-size.cpp

static void printFileSectionSizes(StringRef file) {
   if (!BinaryOrErr) {
     error(BinaryOrErr.takeError(), file);
     return;
   }
   Binary &Bin = *BinaryOrErr.get().getBinary();
 
   if (Archive *a = dyn_cast<Archive>(&Bin)) {
     // This is an archive. Iterate over each member and display its sizes.
-    Error Err;
+    Error Err = Error::success();
     for (auto &C : a->children(Err)) {
       Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
       if (!ChildOrErr) {
         if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
           error(std::move(E), a->getFileName(), C);
         continue;
       }
       if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) {
if (!ArchAll && ArchFlags.size() != 0) {
               error(std::move(E), file, ArchFlags.size() > 1 ?
                     StringRef(I->getArchTypeName()) : StringRef());
               return;
             } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                            I->getAsArchive()) {
               std::unique_ptr<Archive> &UA = *AOrErr;
               // This is an archive. Iterate over each member and display its
               // sizes.
-              Error Err;
+              Error Err = Error::success();
               for (auto &C : UA->children(Err)) {
                 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
                 if (!ChildOrErr) {
                   if (auto E = isNotObjectErrorInvalidFileType(
                                     ChildOrErr.takeError()))
                     error(std::move(E), UA->getFileName(), C,
                           ArchFlags.size() > 1 ?
                           StringRef(I->getArchTypeName()) : StringRef());
if (!ArchAll) {
           } else if (auto E = isNotObjectErrorInvalidFileType(UO.takeError())) {
             error(std::move(E), file);
             return;
           } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                          I->getAsArchive()) {
             std::unique_ptr<Archive> &UA = *AOrErr;
             // This is an archive. Iterate over each member and display its
             // sizes.
-            Error Err;
+            Error Err = Error::success();
             for (auto &C : UA->children(Err)) {
               Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
               if (!ChildOrErr) {
                 if (auto E = isNotObjectErrorInvalidFileType(
                                 ChildOrErr.takeError()))
                   error(std::move(E), UA->getFileName(), C);
                 continue;
               }
for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
       } else if (auto E = isNotObjectErrorInvalidFileType(UO.takeError())) {
         error(std::move(E), file, MoreThanOneArch ?
               StringRef(I->getArchTypeName()) : StringRef());
         return;
       } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                          I->getAsArchive()) {
         std::unique_ptr<Archive> &UA = *AOrErr;
         // This is an archive. Iterate over each member and display its sizes.
-        Error Err;
+        Error Err = Error::success();
         for (auto &C : UA->children(Err)) {
           Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
           if (!ChildOrErr) {
             if (auto E = isNotObjectErrorInvalidFileType(
                               ChildOrErr.takeError()))
               error(std::move(E), UA->getFileName(), C, MoreThanOneArch ?
                     StringRef(I->getArchTypeName()) : StringRef());
             continue;

llvm/tools/llvm-xray/xray-extract.cc

void InstrumentationMapExtractor::exportAsYAML(raw_ostream &OS) {
   for (const auto &Sled : Sleds) {
     YAMLSleds.push_back({FunctionIds[Sled.Function], Sled.Address,
                          Sled.Function, Sled.Kind, Sled.AlwaysInstrument});
   }
   Output Out(OS);
   Out << YAMLSleds;
 }
 
-static CommandRegistration Unused(&Extract, [] {
-  Error Err;
+static CommandRegistration Unused(&Extract, []() -> Error {
+  Error Err = Error::success();
   xray::InstrumentationMapExtractor Extractor(
       ExtractInput, InstrumentationMapExtractor::InputFormats::ELF, Err);
   if (Err)
     return Err;
 
   std::error_code EC;
   raw_fd_ostream OS(ExtractOutput, EC, sys::fs::OpenFlags::F_Text);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + ExtractOutput + "' for writing.", EC);
   Extractor.exportAsYAML(OS);
   return Error::success();
 });

llvm/tools/sancov/sancov.cc

for (uint64_t Index = 0, Size = 0; Index < Section.getSize();
         Addrs->insert(CovPoint);
     }
   }
 }
 
 static void
 visitObjectFiles(const object::Archive &A,
                  function_ref<void(const object::ObjectFile &)> Fn) {
-  Error Err;
+  Error Err = Error::success();
   for (auto &C : A.children(Err)) {
     Expected<std::unique_ptr<object::Binary>> ChildOrErr = C.getAsBinary();
     failIfError(ChildOrErr);
     if (auto *O = dyn_cast<object::ObjectFile>(&*ChildOrErr.get()))
       Fn(*O);
     else
       failIfError(object::object_error::invalid_file_type);
   }

llvm/unittests/Support/ErrorTest.cpp

public:
   static char ID;
 
 protected:
   int ExtraInfo;
 };
 
 char CustomSubError::ID = 0;
 
-static Error handleCustomError(const CustomError &CE) { return Error(); }
+static Error handleCustomError(const CustomError &CE) {
+  return Error::success();
+}
 
 static void handleCustomErrorVoid(const CustomError &CE) {}
 
 static Error handleCustomErrorUP(std::unique_ptr<CustomError> CE) {
-  return Error();
+  return Error::success();
 }
 
 static void handleCustomErrorUPVoid(std::unique_ptr<CustomError> CE) {}
 
 // Test that success values implicitly convert to false, and don't cause crashes
 // once they've been implicitly converted.
 TEST(Error, CheckedSuccess) {
   Error E;