[lldb/API] Move SBCommandInterpreterRunOption in its own header. (NFC)

[JDevlieghere]

Summary

Currently, SBCommandInterpreterRunOptions is defined in SBCommandInterpreter.h. Given that the options are always passed by value, a forward declaration of the class as sufficient. That's not the case SBCommandInterpreterRunResults if we want to add a new overload SBCommandInterpreterRunResults RunCommandInterpreter(const SBCommandInterpreterRunOptions &options);.. We can't include SBCommandInterpreter.h because SBCommandInterpreter::GetDebugger() returns SBDebugger by value and therefore needs a full definition.

My plan is to have both SBCommandInterpreterRunOptions and SBCommandInterpreterRunResults defined in this file.

lldb/bindings/headers.swig

 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBlock.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBBreakpointName.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandInterpreterRunOptions.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBCompileUnit.h"
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"

lldb/bindings/interface/SBCommandInterpreter.i

 //===-- SWIG Interface for SBCommandInterpreter -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 namespace lldb {
 
 %feature("docstring",
-"SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.
-A default SBCommandInterpreterRunOptions object has:
-    StopOnContinue: false
-    StopOnError:    false
-    StopOnCrash:    false
-    EchoCommands:   true
-    PrintResults:   true
-    AddToHistory:   true
-
-") SBCommandInterpreterRunOptions;
-class SBCommandInterpreterRunOptions
-{
-friend class SBDebugger;
-public:
-    SBCommandInterpreterRunOptions();
-    ~SBCommandInterpreterRunOptions();
-
-    bool
-    GetStopOnContinue () const;
-
-    void
-    SetStopOnContinue (bool);
-
-    bool
-    GetStopOnError () const;
-
-    void
-    SetStopOnError (bool);
-
-    bool
-    GetStopOnCrash () const;
-
-    void
-    SetStopOnCrash (bool);
-
-    bool
-    GetEchoCommands () const;
-
-    void
-    SetEchoCommands (bool);
-
-    bool
-    GetPrintResults () const;
-
-    void
-    SetPrintResults (bool);
-
-    bool
-    GetAddToHistory () const;
-
-    void
-    SetAddToHistory (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;
-};
-
-%feature("docstring",
 "SBCommandInterpreter handles/interprets commands for lldb.  You get the
 command interpreter from the SBDebugger instance. For example (from test/
 python_api/interpreter/TestCommandInterpreterAPI.py),
 
     def command_interpreter_api(self):
         '''Test the SBCommandInterpreter APIs.'''
         exe = os.path.join(os.getcwd(), 'a.out')
 

lldb/bindings/interface/SBCommandInterpreterRunOptions.i

+//===-- SWIG Interface for SBCommandInterpreter -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+%feature("docstring",
+"SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.
+A default SBCommandInterpreterRunOptions object has:
+    StopOnContinue: false
+    StopOnError:    false
+    StopOnCrash:    false
+    EchoCommands:   true
+    PrintResults:   true
+    AddToHistory:   true
+
+") SBCommandInterpreterRunOptions;
+class SBCommandInterpreterRunOptions
+{
+friend class SBDebugger;
+public:
+    SBCommandInterpreterRunOptions();
+    ~SBCommandInterpreterRunOptions();
+
+    bool
+    GetStopOnContinue () const;
+
+    void
+    SetStopOnContinue (bool);
+
+    bool
+    GetStopOnError () const;
+
+    void
+    SetStopOnError (bool);
+
+    bool
+    GetStopOnCrash () const;
+
+    void
+    SetStopOnCrash (bool);
+
+    bool
+    GetEchoCommands () const;
+
+    void
+    SetEchoCommands (bool);
+
+    bool
+    GetPrintResults () const;
+
+    void
+    SetPrintResults (bool);
+
+    bool
+    GetAddToHistory () const;
+
+    void
+    SetAddToHistory (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;
+};
+
+} // namespace lldb

lldb/bindings/interfaces.swig

 %include "./interface/SBAddress.i"
 %include "./interface/SBAttachInfo.i"
 %include "./interface/SBBlock.i"
 %include "./interface/SBBreakpoint.i"
 %include "./interface/SBBreakpointLocation.i"
 %include "./interface/SBBreakpointName.i"
 %include "./interface/SBBroadcaster.i"
 %include "./interface/SBCommandInterpreter.i"
+%include "./interface/SBCommandInterpreterRunOptions.i"
 %include "./interface/SBCommandReturnObject.i"
 %include "./interface/SBCommunication.i"
 %include "./interface/SBCompileUnit.i"
 %include "./interface/SBData.i"
 %include "./interface/SBDebugger.i"
 %include "./interface/SBDeclaration.i"
 %include "./interface/SBError.i"
 %include "./interface/SBEnvironment.i"

lldb/include/lldb/API/SBCommandInterpreter.h

 
 #include <memory>
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
-class LLDB_API SBCommandInterpreterRunOptions {
-  friend class SBDebugger;
-  friend class SBCommandInterpreter;
-
-public:
-  SBCommandInterpreterRunOptions();
-  ~SBCommandInterpreterRunOptions();
-
-  bool GetStopOnContinue() const;
-
-  void SetStopOnContinue(bool);
-
-  bool GetStopOnError() const;
-
-  void SetStopOnError(bool);
-
-  bool GetStopOnCrash() const;
-
-  void SetStopOnCrash(bool);
-
-  bool GetEchoCommands() const;
-
-  void SetEchoCommands(bool);
-
-  bool GetEchoCommentCommands() const;
-
-  void SetEchoCommentCommands(bool echo);
-
-  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;
-};
-
 class SBCommandInterpreter {
 public:
   enum {
     eBroadcastBitThreadShouldExit = (1 << 0),
     eBroadcastBitResetPrompt = (1 << 1),
     eBroadcastBitQuitCommandReceived = (1 << 2), // User entered quit
     eBroadcastBitAsynchronousOutputData = (1 << 3),
     eBroadcastBitAsynchronousErrorData = (1 << 4)

lldb/include/lldb/API/SBCommandInterpreterRunOptions.h

+//===-- SBCommandInterpreterRunOptions.h ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H
+#define LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H
+
+#include <memory>
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBCommandInterpreterRunOptions {
+  friend class SBDebugger;
+  friend class SBCommandInterpreter;
+
+public:
+  SBCommandInterpreterRunOptions();
+  ~SBCommandInterpreterRunOptions();
+
+  bool GetStopOnContinue() const;
+
+  void SetStopOnContinue(bool);
+
+  bool GetStopOnError() const;
+
+  void SetStopOnError(bool);
+
+  bool GetStopOnCrash() const;
+
+  void SetStopOnCrash(bool);
+
+  bool GetEchoCommands() const;
+
+  void SetEchoCommands(bool);
+
+  bool GetEchoCommentCommands() const;
+
+  void SetEchoCommentCommands(bool echo);
+
+  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;
+};
+
+} // namespace lldb
+
+#endif // LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H

lldb/lldb/bindings/interface/SBCommandInterpreterRunOptions.i

+//===-- SWIG Interface for SBCommandInterpreter -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+%feature("docstring",
+"SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.
+A default SBCommandInterpreterRunOptions object has:
+    StopOnContinue: false
+    StopOnError:    false
+    StopOnCrash:    false
+    EchoCommands:   true
+    PrintResults:   true
+    AddToHistory:   true
+
+") SBCommandInterpreterRunOptions;
+class SBCommandInterpreterRunOptions
+{
+friend class SBDebugger;
+public:
+    SBCommandInterpreterRunOptions();
+    ~SBCommandInterpreterRunOptions();
+
+    bool
+    GetStopOnContinue () const;
+
+    void
+    SetStopOnContinue (bool);
+
+    bool
+    GetStopOnError () const;
+
+    void
+    SetStopOnError (bool);
+
+    bool
+    GetStopOnCrash () const;
+
+    void
+    SetStopOnCrash (bool);
+
+    bool
+    GetEchoCommands () const;
+
+    void
+    SetEchoCommands (bool);
+
+    bool
+    GetPrintResults () const;
+
+    void
+    SetPrintResults (bool);
+
+    bool
+    GetAddToHistory () const;
+
+    void
+    SetAddToHistory (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;
+};
+
+} // namespace lldb

lldb/lldb/include/lldb/API/SBCommandInterpreterRunOptions.h

+//===-- SBCommandInterpreterRunOptions.h ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H
+#define LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H
+
+#include <memory>
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBCommandInterpreterRunOptions {
+  friend class SBDebugger;
+  friend class SBCommandInterpreter;
+
+public:
+  SBCommandInterpreterRunOptions();
+  ~SBCommandInterpreterRunOptions();
+
+  bool GetStopOnContinue() const;
+
+  void SetStopOnContinue(bool);
+
+  bool GetStopOnError() const;
+
+  void SetStopOnError(bool);
+
+  bool GetStopOnCrash() const;
+
+  void SetStopOnCrash(bool);
+
+  bool GetEchoCommands() const;
+
+  void SetEchoCommands(bool);
+
+  bool GetEchoCommentCommands() const;
+
+  void SetEchoCommentCommands(bool echo);
+
+  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;
+};
+
+} // namespace lldb
+
+#endif // LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H

lldb/lldb/source/API/SBCommandInterpreterRunOptions.cpp

+//===-- SBCommandInterpreterRunOptions.cpp --------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/lldb-types.h"
+
+#include "SBReproducerPrivate.h"
+
+#include "lldb/API/SBCommandInterpreterRunOptions.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+
+#include <memory>
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
+
+  m_opaque_up.reset(new CommandInterpreterRunOptions());
+}
+
+SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
+
+bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnContinue);
+
+  return m_opaque_up->GetStopOnContinue();
+}
+
+void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
+                     (bool), stop_on_continue);
+
+  m_opaque_up->SetStopOnContinue(stop_on_continue);
+}
+
+bool SBCommandInterpreterRunOptions::GetStopOnError() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnError);
+
+  return m_opaque_up->GetStopOnError();
+}
+
+void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+                     (bool), stop_on_error);
+
+  m_opaque_up->SetStopOnError(stop_on_error);
+}
+
+bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnCrash);
+
+  return m_opaque_up->GetStopOnCrash();
+}
+
+void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+                     (bool), stop_on_crash);
+
+  m_opaque_up->SetStopOnCrash(stop_on_crash);
+}
+
+bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetEchoCommands);
+
+  return m_opaque_up->GetEchoCommands();
+}
+
+void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+                     (bool), echo_commands);
+
+  m_opaque_up->SetEchoCommands(echo_commands);
+}
+
+bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetEchoCommentCommands);
+
+  return m_opaque_up->GetEchoCommentCommands();
+}
+
+void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
+                     SetEchoCommentCommands, (bool), echo);
+
+  m_opaque_up->SetEchoCommentCommands(echo);
+}
+
+bool SBCommandInterpreterRunOptions::GetPrintResults() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetPrintResults);
+
+  return m_opaque_up->GetPrintResults();
+}
+
+void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
+                     (bool), print_results);
+
+  m_opaque_up->SetPrintResults(print_results);
+}
+
+bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetAddToHistory);
+
+  return m_opaque_up->GetAddToHistory();
+}
+
+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;
+}
+
+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,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetStopOnError, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetStopOnCrash, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetEchoCommands, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetEchoCommentCommands, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
+                       SetEchoCommentCommands, (bool));
+  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));
+}
+
+} // namespace repro
+} // namespace lldb_private

lldb/source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED ${option_framework}
   SBAttachInfo.cpp
   SBBlock.cpp
   SBBreakpoint.cpp
   SBBreakpointLocation.cpp
   SBBreakpointName.cpp
   SBBreakpointOptionCommon.cpp
   SBBroadcaster.cpp
   SBCommandInterpreter.cpp
+  SBCommandInterpreterRunOptions.cpp
   SBCommandReturnObject.cpp
   SBCommunication.cpp
   SBCompileUnit.cpp
   SBData.cpp
   SBDebugger.cpp
   SBDeclaration.cpp
   SBEnvironment.cpp
   SBError.cpp

lldb/source/API/SBCommandInterpreter.cpp

 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Listener.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandInterpreterRunOptions.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
-
-  m_opaque_up.reset(new CommandInterpreterRunOptions());
-}
-
-SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
-
-bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetStopOnContinue);
-
-  return m_opaque_up->GetStopOnContinue();
-}
-
-void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
-                     (bool), stop_on_continue);
-
-  m_opaque_up->SetStopOnContinue(stop_on_continue);
-}
-
-bool SBCommandInterpreterRunOptions::GetStopOnError() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetStopOnError);
-
-  return m_opaque_up->GetStopOnError();
-}
-
-void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
-                     (bool), stop_on_error);
-
-  m_opaque_up->SetStopOnError(stop_on_error);
-}
-
-bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetStopOnCrash);
-
-  return m_opaque_up->GetStopOnCrash();
-}
-
-void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
-                     (bool), stop_on_crash);
-
-  m_opaque_up->SetStopOnCrash(stop_on_crash);
-}
-
-bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetEchoCommands);
-
-  return m_opaque_up->GetEchoCommands();
-}
-
-void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
-                     (bool), echo_commands);
-
-  m_opaque_up->SetEchoCommands(echo_commands);
-}
-
-bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetEchoCommentCommands);
-
-  return m_opaque_up->GetEchoCommentCommands();
-}
-
-void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
-                     SetEchoCommentCommands, (bool), echo);
-
-  m_opaque_up->SetEchoCommentCommands(echo);
-}
-
-bool SBCommandInterpreterRunOptions::GetPrintResults() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetPrintResults);
-
-  return m_opaque_up->GetPrintResults();
-}
-
-void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
-                     (bool), print_results);
-
-  m_opaque_up->SetPrintResults(print_results);
-}
-
-bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetAddToHistory);
-
-  return m_opaque_up->GetAddToHistory();
-}
-
-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;
-}
-
 class CommandPluginInterfaceImplementation : public CommandObjectParsed {
 public:
   CommandPluginInterfaceImplementation(CommandInterpreter &interpreter,
                                        const char *name,
                                        lldb::SBCommandPluginInterface *backend,
                                        const char *help = nullptr,
                                        const char *syntax = nullptr,
                                        uint32_t flags = 0,
void SBCommand::SetFlags(uint32_t flags) {
 
   if (IsValid())
     m_opaque_sp->GetFlags().Set(flags);
 }
 
 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, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetStopOnError, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetStopOnCrash, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetEchoCommands, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetEchoCommentCommands, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
-                       SetEchoCommentCommands, (bool));
-  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));
+template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) {
   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_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
                        (const char *, lldb::SBCommandPluginInterface *,
                         const char *, const char *));
   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
                        (const char *, lldb::SBCommandPluginInterface *,
                         const char *, const char *, const char *));
   LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
   LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
 }
-
 }
 }

lldb/source/API/SBCommandInterpreterRunOptions.cpp

+//===-- SBCommandInterpreterRunOptions.cpp --------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/lldb-types.h"
+
+#include "SBReproducerPrivate.h"
+
+#include "lldb/API/SBCommandInterpreterRunOptions.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+
+#include <memory>
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
+
+  m_opaque_up.reset(new CommandInterpreterRunOptions());
+}
+
+SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
+
+bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnContinue);
+
+  return m_opaque_up->GetStopOnContinue();
+}
+
+void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
+                     (bool), stop_on_continue);
+
+  m_opaque_up->SetStopOnContinue(stop_on_continue);
+}
+
+bool SBCommandInterpreterRunOptions::GetStopOnError() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnError);
+
+  return m_opaque_up->GetStopOnError();
+}
+
+void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+                     (bool), stop_on_error);
+
+  m_opaque_up->SetStopOnError(stop_on_error);
+}
+
+bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnCrash);
+
+  return m_opaque_up->GetStopOnCrash();
+}
+
+void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+                     (bool), stop_on_crash);
+
+  m_opaque_up->SetStopOnCrash(stop_on_crash);
+}
+
+bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetEchoCommands);
+
+  return m_opaque_up->GetEchoCommands();
+}
+
+void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+                     (bool), echo_commands);
+
+  m_opaque_up->SetEchoCommands(echo_commands);
+}
+
+bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetEchoCommentCommands);
+
+  return m_opaque_up->GetEchoCommentCommands();
+}
+
+void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
+                     SetEchoCommentCommands, (bool), echo);
+
+  m_opaque_up->SetEchoCommentCommands(echo);
+}
+
+bool SBCommandInterpreterRunOptions::GetPrintResults() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetPrintResults);
+
+  return m_opaque_up->GetPrintResults();
+}
+
+void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
+                     (bool), print_results);
+
+  m_opaque_up->SetPrintResults(print_results);
+}
+
+bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetAddToHistory);
+
+  return m_opaque_up->GetAddToHistory();
+}
+
+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;
+}
+
+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,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetStopOnError, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetStopOnCrash, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetEchoCommands, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+                       (bool));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+                             GetEchoCommentCommands, ());
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
+                       SetEchoCommentCommands, (bool));
+  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));
+}
+
+} // namespace repro
+} // namespace lldb_private

lldb/source/API/SBDebugger.cpp

 #include "SystemInitializerFull.h"
 
 #include "lldb/API/SBDebugger.h"
 
 #include "lldb/lldb-private.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandInterpreterRunOptions.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSourceManager.h"

lldb/source/API/SBReproducer.cpp

 
 #include "SBReproducerPrivate.h"
 #include "lldb/API/LLDB.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBlock.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandInterpreterRunOptions.h"
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBReproducer.h"
 #include "lldb/Host/FileSystem.h"
SBRegistry::SBRegistry() {
   RegisterMethods<SBAddress>(R);
   RegisterMethods<SBAttachInfo>(R);
   RegisterMethods<SBBlock>(R);
   RegisterMethods<SBBreakpoint>(R);
   RegisterMethods<SBBreakpointList>(R);
   RegisterMethods<SBBreakpointLocation>(R);
   RegisterMethods<SBBreakpointName>(R);
   RegisterMethods<SBBroadcaster>(R);
+  RegisterMethods<SBCommandInterpreter>(R);
   RegisterMethods<SBCommandInterpreterRunOptions>(R);
   RegisterMethods<SBCommandReturnObject>(R);
   RegisterMethods<SBCommunication>(R);
   RegisterMethods<SBCompileUnit>(R);
   RegisterMethods<SBData>(R);
   RegisterMethods<SBInputReader>(R);
   RegisterMethods<SBDebugger>(R);
   RegisterMethods<SBDeclaration>(R);

lldb/tools/driver/Driver.cpp

 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 
 #include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandInterpreterRunOptions.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"