[ScriptInterpreter] Pass the debugger instead of the command interpreter

[JDevlieghere]

Summary

As discussed in D61090, there's no good reason for the script interpreter to depend on the command interpreter. When looking at the code, it becomes clear that we mostly use the command interpreter as a way to access the debugger. Hence, it makes more sense to just pass that to the script interpreter directly.

This is part 1 out of 2. I have another patch in the pipeline that changes the ownership of the script interpreter to the debugger as well, but I didn't get around to finish that today.

[labath]

Seems like a good change to me, but Jim should have a look as he requested that.

[jingham]

Looks good to me too. The fact that you were mostly eliminating redirections from CommandInterpreter -> Debugger is good evidence this was wrongly structured initially.

I'm a little curious that we do:

m_debugger.GetCommandInterpreter().GetPythonCommandsFromIOHandler

to read "break command add -s python" command text. Seems like the script interpreter IO handler should do this otherwise the Command Interpreter has to know the right way to do input for every script interpreter. But I think that's a change for another patch.

This one seems pure goodness.

[jingham]

Oops, forgot to do the action part of this...

lldb/trunk/include/lldb/Core/PluginManager.h

public:
 
   static bool UnregisterPlugin(ScriptInterpreterCreateInstance create_callback);
 
   static ScriptInterpreterCreateInstance
   GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx);
 
   static lldb::ScriptInterpreterSP
   GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang,
-                                  CommandInterpreter &interpreter);
+                                  Debugger &debugger);
 
   // StructuredDataPlugin
 
   /// Register a StructuredDataPlugin class along with optional
   /// callbacks for debugger initialization and Process launch info
   /// filtering and manipulation.
   ///
   /// \param[in] name

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

typedef enum {
     eScriptReturnTypeLongLongUnsigned,
     eScriptReturnTypeFloat,
     eScriptReturnTypeDouble,
     eScriptReturnTypeChar,
     eScriptReturnTypeCharStrOrNone,
     eScriptReturnTypeOpaqueObject
   } ScriptReturnType;
 
-  ScriptInterpreter(CommandInterpreter &interpreter,
-                    lldb::ScriptLanguage script_lang);
+  ScriptInterpreter(Debugger &debugger, lldb::ScriptLanguage script_lang);
 
   ~ScriptInterpreter() override;
 
   struct ExecuteScriptOptions {
   public:
     ExecuteScriptOptions()
         : m_enable_io(true), m_set_lldb_globals(true), m_maskout_errors(true) {}
 
public:
   }
 
   virtual StructuredData::GenericSP
   CreateScriptedBreakpointResolver(const char *class_name,
                                    StructuredDataImpl *args_data,
                                    lldb::BreakpointSP &bkpt_sp) {
     return StructuredData::GenericSP();
   }
-  
   virtual bool
   ScriptedBreakpointResolverSearchCallback(StructuredData::GenericSP implementor_sp,
                                            SymbolContext *sym_ctx)
   {
     return false;
   }
 
   virtual lldb::SearchDepth
public:
   virtual bool IsReservedWord(const char *word) { return false; }
 
   virtual std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock();
 
   const char *GetScriptInterpreterPtyName();
 
   int GetMasterFileDescriptor();
 
-  CommandInterpreter &GetCommandInterpreter();
-
   static std::string LanguageToString(lldb::ScriptLanguage language);
 
   static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
 
   virtual void ResetOutputFileHandle(FILE *new_fh) {} // By default, do nothing.
 
   lldb::ScriptLanguage GetLanguage() { return m_script_lang; }
 
 protected:
-  CommandInterpreter &m_interpreter;
+  Debugger &m_debugger;
   lldb::ScriptLanguage m_script_lang;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ScriptInterpreter_h_

lldb/trunk/include/lldb/lldb-private-interfaces.h

typedef Status (*StructuredDataFilterLaunchInfo)(ProcessLaunchInfo &launch_info,
                                                  Target *target);
 typedef SystemRuntime *(*SystemRuntimeCreateInstance)(Process *process);
 typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
                                                    const ArchSpec *arch);
 typedef lldb::ProcessSP (*ProcessCreateInstance)(
     lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
     const FileSpec *crash_file_path);
 typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(
-    CommandInterpreter &interpreter);
+    Debugger &debugger);
 typedef SymbolFile *(*SymbolFileCreateInstance)(ObjectFile *obj_file);
 typedef SymbolVendor *(*SymbolVendorCreateInstance)(
     const lldb::ModuleSP &module_sp,
     lldb_private::Stream
         *feedback_strm); // Module can be NULL for default system symbol vendor
 typedef bool (*BreakpointHitCallback)(void *baton,
                                       StoppointCallbackContext *context,
                                       lldb::user_id_t break_id,

lldb/trunk/source/Core/PluginManager.cpp

 PluginManager::GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx) {
   std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
   ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
   if (idx < instances.size())
     return instances[idx].create_callback;
   return nullptr;
 }
 
-lldb::ScriptInterpreterSP PluginManager::GetScriptInterpreterForLanguage(
-    lldb::ScriptLanguage script_lang, CommandInterpreter &interpreter) {
+lldb::ScriptInterpreterSP
+PluginManager::GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang,
+                                               Debugger &debugger) {
   std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
   ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
 
   ScriptInterpreterInstances::iterator pos, end = instances.end();
   ScriptInterpreterCreateInstance none_instance = nullptr;
   for (pos = instances.begin(); pos != end; ++pos) {
     if (pos->language == lldb::eScriptLanguageNone)
       none_instance = pos->create_callback;
 
     if (script_lang == pos->language)
-      return pos->create_callback(interpreter);
+      return pos->create_callback(debugger);
   }
 
   // If we didn't find one, return the ScriptInterpreter for the null language.
   assert(none_instance != nullptr);
-  return none_instance(interpreter);
+  return none_instance(debugger);
 }
 
 #pragma mark -
 #pragma mark StructuredDataPlugin
 
 // StructuredDataPlugin
 
 struct StructuredDataPluginInstance {

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

 
 ScriptInterpreter *CommandInterpreter::GetScriptInterpreter(bool can_create) {
   std::lock_guard<std::recursive_mutex> locker(m_script_interpreter_mutex);
   if (!m_script_interpreter_sp) {
     if (!can_create)
       return nullptr;
     lldb::ScriptLanguage script_lang = GetDebugger().GetScriptLanguage();
     m_script_interpreter_sp =
-        PluginManager::GetScriptInterpreterForLanguage(script_lang, *this);
+        PluginManager::GetScriptInterpreterForLanguage(script_lang, m_debugger);
   }
   return m_script_interpreter_sp.get();
 }
 
 bool CommandInterpreter::GetSynchronous() { return m_synchronous_execution; }
 
 void CommandInterpreter::SetSynchronous(bool value) {
   m_synchronous_execution = value;

lldb/trunk/source/Interpreter/ScriptInterpreter.cpp

 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-ScriptInterpreter::ScriptInterpreter(CommandInterpreter &interpreter,
+ScriptInterpreter::ScriptInterpreter(Debugger &debugger,
                                      lldb::ScriptLanguage script_lang)
-    : m_interpreter(interpreter), m_script_lang(script_lang) {}
+    : m_debugger(debugger), m_script_lang(script_lang) {}
 
 ScriptInterpreter::~ScriptInterpreter() {}
 
-CommandInterpreter &ScriptInterpreter::GetCommandInterpreter() {
-  return m_interpreter;
-}
-
 void ScriptInterpreter::CollectDataForBreakpointCommandCallback(
     std::vector<BreakpointOptions *> &bp_options_vec,
     CommandReturnObject &result) {
   result.SetStatus(eReturnStatusFailed);
   result.AppendError(
       "ScriptInterpreter::GetScriptCommands(StringList &) is not implemented.");
 }
 

lldb/trunk/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h

 #define liblldb_ScriptInterpreterNone_h_
 
 #include "lldb/Interpreter/ScriptInterpreter.h"
 
 namespace lldb_private {
 
 class ScriptInterpreterNone : public ScriptInterpreter {
 public:
-  ScriptInterpreterNone(CommandInterpreter &interpreter);
+  ScriptInterpreterNone(Debugger &debugger);
 
   ~ScriptInterpreterNone() override;
 
   bool ExecuteOneLine(
       llvm::StringRef command, CommandReturnObject *result,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
 
   void ExecuteInterpreterLoop() override;
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
-  static lldb::ScriptInterpreterSP
-  CreateInstance(CommandInterpreter &interpreter);
+  static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ScriptInterpreterNone_h_

lldb/trunk/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

 //===-- ScriptInterpreterNone.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 "ScriptInterpreterNone.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 
 #include "llvm/Support/Threading.h"
 
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
 
-ScriptInterpreterNone::ScriptInterpreterNone(CommandInterpreter &interpreter)
-    : ScriptInterpreter(interpreter, eScriptLanguageNone) {}
+ScriptInterpreterNone::ScriptInterpreterNone(Debugger &debugger)
+    : ScriptInterpreter(debugger, eScriptLanguageNone) {}
 
 ScriptInterpreterNone::~ScriptInterpreterNone() {}
 
 bool ScriptInterpreterNone::ExecuteOneLine(llvm::StringRef command,
                                            CommandReturnObject *,
                                            const ExecuteScriptOptions &) {
-  m_interpreter.GetDebugger().GetErrorFile()->PutCString(
+  m_debugger.GetErrorFile()->PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
   return false;
 }
 
 void ScriptInterpreterNone::ExecuteInterpreterLoop() {
-  m_interpreter.GetDebugger().GetErrorFile()->PutCString(
+  m_debugger.GetErrorFile()->PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
 }
 
 void ScriptInterpreterNone::Initialize() {
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(),
                                   lldb::eScriptLanguageNone, CreateInstance);
   });
 }
 
 void ScriptInterpreterNone::Terminate() {}
 
 lldb::ScriptInterpreterSP
-ScriptInterpreterNone::CreateInstance(CommandInterpreter &interpreter) {
-  return std::make_shared<ScriptInterpreterNone>(interpreter);
+ScriptInterpreterNone::CreateInstance(Debugger &debugger) {
+  return std::make_shared<ScriptInterpreterNone>(debugger);
 }
 
 lldb_private::ConstString ScriptInterpreterNone::GetPluginNameStatic() {
   static ConstString g_name("script-none");
   return g_name;
 }
 
 const char *ScriptInterpreterNone::GetPluginDescriptionStatic() {
   return "Null script interpreter";
 }
 
 lldb_private::ConstString ScriptInterpreterNone::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t ScriptInterpreterNone::GetPluginVersion() { return 1; }

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

 public:
   class CommandDataPython : public BreakpointOptions::CommandData {
   public:
     CommandDataPython() : BreakpointOptions::CommandData() {
       interpreter = lldb::eScriptLanguagePython;
     }
   };
 
-  ScriptInterpreterPython(CommandInterpreter &interpreter)
-      : ScriptInterpreter(interpreter, lldb::eScriptLanguagePython),
+  ScriptInterpreterPython(Debugger &debugger)
+      : ScriptInterpreter(debugger, lldb::eScriptLanguagePython),
         IOHandlerDelegateMultiline("DONE") {}
 
   static void Initialize();
   static void Terminate();
   static lldb_private::ConstString GetPluginNameStatic();
   static const char *GetPluginDescriptionStatic();
   static FileSpec GetPythonDir();
 

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 }
 
 ScriptInterpreterPythonImpl::Locker::~Locker() {
   if (m_teardown_session)
     DoTearDownSession();
   DoFreeLock();
 }
 
-ScriptInterpreterPythonImpl::ScriptInterpreterPythonImpl(
-    CommandInterpreter &interpreter)
-    : ScriptInterpreterPython(interpreter), m_saved_stdin(), m_saved_stdout(),
+ScriptInterpreterPythonImpl::ScriptInterpreterPythonImpl(Debugger &debugger)
+    : ScriptInterpreterPython(debugger), m_saved_stdin(), m_saved_stdout(),
       m_saved_stderr(), m_main_module(),
       m_session_dict(PyInitialValue::Invalid),
       m_sys_module_dict(PyInitialValue::Invalid), m_run_one_line_function(),
       m_run_one_line_str_global(),
-      m_dictionary_name(
-          interpreter.GetDebugger().GetInstanceName().AsCString()),
+      m_dictionary_name(m_debugger.GetInstanceName().AsCString()),
       m_terminal_state(), m_active_io_handler(eIOHandlerNone),
       m_session_is_active(false), m_pty_slave_is_open(false),
       m_valid_session(true), m_lock_count(0), m_command_thread_state(nullptr) {
   InitializePrivate();
 
   m_dictionary_name.append("_dict");
   StreamString run_string;
   run_string.Printf("%s = dict()", m_dictionary_name.c_str());
run_string.Printf("run_one_line (%s, 'import lldb.embedded_interpreter; from "
                     "lldb.embedded_interpreter import run_python_interpreter; "
                     "from lldb.embedded_interpreter import run_one_line')",
                     m_dictionary_name.c_str());
   PyRun_SimpleString(run_string.GetData());
   run_string.Clear();
 
   run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64
                     "; pydoc.pager = pydoc.plainpager')",
-                    m_dictionary_name.c_str(),
-                    interpreter.GetDebugger().GetID());
+                    m_dictionary_name.c_str(), m_debugger.GetID());
   PyRun_SimpleString(run_string.GetData());
 }
 
 ScriptInterpreterPythonImpl::~ScriptInterpreterPythonImpl() {
   // the session dictionary may hold objects with complex state which means
   // that they may need to be torn down with some level of smarts and that, in
   // turn, requires a valid thread state force Python to procure itself such a
   // thread state, nuke the session dictionary and then release it for others
if (output_sp && interactive) {
       output_sp->Flush();
     }
   }
 }
 
 void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
                                                          std::string &data) {
   io_handler.SetIsDone(true);
-  bool batch_mode = m_interpreter.GetBatchCommandMode();
+  bool batch_mode = m_debugger.GetCommandInterpreter().GetBatchCommandMode();
 
   switch (m_active_io_handler) {
   case eIOHandlerNone:
     break;
   case eIOHandlerBreakpoint: {
     std::vector<BreakpointOptions *> *bp_options_vec =
         (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
     for (auto bp_options : *bp_options_vec) {
if (GenerateWatchpointCommandCallbackData(data_up->user_source,
       }
     }
     m_active_io_handler = eIOHandlerNone;
   } break;
   }
 }
 
 lldb::ScriptInterpreterSP
-ScriptInterpreterPythonImpl::CreateInstance(CommandInterpreter &interpreter) {
-  return std::make_shared<ScriptInterpreterPythonImpl>(interpreter);
+ScriptInterpreterPythonImpl::CreateInstance(Debugger &debugger) {
+  return std::make_shared<ScriptInterpreterPythonImpl>(debugger);
 }
 
 void ScriptInterpreterPythonImpl::ResetOutputFileHandle(FILE *fh) {}
 
 void ScriptInterpreterPythonImpl::SaveTerminalState(int fd) {
   // Python mucks with the terminal state of STDIN. If we can possibly avoid
   // this by setting the file handles up correctly prior to entering the
   // interpreter we should. For now we save and restore the terminal state on
log->Printf(
         on_entry_flags);
 
   m_session_is_active = true;
 
   StreamString run_string;
 
   if (on_entry_flags & Locker::InitGlobals) {
     run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
-                      m_dictionary_name.c_str(),
-                      GetCommandInterpreter().GetDebugger().GetID());
+                      m_dictionary_name.c_str(), m_debugger.GetID());
     run_string.Printf(
         "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
-        GetCommandInterpreter().GetDebugger().GetID());
+        m_debugger.GetID());
     run_string.PutCString("; lldb.target = lldb.debugger.GetSelectedTarget()");
     run_string.PutCString("; lldb.process = lldb.target.GetProcess()");
     run_string.PutCString("; lldb.thread = lldb.process.GetSelectedThread ()");
     run_string.PutCString("; lldb.frame = lldb.thread.GetSelectedFrame ()");
     run_string.PutCString("')");
   } else {
     // If we aren't initing the globals, we should still always set the
     // debugger (since that is always unique.)
     run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
-                      m_dictionary_name.c_str(),
-                      GetCommandInterpreter().GetDebugger().GetID());
+                      m_dictionary_name.c_str(), m_debugger.GetID());
     run_string.Printf(
         "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
-        GetCommandInterpreter().GetDebugger().GetID());
+        m_debugger.GetID());
     run_string.PutCString("')");
   }
 
   PyRun_SimpleString(run_string.GetData());
   run_string.Clear();
 
   PythonDictionary &sys_module_dict = GetSysModuleDictionary();
   if (sys_module_dict.IsValid()) {
     File in_file(in, false);
     File out_file(out, false);
     File err_file(err, false);
 
     lldb::StreamFileSP in_sp;
     lldb::StreamFileSP out_sp;
     lldb::StreamFileSP err_sp;
     if (!in_file.IsValid() || !out_file.IsValid() || !err_file.IsValid())
-      m_interpreter.GetDebugger().AdoptTopIOHandlerFilesIfInvalid(in_sp, out_sp,
-                                                                  err_sp);
+      m_debugger.AdoptTopIOHandlerFilesIfInvalid(in_sp, out_sp, err_sp);
 
     if (on_entry_flags & Locker::NoSTDIN) {
       m_saved_stdin.Reset();
     } else {
       if (!SetStdHandle(in_file, "stdin", m_saved_stdin, "r")) {
         if (in_sp)
           SetStdHandle(in_sp->GetFile(), "stdin", m_saved_stdin, "r");
       }
bool ScriptInterpreterPythonImpl::ExecuteOneLine(
 
   if (!command.empty()) {
     // We want to call run_one_line, passing in the dictionary and the command
     // string.  We cannot do this through PyRun_SimpleString here because the
     // command string may contain escaped characters, and putting it inside
     // another string to pass to PyRun_SimpleString messes up the escaping.  So
     // we use the following more complicated method to pass the command string
     // directly down to Python.
-    Debugger &debugger = m_interpreter.GetDebugger();
+    Debugger &debugger = m_debugger;
 
     StreamFileSP input_file_sp;
     StreamFileSP output_file_sp;
     StreamFileSP error_file_sp;
     Communication output_comm(
         "lldb.ScriptInterpreterPythonImpl.ExecuteOneLine.comm");
     bool join_read_thread = false;
     if (options.GetEnableIO()) {
if (result)
     result->AppendError("empty command passed to python\n");
   return false;
 }
 
 void ScriptInterpreterPythonImpl::ExecuteInterpreterLoop() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
-  Debugger &debugger = GetCommandInterpreter().GetDebugger();
+  Debugger &debugger = m_debugger;
 
   // At the moment, the only time the debugger does not have an input file
   // handle is when this is called directly from Python, in which case it is
   // both dangerous and unnecessary (not to mention confusing) to try to embed
   // a running interpreter loop inside the already running Python interpreter
   // loop, so we won't do it.
 
   if (!debugger.GetInputFile()->GetFile().IsValid())
#endif
 
   return error;
 }
 
 void ScriptInterpreterPythonImpl::CollectDataForBreakpointCommandCallback(
     std::vector<BreakpointOptions *> &bp_options_vec,
     CommandReturnObject &result) {
   m_active_io_handler = eIOHandlerBreakpoint;
-  m_interpreter.GetPythonCommandsFromIOHandler("    ", *this, true,
-                                               &bp_options_vec);
+  m_debugger.GetCommandInterpreter().GetPythonCommandsFromIOHandler(
+      "    ", *this, true, &bp_options_vec);
 }
 
 void ScriptInterpreterPythonImpl::CollectDataForWatchpointCommandCallback(
     WatchpointOptions *wp_options, CommandReturnObject &result) {
   m_active_io_handler = eIOHandlerWatchpoint;
-  m_interpreter.GetPythonCommandsFromIOHandler("    ", *this, true, wp_options);
+  m_debugger.GetCommandInterpreter().GetPythonCommandsFromIOHandler(
+      "    ", *this, true, wp_options);
 }
 
 void ScriptInterpreterPythonImpl::SetBreakpointCommandCallbackFunction(
     BreakpointOptions *bp_options, const char *function_name) {
   // For now just cons up a oneliner that calls the provided function.
   std::string oneliner("return ");
   oneliner += function_name;
   oneliner += "(frame, bp_loc, internal_dict)";
-  m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback(
-      bp_options, oneliner.c_str());
+  m_debugger.GetCommandInterpreter()
+      .GetScriptInterpreter()
+      ->SetBreakpointCommandCallback(bp_options, oneliner.c_str());
 }
 
 Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
     BreakpointOptions *bp_options,
     std::unique_ptr<BreakpointOptions::CommandData> &cmd_data_up) {
   Status error;
   error = GenerateBreakpointCommandCallbackData(cmd_data_up->user_source,
                                                 cmd_data_up->script_source);
ret_val = LLDBSwigPythonCreateSyntheticProvider(
         class_name, python_interpreter->m_dictionary_name.c_str(), valobj);
   }
 
   return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::CreateScriptCommandObject(const char *class_name) {
-  DebuggerSP debugger_sp(
-      GetCommandInterpreter().GetDebugger().shared_from_this());
+  DebuggerSP debugger_sp(m_debugger.shared_from_this());
 
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!debugger_sp.get())
     return StructuredData::GenericSP();
 
   void *ret_val;

 bool ScriptInterpreterPythonImpl::LoadScriptingModule(
     const char *pathname, bool can_reload, bool init_session,
     lldb_private::Status &error, StructuredData::ObjectSP *module_sp) {
   if (!pathname || !pathname[0]) {
     error.SetErrorString("invalid pathname");
     return false;
   }
 
-  lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
+  lldb::DebuggerSP debugger_sp = m_debugger.shared_from_this();
 
   {
     FileSpec target_file(pathname);
     FileSystem::Instance().Resolve(target_file);
     std::string basename(target_file.GetFilename().GetCString());
 
     StreamString command_stream;
 
bool ScriptInterpreterPythonImpl::RunScriptBasedCommand(
     ScriptedCommandSynchronicity synchronicity,
     lldb_private::CommandReturnObject &cmd_retobj, Status &error,
     const lldb_private::ExecutionContext &exe_ctx) {
   if (!impl_function) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
-  lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
+  lldb::DebuggerSP debugger_sp = m_debugger.shared_from_this();
   lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
 
   if (!debugger_sp.get()) {
     error.SetErrorString("invalid Debugger pointer");
     return false;
   }
 
   bool ret_val = false;
bool ScriptInterpreterPythonImpl::RunScriptBasedCommand(
     ScriptedCommandSynchronicity synchronicity,
     lldb_private::CommandReturnObject &cmd_retobj, Status &error,
     const lldb_private::ExecutionContext &exe_ctx) {
   if (!impl_obj_sp || !impl_obj_sp->IsValid()) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
-  lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
+  lldb::DebuggerSP debugger_sp = m_debugger.shared_from_this();
   lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
 
   if (!debugger_sp.get()) {
     error.SetErrorString("invalid Debugger pointer");
     return false;
   }
 
   bool ret_val = false;

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h

 #include "llvm/ADT/StringRef.h"
 
 namespace lldb_private {
 class IOHandlerPythonInterpreter;
 class ScriptInterpreterPythonImpl : public ScriptInterpreterPython {
 public:
   friend class IOHandlerPythonInterpreter;
 
-  ScriptInterpreterPythonImpl(CommandInterpreter &interpreter);
+  ScriptInterpreterPythonImpl(Debugger &debugger);
 
   ~ScriptInterpreterPythonImpl() override;
 
   bool Interrupt() override;
 
   bool ExecuteOneLine(
       llvm::StringRef command, CommandReturnObject *result,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
public:
   }
 
   // IOHandlerDelegate
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override;
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override;
 
-  static lldb::ScriptInterpreterSP
-  CreateInstance(CommandInterpreter &interpreter);
+  static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   class Locker : public ScriptInterpreterLocker {
   public: