[lldb/CommandInterpreter] Move AutoHandleEvents and SpawnThread into CommandInterpreterRunOptions (NFC)

[JDevlieghere]

Summary

This implements Greg's suggestion from D78825 to include AutoHandleEvents and SpawnThread in CommandInterpreterRunOptions. This is in preparation for adding a new overload for RunCommandInterpreter: SBCommandInterpreterRunResults RunCommandInterpreter(SBCommandInterpreterRunOptions &options);.

[JDevlieghere]

Add reproducer instrumentation.

[labath]

lldb/source/API/SBDebugger.cpp

1189–1190

Maybe document somewhere that the arguments take precedence over what's present in SBCommandInterpreterRunOptions

[clayborg]

lldb/source/API/SBDebugger.cpp

1190

I agree this is a good idea to do in the header doc. Also might be worth marking this and other functions RunCommandInterpreter as deprecated and point them to the new way of doing things once that patch is in where everything is in SBCommandInterpreterRunOptions and SBCommandInterpreterRunResults

lldb/include/lldb/API/SBCommandInterpreter.h

public:
   bool GetPrintResults() const;
 
   void SetPrintResults(bool);
 
   bool GetAddToHistory() const;
 
   void SetAddToHistory(bool);
 
+  bool GetAutoHandleEvents() const;
+
+  void SetAutoHandleEvents(bool);
+
+  bool GetSpawnThread() const;
+
+  void SetSpawnThread(bool);
+
 private:
   lldb_private::CommandInterpreterRunOptions *get() const;
 
   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;

lldb/include/lldb/API/SBDebugger.h

public:
   SBTypeFormat GetFormatForType(SBTypeNameSpecifier);
 
   SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
 
   SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
 
   SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
 
+  /// Run the command interpreter.
+  ///
+  /// \param[in] auto_handle_events
+  ///     If true, automatically handle resulting events. This takes precedence
+  ///     and overrides the corresponding option in
+  ///     SBCommandInterpreterRunOptions.
+  ///
+  /// \param[in] spawn_thread
+  ///     If true, start a new thread for IO handling. This takes precedence
+  ///     and overrides the corresponding option in
+  ///     SBCommandInterpreterRunOptions.
   void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread);
 
+  /// Run the command interpreter.
+  ///
+  /// \param[in] auto_handle_events
+  ///     If true, automatically handle resulting events. This takes precedence
+  ///     and overrides the corresponding option in
+  ///     SBCommandInterpreterRunOptions.
+  ///
+  /// \param[in] spawn_thread
+  ///     If true, start a new thread for IO handling. This takes precedence
+  ///     and overrides the corresponding option in
+  ///     SBCommandInterpreterRunOptions.
+  ///
+  /// \param[in] options
+  ///     Parameter collection of type SBCommandInterpreterRunOptions.
+  ///
+  /// \param[out] num_errors
+  ///     The number of errors.
+  ///
+  /// \param[out] quit_requested
+  ///     Whether a quit was requested.
+  ///
+  /// \param[out] stopped_for_crash
+  ///     Whether the interpreter stopped for a crash.
   void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread,
                              SBCommandInterpreterRunOptions &options,
                              int &num_errors, bool &quit_requested,
                              bool &stopped_for_crash);
 
   SBError RunREPL(lldb::LanguageType language, const char *repl_options);
 
 private:

lldb/include/lldb/Interpreter/CommandInterpreter.h

public:
   }
 
   bool GetAddToHistory() const { return DefaultToYes(m_add_to_history); }
 
   void SetAddToHistory(bool add_to_history) {
     m_add_to_history = add_to_history ? eLazyBoolYes : eLazyBoolNo;
   }
 
+  bool GetAutoHandleEvents() const {
+    return DefaultToYes(m_auto_handle_events);
+  }
+
+  void SetAutoHandleEvents(bool auto_handle_events) {
+    m_auto_handle_events = auto_handle_events ? eLazyBoolYes : eLazyBoolNo;
+  }
+
+  bool GetSpawnThread() const { return DefaultToNo(m_spawn_thread); }
+
+  void SetSpawnThread(bool spawn_thread) {
+    m_spawn_thread = spawn_thread ? eLazyBoolYes : eLazyBoolNo;
+  }
+
   LazyBool m_stop_on_continue;
   LazyBool m_stop_on_error;
   LazyBool m_stop_on_crash;
   LazyBool m_echo_commands;
   LazyBool m_echo_comment_commands;
   LazyBool m_print_results;
   LazyBool m_print_errors;
   LazyBool m_add_to_history;
+  LazyBool m_auto_handle_events;
+  LazyBool m_spawn_thread;
 
 private:
   static bool DefaultToYes(LazyBool flag) {
     switch (flag) {
     case eLazyBoolNo:
       return false;
     default:
       return true;
return "*** Some of your variables have more members than the debugger "
            "--show-all-children option to %s or raise the limit by changing "
            "the target.max-children-count setting.\n";
   }
 
   CommandHistory &GetCommandHistory() { return m_command_history; }
 
   bool IsActive();
 
-  void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread,
-                             CommandInterpreterRunOptions &options);
+  void RunCommandInterpreter(CommandInterpreterRunOptions &options);
 
   void GetLLDBCommandsFromIOHandler(const char *prompt,
                                     IOHandlerDelegate &delegate,
                                     void *baton = nullptr);
 
   void GetPythonCommandsFromIOHandler(const char *prompt,
                                       IOHandlerDelegate &delegate,
                                       void *baton = nullptr);

lldb/source/API/SBCommandInterpreter.cpp

 
 void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
                      (bool), add_to_history);
 
   m_opaque_up->SetAddToHistory(add_to_history);
 }
 
+bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetAutoHandleEvents);
+
+  return m_opaque_up->GetAutoHandleEvents();
+}
+
+void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
+    bool auto_handle_events) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents,
+                     (bool), auto_handle_events);
+
+  m_opaque_up->SetAutoHandleEvents(auto_handle_events);
+}
+
+bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetSpawnThread);
+
+  return m_opaque_up->GetSpawnThread();
+}
+
+void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
+                     (bool), spawn_thread);
+
+  m_opaque_up->SetSpawnThread(spawn_thread);
+}
+
 lldb_private::CommandInterpreterRunOptions *
 SBCommandInterpreterRunOptions::get() const {
   return m_opaque_up.get();
 }
 
 lldb_private::CommandInterpreterRunOptions &
 SBCommandInterpreterRunOptions::ref() const {
   return *m_opaque_up;
void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
                              GetPrintResults, ());
   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
                        (bool));
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
                              GetAddToHistory, ());
   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
                        (bool));
+  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(SBCommandInterpreter,
                             (lldb_private::CommandInterpreter *));
   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
                             (const lldb::SBCommandInterpreter &));
   LLDB_REGISTER_METHOD(
       const lldb::SBCommandInterpreter &,
       SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());

lldb/source/API/SBDebugger.cpp

 
 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool spawn_thread) {
   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
                      auto_handle_events, spawn_thread);
 
   if (m_opaque_sp) {
     CommandInterpreterRunOptions options;
-
-    m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
-        auto_handle_events, spawn_thread, options);
+    options.SetAutoHandleEvents(auto_handle_events);
+    options.SetSpawnThread(spawn_thread);
+    m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(options);
   }
 }
 
 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool spawn_thread,
                                        SBCommandInterpreterRunOptions &options,
                                        int &num_errors, bool &quit_requested,
                                        bool &stopped_for_crash)
 
 {
   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
                      (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
                       bool &, bool &),
                      auto_handle_events, spawn_thread, options, num_errors,
                      quit_requested, stopped_for_crash);
 
   if (m_opaque_sp) {
+    options.SetAutoHandleEvents(auto_handle_events);
+    options.SetSpawnThread(spawn_thread);
     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
-    interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
-                                 options.ref());
+    interp.RunCommandInterpreter(options.ref());
     num_errors = interp.GetNumErrors();
     quit_requested = interp.GetQuitRequested();
     stopped_for_crash = interp.GetStoppedForCrash();
   }
 }
 
 SBError SBDebugger::RunREPL(lldb::LanguageType language,
                             const char *repl_options) {

lldb/source/Interpreter/CommandInterpreter.cpp

m_command_io_handler_sp = std::make_shared<IOHandlerEditline>(
         0,     // Don't show line numbers
         *this, // IOHandlerDelegate
         GetDebugger().GetInputRecorder());
   }
   return m_command_io_handler_sp;
 }
 
 void CommandInterpreter::RunCommandInterpreter(
-    bool auto_handle_events, bool spawn_thread,
     CommandInterpreterRunOptions &options) {
   // Always re-create the command interpreter when we run it in case any file
   // handles have changed.
   bool force_create = true;
   m_debugger.RunIOHandlerAsync(GetIOHandler(force_create, &options));
   m_stopped_for_crash = false;
 
-  if (auto_handle_events)
+  if (options.GetAutoHandleEvents())
     m_debugger.StartEventHandlerThread();
 
-  if (spawn_thread) {
+  if (options.GetSpawnThread()) {
     m_debugger.StartIOHandlerThread();
   } else {
     m_debugger.RunIOHandlers();
 
-    if (auto_handle_events)
+    if (options.GetAutoHandleEvents())
       m_debugger.StopEventHandlerThread();
   }
 }
 
 CommandObject *
 CommandInterpreter::ResolveCommandImpl(std::string &command_line,
                                        CommandReturnObject &result) {
   std::string scratch_command(command_line); // working copy so we don't modify