[lldb/API] Add RunCommandInterpreter overload that returns SBCommandInterpreterRunResults (NFC)

[JDevlieghere]

Summary

This adds an RunCommandInterpreter overload that returns an instance of SBCommandInterpreterRunResults. The goal is to avoid having to add more and more overloads when we need more output arguments.

[clayborg]

Yeah, anytime you see API calls that have many arguments it is a good idea to switch to this kind of API as adding accessors doesn't require us to change the API. We did this with SBTarget::Attach() and SBTarget::Launch() after having many variants of these functions...

[clayborg]

Sorry, missed the fact that the new class had ivars. For ABI stability, we can't modify the number of ivars since we need the class size of SBCommandInterpreterRunResults to never change even if we add more things to it.

lldb/include/lldb/API/SBCommandInterpreterRunOptions.h

90–93

We need to abstract these, they can't be in the lldb::SB class. So you just need to make an opaque class that contains these ivar and use a std::unique_ptr to the opaque class.

[clayborg]

lldb/include/lldb/API/SBCommandInterpreterRunOptions.h

93

like how SBCommandInterpreterRunOptions does it above with its ivar "m_opaque_up" that never changes size

[labath]

Here I would be interested to know whether the "stop reasons" are mutually exclusive? It sounds like they should be...

And if they are, it seems that a better way to express this would be via something like GetRunResult which returns Success, or InferiorCrash, or CommandError, or QuitRequested. Other reasons can be added to the enum later, if needed...

lldb/include/lldb/API/SBCommandInterpreterRunOptions.h

private:
 
   lldb_private::CommandInterpreterRunOptions &ref() const;
 
   // This is set in the constructor and will always be valid.
   mutable std::unique_ptr<lldb_private::CommandInterpreterRunOptions>
       m_opaque_up;
 };
 
+class LLDB_API SBCommandInterpreterRunResults {
+  friend class SBDebugger;
+  friend class SBCommandInterpreter;
+
+public:
+  SBCommandInterpreterRunResults();
+  ~SBCommandInterpreterRunResults() = default;
+
+  int GetNumberOfErrors() const;
+  bool GetQuitRequested() const;
+  bool GetStoppedForCrash() const;
+
+protected:
+  void SetNumberOfErrors(int);
+  void SetQuitRequested(bool);
+  void SetStoppedForCrash(bool);
+
+private:
+  int m_num_errors;
+  bool m_quit_requested;
+  bool m_stopped_for_crash;
+};
+
 } // namespace lldb
 
 #endif // LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H

lldb/include/lldb/API/SBDebugger.h

public:
 
   void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread);
 
   void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread,
                              SBCommandInterpreterRunOptions &options,
                              int &num_errors, bool &quit_requested,
                              bool &stopped_for_crash);
 
+  SBCommandInterpreterRunResults
+  RunCommandInterpreter(const SBCommandInterpreterRunOptions &options);
+
   SBError RunREPL(lldb::LanguageType language, const char *repl_options);
 
 private:
   friend class SBCommandInterpreter;
   friend class SBInputReader;
   friend class SBListener;
   friend class SBProcess;
   friend class SBSourceManager;

lldb/include/lldb/API/SBDefines.h

 class LLDB_API SBBreakpoint;
 class LLDB_API SBBreakpointLocation;
 class LLDB_API SBBreakpointName;
 class LLDB_API SBBreakpointNameImpl;
 class LLDB_API SBBroadcaster;
 class LLDB_API SBCommand;
 class LLDB_API SBCommandInterpreter;
 class LLDB_API SBCommandInterpreterRunOptions;
+class LLDB_API SBCommandInterpreterRunResults;
 class LLDB_API SBCommandPluginInterface;
 class LLDB_API SBCommandReturnObject;
 class LLDB_API SBCommunication;
 class LLDB_API SBCompileUnit;
 class LLDB_API SBData;
 class LLDB_API SBDebugger;
 class LLDB_API SBDeclaration;
 class LLDB_API SBEnvironment;

lldb/source/API/SBCommandInterpreterRunOptions.cpp

SBCommandInterpreterRunOptions::get() const {
   return m_opaque_up.get();
 }
 
 lldb_private::CommandInterpreterRunOptions &
 SBCommandInterpreterRunOptions::ref() const {
   return *m_opaque_up;
 }
 
+SBCommandInterpreterRunResults::SBCommandInterpreterRunResults()
+    : m_num_errors(0), m_quit_requested(false), m_stopped_for_crash(false) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResults);
+}
+
+int SBCommandInterpreterRunResults::GetNumberOfErrors() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResults,
+                                   GetNumberOfErrors);
+
+  return m_num_errors;
+}
+
+bool SBCommandInterpreterRunResults::GetQuitRequested() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunResults,
+                                   GetQuitRequested);
+
+  return m_quit_requested;
+}
+
+bool SBCommandInterpreterRunResults::GetStoppedForCrash() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunResults,
+                                   GetStoppedForCrash);
+
+  return m_stopped_for_crash;
+}
+
+void SBCommandInterpreterRunResults::SetNumberOfErrors(int num_errors) {
+  m_num_errors = num_errors;
+}
+
+void SBCommandInterpreterRunResults::SetQuitRequested(bool quit_requested) {
+  m_quit_requested = quit_requested;
+}
+void SBCommandInterpreterRunResults::SetStoppedForCrash(
+    bool stopped_for_crash) {
+  m_stopped_for_crash = stopped_for_crash;
+}
+
 namespace lldb_private {
 namespace repro {
 
 template <> void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
                              GetStopOnContinue, ());
   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
template <> void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
                              GetAutoHandleEvents, ());
   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
                        SetAutoHandleEvents, (bool));
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
                              GetSpawnThread, ());
   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
                        (bool));
+  LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunResults, ());
+  LLDB_REGISTER_METHOD_CONST(int, SBCommandInterpreterRunResults,
+                             GetNumberOfErrors, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunResults,
+                             GetQuitRequested, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunResults,
+                             GetStoppedForCrash, ());
 }
 
 } // namespace repro
 } // namespace lldb_private

lldb/source/API/SBDebugger.cpp

     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
     interp.RunCommandInterpreter(options.ref());
     num_errors = interp.GetNumErrors();
     quit_requested = interp.GetQuitRequested();
     stopped_for_crash = interp.GetStoppedForCrash();
   }
 }
 
+SBCommandInterpreterRunResults SBDebugger::RunCommandInterpreter(
+    const SBCommandInterpreterRunOptions &options) {
+  if (!m_opaque_sp)
+    return {};
+
+  CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
+  interp.RunCommandInterpreter(options.ref());
+
+  SBCommandInterpreterRunResults results;
+  results.SetNumberOfErrors(interp.GetNumErrors());
+  results.SetQuitRequested(interp.GetQuitRequested());
+  results.SetStoppedForCrash(interp.GetStoppedForCrash());
+
+  return results;
+}
+
 SBError SBDebugger::RunREPL(lldb::LanguageType language,
                             const char *repl_options) {
   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
                      (lldb::LanguageType, const char *), language,
                      repl_options);
 
   SBError error;
   if (m_opaque_sp)

lldb/tools/driver/Driver.cpp

#endif
   const bool spawn_thread = false;
 
   // Check if we have any data in the commands stream, and if so, save it to a
   // temp file
   // so we can then run the command interpreter using the file contents.
   const char *commands_data = commands_stream.GetData();
   const size_t commands_size = commands_stream.GetSize();
 
-  // The command file might have requested that we quit, this variable will
-  // track that.
-  bool quit_requested = false;
-  bool stopped_for_crash = false;
+  bool go_interactive = true;
   if ((commands_data != nullptr) && (commands_size != 0u)) {
     FILE *commands_file =
         PrepareCommandsForSourcing(commands_data, commands_size);
 
     if (commands_file == nullptr) {
       // We should have already printed an error in PrepareCommandsForSourcing.
       exit(1);
     }
 
     m_debugger.SetInputFileHandle(commands_file, true);
 
-    // Set the debugger into Sync mode when running the command file.
-    // Otherwise command files
-    // that run the target won't run in a sensible way.
+    // Set the debugger into Sync mode when running the command file. Otherwise
+    // command files that run the target won't run in a sensible way.
     bool old_async = m_debugger.GetAsync();
     m_debugger.SetAsync(false);
-    int num_errors = 0;
 
     SBCommandInterpreterRunOptions options;
+    options.SetAutoHandleEvents(true);
+    options.SetSpawnThread(false);
     options.SetStopOnError(true);
-    if (m_option_data.m_batch)
-      options.SetStopOnCrash(true);
+    options.SetStopOnCrash(m_option_data.m_batch);
 
-    m_debugger.RunCommandInterpreter(handle_events, spawn_thread, options,
-                                     num_errors, quit_requested,
-                                     stopped_for_crash);
+    SBCommandInterpreterRunResults results =
+        m_debugger.RunCommandInterpreter(options);
+    if (results.GetQuitRequested())
+      go_interactive = false;
+    if (m_option_data.m_batch && !results.GetStoppedForCrash())
+      go_interactive = false;
 
-    if (m_option_data.m_batch && stopped_for_crash &&
+    if (m_option_data.m_batch && results.GetStoppedForCrash() &&
         !m_option_data.m_after_crash_commands.empty()) {
       SBStream crash_commands_stream;
       WriteCommandsForSourcing(eCommandPlacementAfterCrash,
                                crash_commands_stream);
       const char *crash_commands_data = crash_commands_stream.GetData();
       const size_t crash_commands_size = crash_commands_stream.GetSize();
       commands_file =
           PrepareCommandsForSourcing(crash_commands_data, crash_commands_size);
       if (commands_file != nullptr) {
-        bool local_quit_requested;
-        bool local_stopped_for_crash;
         m_debugger.SetInputFileHandle(commands_file, true);
-
-        m_debugger.RunCommandInterpreter(handle_events, spawn_thread, options,
-                                         num_errors, local_quit_requested,
-                                         local_stopped_for_crash);
-        if (local_quit_requested)
-          quit_requested = true;
+        SBCommandInterpreterRunResults local_results =
+            m_debugger.RunCommandInterpreter(options);
+        if (local_results.GetQuitRequested())
+          go_interactive = false;
       }
     }
     m_debugger.SetAsync(old_async);
   }
 
-  // Now set the input file handle to STDIN and run the command
-  // interpreter again in interactive mode or repl mode and let the debugger
-  // take ownership of stdin
-
-  bool go_interactive = true;
-  if (quit_requested)
-    go_interactive = false;
-  else if (m_option_data.m_batch && !stopped_for_crash)
-    go_interactive = false;
-
+  // Now set the input file handle to STDIN and run the command interpreter
+  // again in interactive mode or repl mode and let the debugger take ownership
+  // of stdin.
   if (go_interactive) {
     m_debugger.SetInputFileHandle(stdin, true);
 
     if (m_option_data.m_repl) {
       const char *repl_options = nullptr;
       if (!m_option_data.m_repl_options.empty())
         repl_options = m_option_data.m_repl_options.c_str();
       SBError error(