[lldb] Remove redundant calls to set eReturnStatusFailed

[DavidSpickett]

Summary

Since https://reviews.llvm.org/D103701 AppendError<...>
sets this for you.

This change includes all of the non-command uses.

Some uses remain where it's either tricky to reason about
the logic, or they aren't paired with AppendError calls.

[DavidSpickett]

There'll be a part 2 once this has passed the bots, which will cover all the CommandObject* files.

[DavidSpickett]

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

835

https://reviews.llvm.org/D104380 should address calls like this one. Where we append something that could be empty.

[teemperor]

LGTM and passes on macOS and Linux for me. Thanks!

lldb/source/API/SBCommandInterpreter.cpp

if (override_context.get())
                                   override_context.get()->Lock(true),
                                   result.ref());
     else
       m_opaque_ptr->HandleCommand(command_line, do_add_to_history,
                                   result.ref());
   } else {
     result->AppendError(
         "SBCommandInterpreter or the command line is not valid");
-    result->SetStatus(eReturnStatusFailed);
   }
 
   return result.GetStatus();
 }
 
 void SBCommandInterpreter::HandleCommandsFromFile(
     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
     lldb::SBCommandInterpreterRunOptions &options,
     lldb::SBCommandReturnObject result) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
                      (lldb::SBFileSpec &, lldb::SBExecutionContext &,
                       lldb::SBCommandInterpreterRunOptions &,
                       lldb::SBCommandReturnObject),
                      file, override_context, options, result);
 
   if (!IsValid()) {
     result->AppendError("SBCommandInterpreter is not valid.");
-    result->SetStatus(eReturnStatusFailed);
     return;
   }
 
   if (!file.IsValid()) {
     SBStream s;
     file.GetDescription(s);
     result->AppendErrorWithFormat("File is not valid: %s.", s.GetData());
-    result->SetStatus(eReturnStatusFailed);
   }
 
   FileSpec tmp_spec = file.ref();
   if (override_context.get())
     m_opaque_ptr->HandleCommandsFromFile(tmp_spec,
                                          override_context.get()->Lock(true),
                                          options.ref(),
                                          result.ref());
LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
                      command_line, result);
 
   result.Clear();
   if (command_line && IsValid()) {
     m_opaque_ptr->ResolveCommand(command_line, result.ref());
   } else {
     result->AppendError(
         "SBCommandInterpreter or the command line is not valid");
-    result->SetStatus(eReturnStatusFailed);
   }
 }
 
 CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; }
 
 CommandInterpreter &SBCommandInterpreter::ref() {
   assert(m_opaque_ptr);
   return *m_opaque_ptr;
void SBCommandInterpreter::SourceInitFileInHomeDirectory(
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFileHome(result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
-    result->SetStatus(eReturnStatusFailed);
   }
 }
 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result, bool is_repl) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
                      (lldb::SBCommandReturnObject &, bool), result, is_repl);
 
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFileHome(result.ref(), is_repl);
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
-    result->SetStatus(eReturnStatusFailed);
   }
 }
 
 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
     SBCommandReturnObject &result) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreter,
                      SourceInitFileInCurrentWorkingDirectory,
                      (lldb::SBCommandReturnObject &), result);
 
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFileCwd(result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
-    result->SetStatus(eReturnStatusFailed);
   }
 }
 
 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
                              GetBroadcaster);
 
 

lldb/source/Breakpoint/BreakpointIDList.cpp

for (size_t i = 0; i < old_args.size(); ++i) {
     std::tie(range_from, range_to) =
         BreakpointIDList::SplitIDRangeExpression(current_arg);
     if (!range_from.empty() && !range_to.empty()) {
       is_range = true;
     } else if (BreakpointID::StringIsBreakpointName(current_arg, error)) {
       if (!error.Success()) {
         new_args.Clear();
         result.AppendError(error.AsCString());
-        result.SetStatus(eReturnStatusFailed);
         return;
       } else
         names_found.insert(std::string(current_arg));
     } else if ((i + 2 < old_args.size()) &&
                BreakpointID::IsRangeIdentifier(old_args[i + 1].ref()) &&
                BreakpointID::IsValidIDExpression(current_arg) &&
                BreakpointID::IsValidIDExpression(old_args[i + 2].ref())) {
       range_from = current_arg;
if (!range_from.empty() && !range_to.empty()) {
           BreakpointSP breakpoint_sp;
           auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
           if (bp_id.hasValue())
             breakpoint_sp = target->GetBreakpointByID(bp_id->GetBreakpointID());
           if (!breakpoint_sp) {
             new_args.Clear();
             result.AppendErrorWithFormat("'%d' is not a valid breakpoint ID.\n",
                                          bp_id->GetBreakpointID());
-            result.SetStatus(eReturnStatusFailed);
             return;
           }
           const size_t num_locations = breakpoint_sp->GetNumLocations();
           for (size_t j = 0; j < num_locations; ++j) {
             BreakpointLocation *bp_loc =
                 breakpoint_sp->GetLocationAtIndex(j).get();
             StreamString canonical_id_str;
             BreakpointID::GetCanonicalReference(
for (size_t i = 0; i < old_args.size(); ++i) {
     auto start_bp = BreakpointID::ParseCanonicalReference(range_from);
     auto end_bp = BreakpointID::ParseCanonicalReference(range_to);
 
     if (!start_bp.hasValue() ||
         !target->GetBreakpointByID(start_bp->GetBreakpointID())) {
       new_args.Clear();
       result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
                                    range_from.str().c_str());
-      result.SetStatus(eReturnStatusFailed);
       return;
     }
 
     if (!end_bp.hasValue() ||
         !target->GetBreakpointByID(end_bp->GetBreakpointID())) {
       new_args.Clear();
       result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
                                    range_to.str().c_str());
-      result.SetStatus(eReturnStatusFailed);
       return;
     }
     break_id_t start_bp_id = start_bp->GetBreakpointID();
     break_id_t start_loc_id = start_bp->GetLocationID();
     break_id_t end_bp_id = end_bp->GetBreakpointID();
     break_id_t end_loc_id = end_bp->GetLocationID();
     if (((start_loc_id == LLDB_INVALID_BREAK_ID) &&
             (end_loc_id != LLDB_INVALID_BREAK_ID)) ||
         ((start_loc_id != LLDB_INVALID_BREAK_ID) &&
          (end_loc_id == LLDB_INVALID_BREAK_ID))) {
       new_args.Clear();
       result.AppendError("Invalid breakpoint id range:  Either "
                          "both ends of range must specify"
                          " a breakpoint location, or neither can "
                          "specify a breakpoint location.");
-      result.SetStatus(eReturnStatusFailed);
       return;
     }
 
     // We have valid range starting & ending breakpoint IDs.  Go through all
     // the breakpoints in the target and find all the breakpoints that fit into
     // this range, and add them to new_args.
 
     // Next check to see if we have location id's.  If so, make sure the
     // start_bp_id and end_bp_id are for the same breakpoint; otherwise we have
     // an illegal range: breakpoint id ranges that specify bp locations are NOT
     // allowed to cross major bp id numbers.
 
     if ((start_loc_id != LLDB_INVALID_BREAK_ID) ||
         (end_loc_id != LLDB_INVALID_BREAK_ID)) {
       if (start_bp_id != end_bp_id) {
         new_args.Clear();
         result.AppendErrorWithFormat(
             "Invalid range: Ranges that specify particular breakpoint "
             "locations"
             " must be within the same major breakpoint; you specified two"
             " different major breakpoints, %d and %d.\n",
             start_bp_id, end_bp_id);
-        result.SetStatus(eReturnStatusFailed);
         return;
       }
     }
 
     const BreakpointList &breakpoints = target->GetBreakpointList();
     const size_t num_breakpoints = breakpoints.GetSize();
     for (size_t j = 0; j < num_breakpoints; ++j) {
       Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(j).get();

lldb/source/Interpreter/CommandAlias.cpp

ExecutionContext exe_ctx =
         cmd_obj_sp->GetCommandInterpreter().GetExecutionContext();
     options->NotifyOptionParsingStarting(&exe_ctx);
 
     llvm::Expected<Args> args_or =
         options->ParseAlias(args, option_arg_vector, options_string);
     if (!args_or) {
       result.AppendError(toString(args_or.takeError()));
       result.AppendError("Unable to create requested alias.\n");
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
     args = std::move(*args_or);
     options->VerifyPartialOptions(result);
     if (!result.Succeeded() &&
         result.GetStatus() != lldb::eReturnStatusStarted) {
       result.AppendError("Unable to create requested alias.\n");
       return false;

lldb/source/Interpreter/CommandInterpreter.cpp

for (const auto &entry : *option_arg_vector) {
     if (index == 0)
       result_str.Printf("%s", value.c_str());
     else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount()) {
 
       result.AppendErrorWithFormat("Not enough arguments provided; you "
                                    "need at least %d arguments to use "
                                    "this alias.\n",
                                    index);
-      result.SetStatus(eReturnStatusFailed);
       return nullptr;
     } else {
       size_t strpos = raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
       if (strpos != std::string::npos)
         raw_input_string = raw_input_string.erase(
             strpos, strlen(cmd_args.GetArgumentAtIndex(index)));
       result_str.Printf("%s", cmd_args.GetArgumentAtIndex(index));
     }
bool CommandInterpreter::HandleCommand(const char *command_line,
   llvm::PrettyStackTraceFormat stack_trace("HandleCommand(command = \"%s\")",
                                    command_line);
 
   LLDB_LOGF(log, "Processing command: %s", command_line);
   LLDB_SCOPED_TIMERF("Processing command: %s.", command_line);
 
   if (WasInterrupted()) {
     result.AppendError("interrupted");
-    result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
   bool add_to_history;
   if (lazy_add_to_history == eLazyBoolCalculate)
     add_to_history = (m_command_source_depth == 0);
   else
     add_to_history = (lazy_add_to_history == eLazyBoolYes);
else if (command_string[non_space] == CommandHistory::g_repeat_char) {
       search_str = search_str.drop_front(non_space);
       if (auto hist_str = m_command_history.FindString(search_str)) {
         add_to_history = false;
         command_string = std::string(*hist_str);
         original_command_string = std::string(*hist_str);
       } else {
         result.AppendErrorWithFormat("Could not find entry: %s in history",
                                      command_string.c_str());
-        result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
   }
 
   if (empty_command) {
     if (!GetRepeatPreviousCommand()) {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return true;
     }
 
     if (m_command_history.IsEmpty()) {
       result.AppendError("empty command");
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     command_line = m_repeat_command.c_str();
     command_string = command_line;
     original_command_string = command_line;
     if (m_repeat_command.empty()) {
       result.AppendError("No auto repeat.");
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     add_to_history = false;
   } else if (comment_command) {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return true;
   }
 
   Status error(PreprocessCommand(command_string));
 
   if (error.Fail()) {
     result.AppendError(error.AsCString());
-    result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
   // Phase 1.
 
   // Before we do ANY kind of argument processing, we need to figure out what
   // the real/final command object is for the specified command.  This gets
   // complicated by the fact that the user could have specified an alias, and,
for (const auto &option_entry : *option_arg_vector) {
           new_args.AppendArgument(option + value);
         }
 
       } else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount()) {
         result.AppendErrorWithFormat("Not enough arguments provided; you "
                                      "need at least %d arguments to use "
                                      "this alias.\n",
                                      index);
-        result.SetStatus(eReturnStatusFailed);
         return;
       } else {
         // Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string
         size_t strpos =
             raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
         if (strpos != std::string::npos) {
           raw_input_string = raw_input_string.erase(
               strpos, strlen(cmd_args.GetArgumentAtIndex(index)));
void CommandInterpreter::SourceInitFileCwd(CommandReturnObject &result) {
   case eLoadCWDlldbinitWarn: {
     llvm::SmallString<128> home_init_file;
     GetHomeInitFile(home_init_file);
     if (llvm::sys::path::parent_path(init_file) ==
         llvm::sys::path::parent_path(home_init_file)) {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     } else {
       result.AppendError(InitFileWarning);
-      result.SetStatus(eReturnStatusFailed);
     }
   }
   }
 }
 
 /// We will first see if there is an application specific ".lldbinit" file
 /// whose name is "~/.lldbinit" followed by a "-" and the name of the program.
 /// If this file doesn't exist, we fall back to the REPL init file or the
if (!success || !tmp_result.Succeeded()) {
       llvm::StringRef error_msg = tmp_result.GetErrorData();
       if (error_msg.empty())
         error_msg = "<unknown error>.\n";
       if (options.GetStopOnError()) {
         result.AppendErrorWithFormat(
             "Aborting reading of commands after command #%" PRIu64
             ": '%s' failed with %s",
             (uint64_t)idx, cmd, error_msg.str().c_str());
-        result.SetStatus(eReturnStatusFailed);
         m_debugger.SetAsyncExecution(old_async_execution);
         return;
       } else if (options.GetPrintResults()) {
         result.AppendMessageWithFormat(
             "Command #%" PRIu64 " '%s' failed with %s", (uint64_t)idx + 1, cmd,
             error_msg.str().c_str());
       }
     }

 }
 
 void CommandInterpreter::HandleCommandsFromFile(FileSpec &cmd_file,
     const CommandInterpreterRunOptions &options, CommandReturnObject &result) {
   if (!FileSystem::Instance().Exists(cmd_file)) {
     result.AppendErrorWithFormat(
         "Error reading commands from file %s - file not found.\n",
         cmd_file.GetFilename().AsCString("<Unknown>"));
-    result.SetStatus(eReturnStatusFailed);
     return;
   }
 
   std::string cmd_file_path = cmd_file.GetPath();
   auto input_file_up =
       FileSystem::Instance().Open(cmd_file, File::eOpenOptionRead);
   if (!input_file_up) {
     std::string error = llvm::toString(input_file_up.takeError());
     result.AppendErrorWithFormatv(
         "error: an error occurred read file '{0}': {1}\n", cmd_file_path,
         llvm::fmt_consume(input_file_up.takeError()));
-    result.SetStatus(eReturnStatusFailed);
     return;
   }
   FileSP input_file_sp = FileSP(std::move(input_file_up.get()));
 
   Debugger &debugger = GetDebugger();
 
   uint32_t flags = 0;
 
if (cmd_obj == nullptr) {
         }
         result.AppendRawError(error_msg.GetString());
       } else {
         // We didn't have only one match, otherwise we wouldn't get here.
         lldbassert(num_matches == 0);
         result.AppendErrorWithFormat("'%s' is not a valid command.\n",
                                      next_word.c_str());
       }
-      result.SetStatus(eReturnStatusFailed);
       return nullptr;
     }
 
     if (cmd_obj->IsMultiwordObject()) {
       if (!suffix.empty()) {
         result.AppendErrorWithFormat(
             "command '%s' did not recognize '%s%s%s' as valid (subcommand "
             "might be invalid).\n",
             cmd_obj->GetCommandName().str().c_str(),
             next_word.empty() ? "" : next_word.c_str(),
             next_word.empty() ? " -- " : " ", suffix.c_str());
-        result.SetStatus(eReturnStatusFailed);
         return nullptr;
       }
     } else {
       // If we found a normal command, we are done
       done = true;
       if (!suffix.empty()) {
         switch (suffix[0]) {
         case '/':
if (cmd_obj->IsMultiwordObject()) {
 
               if (wants_raw_input &&
                   FindArgumentTerminator(cmd) == std::string::npos)
                 revised_command_line.PutCString(" --");
             } else {
               result.AppendErrorWithFormat(
                   "the '%s' command doesn't support the --gdb-format option\n",
                   cmd_obj->GetCommandName().str().c_str());
-              result.SetStatus(eReturnStatusFailed);
               return nullptr;
             }
           }
           break;
 
         default:
           result.AppendErrorWithFormat(
               "unknown command shorthand suffix: '%s'\n", suffix.c_str());
-          result.SetStatus(eReturnStatusFailed);
           return nullptr;
         }
       }
     }
     if (scratch_command.empty())
       done = true;
   }
 
   if (!scratch_command.empty())
     revised_command_line.Printf(" %s", scratch_command.c_str());
 
   if (cmd_obj != nullptr)
     command_line = std::string(revised_command_line.GetString());
 
   return cmd_obj;
 }

lldb/source/Interpreter/Options.cpp

bool Options::VerifyOptions(CommandReturnObject &result) {
   } else {
     options_are_valid = true;
   }
 
   if (options_are_valid) {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
   } else {
     result.AppendError("invalid combination of options for the given command");
-    result.SetStatus(eReturnStatusFailed);
   }
 
   return options_are_valid;
 }
 
 // This is called in the Options constructor, though we could call it lazily if
 // that ends up being a performance problem.
 

lldb/source/Interpreter/ScriptInterpreter.cpp

ScriptInterpreter::ScriptInterpreter(
     lldb::ScriptedProcessInterfaceUP scripted_process_interface_up)
     : m_debugger(debugger), m_script_lang(script_lang),
       m_scripted_process_interface_up(
           std::move(scripted_process_interface_up)) {}
 
 void ScriptInterpreter::CollectDataForBreakpointCommandCallback(
     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
     CommandReturnObject &result) {
-  result.SetStatus(eReturnStatusFailed);
   result.AppendError(
       "This script interpreter does not support breakpoint callbacks.");
 }
 
 void ScriptInterpreter::CollectDataForWatchpointCommandCallback(
     WatchpointOptions *bp_options, CommandReturnObject &result) {
-  result.SetStatus(eReturnStatusFailed);
   result.AppendError(
       "This script interpreter does not support watchpoint callbacks.");
 }
 
 bool ScriptInterpreter::LoadScriptingModule(const char *filename,
                                             bool init_session,
                                             lldb_private::Status &error,
                                             StructuredData::ObjectSP *module_sp,

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

public:
   Options *GetOptions() override { return &m_options; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc < 1) {
       result.AppendErrorWithFormat("'%s' takes 1 argument of reduction name, "
                                    "and an optional kernel type list",
                                    m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     auto &outstream = result.GetOutputStream();
     auto name = command.GetArgumentAtIndex(0);
     auto &target = m_exe_ctx.GetTargetSP();
     auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr;
     if (!runtime->PlaceBreakpointOnReduction(target, outstream, name, coord,
                                              m_options.m_kernel_types)) {
-      result.SetStatus(eReturnStatusFailed);
       result.AppendError("Error: unable to place breakpoint on reduction");
       return false;
     }
     result.AppendMessage("Breakpoint(s) created");
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 
public:
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc < 1) {
       result.AppendErrorWithFormat(
           "'%s' takes 1 argument of kernel name, and an optional coordinate.",
           m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     auto &outstream = result.GetOutputStream();
     auto &target = m_exe_ctx.GetTargetSP();
     auto name = command.GetArgumentAtIndex(0);
     auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr;
     if (!runtime->PlaceBreakpointOnKernel(target, outstream, name, coord)) {
-      result.SetStatus(eReturnStatusFailed);
       result.AppendErrorWithFormat(
           "Error: unable to set breakpoint on kernel '%s'", name);
       return false;
     }
 
     result.AppendMessage("Breakpoint(s) created");
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
public:
 
   ~CommandObjectRenderScriptRuntimeKernelBreakpointAll() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc != 1) {
       result.AppendErrorWithFormat(
           "'%s' takes 1 argument of 'enable' or 'disable'", m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     bool do_break = false;
     const char *argument = command.GetArgumentAtIndex(0);
     if (strcmp(argument, "enable") == 0) {
       do_break = true;
       result.AppendMessage("Breakpoints will be set on all kernels.");
     } else if (strcmp(argument, "disable") == 0) {
       do_break = false;
       result.AppendMessage("Breakpoints will not be set on any new kernels.");
     } else {
       result.AppendErrorWithFormat(
           "Argument must be either 'enable' or 'disable'");
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     runtime->SetBreakAllKernels(do_break, m_exe_ctx.GetTargetSP());
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
public:
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc < 1) {
       result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. "
                                    "As well as an optional -f argument",
                                    m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     const char *id_cstr = command.GetArgumentAtIndex(0);
     bool success = false;
     const uint32_t id =
         StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
     if (!success) {
       result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                    id_cstr);
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     Stream *output_stream_p = nullptr;
     std::unique_ptr<Stream> output_stream_storage;
 
     const FileSpec &outfile_spec =
         m_options.m_outfile; // Dump allocation to file instead
     if (outfile_spec) {
       // Open output file
       std::string path = outfile_spec.GetPath();
       auto file = FileSystem::Instance().Open(
           outfile_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate);
       if (file) {
         output_stream_storage =
             std::make_unique<StreamFile>(std::move(file.get()));
         output_stream_p = output_stream_storage.get();
         result.GetOutputStream().Printf("Results written to '%s'",
                                         path.c_str());
         result.GetOutputStream().EOL();
       } else {
         std::string error = llvm::toString(file.takeError());
         result.AppendErrorWithFormat("Couldn't open file '%s': %s",
                                      path.c_str(), error.c_str());
-        result.SetStatus(eReturnStatusFailed);
         return false;
       }
     } else
       output_stream_p = &result.GetOutputStream();
 
     assert(output_stream_p != nullptr);
     bool dumped =
         runtime->DumpAllocation(*output_stream_p, m_exe_ctx.GetFramePtr(), id);
public:
   ~CommandObjectRenderScriptRuntimeAllocationLoad() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc != 2) {
       result.AppendErrorWithFormat(
           "'%s' takes 2 arguments, an allocation ID and filename to read from.",
           m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     const char *id_cstr = command.GetArgumentAtIndex(0);
     bool success = false;
     const uint32_t id =
         StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
     if (!success) {
       result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                    id_cstr);
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     const char *path = command.GetArgumentAtIndex(1);
     bool loaded = runtime->LoadAllocation(result.GetOutputStream(), id, path,
                                           m_exe_ctx.GetFramePtr());
 
     if (loaded)
public:
   ~CommandObjectRenderScriptRuntimeAllocationSave() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc != 2) {
       result.AppendErrorWithFormat(
           "'%s' takes 2 arguments, an allocation ID and filename to read from.",
           m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     const char *id_cstr = command.GetArgumentAtIndex(0);
     bool success = false;
     const uint32_t id =
         StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
     if (!success) {
       result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                    id_cstr);
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     const char *path = command.GetArgumentAtIndex(1);
     bool saved = runtime->SaveAllocation(result.GetOutputStream(), id, path,
                                          m_exe_ctx.GetFramePtr());
 
     if (saved)

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

public:
   ~CommandObjectProcessKDPPacketSend() {}
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       if (!m_command_byte.GetOptionValue().OptionWasSet()) {
         result.AppendError(
             "the --command option must be set to a valid command byte");
-        result.SetStatus(eReturnStatusFailed);
       } else {
         const uint64_t command_byte =
             m_command_byte.GetOptionValue().GetUInt64Value(0);
         if (command_byte > 0 && command_byte <= UINT8_MAX) {
           ProcessKDP *process =
               (ProcessKDP *)m_interpreter.GetExecutionContext().GetProcessPtr();
           if (process) {
             const StateType state = process->GetState();
 
             if (StateIsStoppedState(state, true)) {
               std::vector<uint8_t> payload_bytes;
               const char *ascii_hex_bytes_cstr =
                   m_packet_data.GetOptionValue().GetCurrentValue();
               if (ascii_hex_bytes_cstr && ascii_hex_bytes_cstr[0]) {
                 StringExtractor extractor(ascii_hex_bytes_cstr);
                 const size_t ascii_hex_bytes_cstr_len =
                     extractor.GetStringRef().size();
                 if (ascii_hex_bytes_cstr_len & 1) {
                   result.AppendErrorWithFormat("payload data must contain an "
                                                "even number of ASCII hex "
                                                "characters: '%s'",
                                                ascii_hex_bytes_cstr);
-                  result.SetStatus(eReturnStatusFailed);
                   return false;
                 }
                 payload_bytes.resize(ascii_hex_bytes_cstr_len / 2);
                 if (extractor.GetHexBytes(payload_bytes, '\xdd') !=
                     payload_bytes.size()) {
                   result.AppendErrorWithFormat("payload data must only contain "
                                                "ASCII hex characters (no "
                                                "spaces or hex prefixes): '%s'",
                                                ascii_hex_bytes_cstr);
-                  result.SetStatus(eReturnStatusFailed);
                   return false;
                 }
               }
               Status error;
               DataExtractor reply;
               process->GetCommunication().SendRawRequest(
                   command_byte,
                   payload_bytes.empty() ? NULL : payload_bytes.data(),
if (argc == 0) {
                 return true;
               } else {
                 const char *error_cstr = error.AsCString();
                 if (error_cstr && error_cstr[0])
                   result.AppendError(error_cstr);
                 else
                   result.AppendErrorWithFormat("unknown error 0x%8.8x",
                                                error.GetError());
-                result.SetStatus(eReturnStatusFailed);
                 return false;
               }
             } else {
               result.AppendErrorWithFormat("process must be stopped in order "
                                            "to send KDP packets, state is %s",
                                            StateAsCString(state));
-              result.SetStatus(eReturnStatusFailed);
             }
           } else {
             result.AppendError("invalid process");
-            result.SetStatus(eReturnStatusFailed);
           }
         } else {
           result.AppendErrorWithFormat("invalid command byte 0x%" PRIx64
                                        ", valid values are 1 - 255",
                                        command_byte);
-          result.SetStatus(eReturnStatusFailed);
         }
       }
     } else {
       result.AppendErrorWithFormat("'%s' takes no arguments, only options.",
                                    m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
     }
     return false;
   }
 };
 
 class CommandObjectProcessKDPPacket : public CommandObjectMultiword {
 private:
 public:

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

public:
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       result.AppendErrorWithFormat("'%s' takes an argument to specify the max "
                                    "amount to be transferred when "
                                    "reading/writing",
                                    m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     ProcessGDBRemote *process =
         (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
     if (process) {
       const char *packet_size = command.GetArgumentAtIndex(0);
       errno = 0;
public:
   ~CommandObjectProcessGDBRemotePacketSend() override {}
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       result.AppendErrorWithFormat(
           "'%s' takes a one or more packet content arguments",
           m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     ProcessGDBRemote *process =
         (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
     if (process) {
       for (size_t i = 0; i < argc; ++i) {
         const char *packet_cstr = command.GetArgumentAtIndex(0);
public:
 
   ~CommandObjectProcessGDBRemotePacketMonitor() override {}
 
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     if (command.empty()) {
       result.AppendErrorWithFormat("'%s' takes a command string argument",
                                    m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     ProcessGDBRemote *process =
         (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
     if (process) {
       StreamString packet;
       packet.PutCString("qRcmd,");

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

public:
 
   Options *GetOptions() override { return &m_option_group; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc > 0) {
       result.AppendErrorWithFormat("'%s' take no arguments, only options",
                                    m_cmd_name.c_str());
-      result.SetStatus(eReturnStatusFailed);
       return false;
     }
     SetDefaultOptionsIfNoneAreSet();
 
     ProcessMinidump *process = static_cast<ProcessMinidump *>(
         m_interpreter.GetExecutionContext().GetProcessPtr());
     result.SetStatus(eReturnStatusSuccessFinishResult);
     Stream &s = result.GetOutputStream();

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     // Get the plugin for the process.
     auto plugin_sp =
         process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
     if (!plugin_sp || (plugin_sp->GetPluginName() !=
                        StructuredDataDarwinLog::GetStaticPluginName())) {
       result.AppendError("failed to get StructuredDataPlugin for "
                          "the process");
-      result.SetStatus(eReturnStatusFailed);
     }
     StructuredDataDarwinLog &plugin =
         *static_cast<StructuredDataDarwinLog *>(plugin_sp.get());
 
     if (m_enable) {
       // Hook up the breakpoint for the process that detects when libtrace has
       // been sufficiently initialized to really start the os_log stream.  This
       // is insurance to assure us that logging is really enabled.  Requesting
       // that logging be enabled for a process before libtrace is initialized
       // results in a scenario where no errors occur, but no logging is
       // captured, either.  This step is to eliminate that possibility.
       plugin.AddInitCompletionHook(*process_sp);
     }
 
     // Send configuration to the feature by way of the process. Construct the
     // options we will use.
     auto config_sp = m_options_sp->BuildConfigurationData(m_enable);
     const Status error =
         process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
 
     // Report results.
     if (!error.Success()) {
       result.AppendError(error.AsCString());
-      result.SetStatus(eReturnStatusFailed);
       // Our configuration failed, so we're definitely disabled.
       plugin.SetEnabled(false);
     } else {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       // Our configuration succeeded, so we're enabled/disabled per whichever
       // one this command is setup to do.
       plugin.SetEnabled(m_enable);
     }