[ScriptInterpreter] Move ownership into debugger (NFC)

[JDevlieghere]

Summary

This is part two of the change started in r359330. This patch moves the ownership of the script interpreter from the command interpreter into the debugger. I would've preferred to remove the lazy initialization, however the fact that the scripting language is set after the debugger is created makes that tricky. So for now this does exactly the same thing as when it was under the command interpreter. The result is that this patch is fully NFC.

[jingham]

That looks nicer!

include/lldb/Core/Debugger.h

public:
 
   lldb::StreamSP GetAsyncErrorStream();
 
   CommandInterpreter &GetCommandInterpreter() {
     assert(m_command_interpreter_up.get());
     return *m_command_interpreter_up;
   }
 
+  ScriptInterpreter *GetScriptInterpreter(bool can_create = true);
+
   lldb::ListenerSP GetListener() { return m_listener_sp; }
 
   // This returns the Debugger's scratch source manager.  It won't be able to
   // look up files in debug information, but it can look up files by absolute
   // path and display them to you. To get the target's source manager, call
   // GetSourceManager on the target instead.
   SourceManager &GetSourceManager();
 
std::unique_ptr<SourceManager> m_source_manager_up; // This is a scratch
                                                       // targets.
   SourceManager::SourceFileCache m_source_file_cache; // All the source managers
                                                       // for targets created in
                                                       // this debugger used this
                                                       // shared
                                                       // source file cache.
   std::unique_ptr<CommandInterpreter> m_command_interpreter_up;
 
+  lldb::ScriptInterpreterSP m_script_interpreter_sp;
+  std::recursive_mutex m_script_interpreter_mutex;
+
   IOHandlerStack m_input_reader_stack;
   llvm::StringMap<std::weak_ptr<llvm::raw_ostream>> m_log_streams;
   std::shared_ptr<llvm::raw_ostream> m_log_callback_stream_sp;
   ConstString m_instance_name;
   static LoadPluginCallbackType g_load_plugin_callback;
   typedef std::vector<llvm::sys::DynamicLibrary> LoadedPluginsList;
   LoadedPluginsList m_loaded_plugins;
   HostThread m_event_handler_thread;

include/lldb/Interpreter/CommandInterpreter.h

public:
 
   void BuildAliasCommandArgs(CommandObject *alias_cmd_obj,
                              const char *alias_name, Args &cmd_args,
                              std::string &raw_input_string,
                              CommandReturnObject &result);
 
   int GetOptionArgumentPosition(const char *in_string);
 
-  ScriptInterpreter *GetScriptInterpreter(bool can_create = true);
-
-  void SetScriptInterpreter();
-
   void SkipLLDBInitFiles(bool skip_lldbinit_files) {
     m_skip_lldbinit_files = skip_lldbinit_files;
   }
 
   void SkipAppInitFiles(bool skip_app_init_files) {
     m_skip_app_init_files = m_skip_lldbinit_files;
   }
 
CommandObject::CommandMap m_command_dict; // Stores basic built-in commands
                                             // (they cannot be deleted, removed
                                             // or overwritten).
   CommandObject::CommandMap
       m_alias_dict; // Stores user aliases/abbreviations for commands
   CommandObject::CommandMap m_user_dict; // Stores user-defined commands
   CommandHistory m_command_history;
   std::string m_repeat_command; // Stores the command that will be executed for
                                 // an empty command string.
-  lldb::ScriptInterpreterSP m_script_interpreter_sp;
-  std::recursive_mutex m_script_interpreter_mutex;
   lldb::IOHandlerSP m_command_io_handler_sp;
   char m_comment_char;
   bool m_batch_command_mode;
   ChildrenTruncatedWarningStatus m_truncation_warning; // Whether we truncated
                                                        // children and whether
                                                        // the user has been told
   uint32_t m_command_source_depth;
   std::vector<uint32_t> m_command_source_flags;

include/lldb/Interpreter/CommandObject.h

public:
 
   static const char *
   GetArgumentTypeAsCString(const lldb::CommandArgumentType arg_type);
 
   static const char *
   GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type);
 
   CommandInterpreter &GetCommandInterpreter() { return m_interpreter; }
+  Debugger &GetDebugger();
 
   virtual llvm::StringRef GetHelp();
 
   virtual llvm::StringRef GetHelpLong();
 
   virtual llvm::StringRef GetSyntax();
 
   llvm::StringRef GetCommandName() const;

source/API/SBBreakpoint.cpp

void SBBreakpoint::SetScriptCallbackFunction(
   BreakpointSP bkpt_sp = GetSP();
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
     bkpt_sp->GetTarget()
         .GetDebugger()
-        .GetCommandInterpreter()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name);
   }
 }
 
 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 
   BreakpointSP bkpt_sp = GetSP();
 
   SBError sb_error;
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
     Status error =
         bkpt_sp->GetTarget()
             .GetDebugger()
-            .GetCommandInterpreter()
             .GetScriptInterpreter()
             ->SetBreakpointCommandCallback(bp_options, callback_body_text);
     sb_error.SetError(error);
   } else
     sb_error.SetErrorString("invalid breakpoint");
 
   return LLDB_RECORD_RESULT(sb_error);
 }

source/API/SBBreakpointLocation.cpp

void SBBreakpointLocation::SetScriptCallbackFunction(
 
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
     loc_sp->GetBreakpoint()
         .GetTarget()
         .GetDebugger()
-        .GetCommandInterpreter()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name);
   }
 }
 
 SBError
 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 
   BreakpointLocationSP loc_sp = GetSP();
 
   SBError sb_error;
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
     Status error =
         loc_sp->GetBreakpoint()
             .GetTarget()
             .GetDebugger()
-            .GetCommandInterpreter()
             .GetScriptInterpreter()
             ->SetBreakpointCommandCallback(bp_options, callback_body_text);
     sb_error.SetError(error);
   } else
     sb_error.SetErrorString("invalid breakpoint");
 
   return LLDB_RECORD_RESULT(sb_error);
 }

source/API/SBBreakpointName.cpp

if (!bp_name)
     return;
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   BreakpointOptions &bp_options = bp_name->GetOptions();
   m_impl_up->GetTarget()
       ->GetDebugger()
-      .GetCommandInterpreter()
       .GetScriptInterpreter()
       ->SetBreakpointCommandCallbackFunction(&bp_options,
                                              callback_function_name);
   UpdateName(*bp_name);
 }
 
 SBError
 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 
   SBError sb_error;
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return LLDB_RECORD_RESULT(sb_error);
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   BreakpointOptions &bp_options = bp_name->GetOptions();
   Status error =
       m_impl_up->GetTarget()
           ->GetDebugger()
-          .GetCommandInterpreter()
           .GetScriptInterpreter()
           ->SetBreakpointCommandCallback(&bp_options, callback_body_text);
   sb_error.SetError(error);
   if (!sb_error.Fail())
     UpdateName(*bp_name);
 
   return LLDB_RECORD_RESULT(sb_error);
 }

source/API/SBTypeCategory.cpp

if (summary.IsFunctionCode()) {
     StringList input;
     input.SplitIntoLines(script, strlen(script));
     uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
     bool need_set = true;
     for (uint32_t j = 0; j < num_debuggers; j++) {
       DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
       if (debugger_sp) {
         ScriptInterpreter *interpreter_ptr =
-            debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
+            debugger_sp->GetScriptInterpreter();
         if (interpreter_ptr) {
           std::string output;
           if (interpreter_ptr->GenerateTypeScriptFunction(input, output,
                                                           name_token) &&
               !output.empty()) {
             if (need_set) {
               need_set = false;
               summary.SetFunctionName(output.c_str());
if (synth.IsClassCode()) {
     StringList input;
     input.SplitIntoLines(script, strlen(script));
     uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
     bool need_set = true;
     for (uint32_t j = 0; j < num_debuggers; j++) {
       DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
       if (debugger_sp) {
         ScriptInterpreter *interpreter_ptr =
-            debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
+            debugger_sp->GetScriptInterpreter();
         if (interpreter_ptr) {
           std::string output;
           if (interpreter_ptr->GenerateTypeSynthClass(input, output,
                                                       name_token) &&
               !output.empty()) {
             if (need_set) {
               need_set = false;
               synth.SetClassName(output.c_str());

source/Breakpoint/BreakpointOptions.cpp

std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
 
   auto bp_options = llvm::make_unique<BreakpointOptions>(
       condition_ref.str().c_str(), enabled, 
       ignore_count, one_shot, auto_continue);
   if (cmd_data_up) {
     if (cmd_data_up->interpreter == eScriptLanguageNone)
       bp_options->SetCommandDataCallback(cmd_data_up);
     else {
-      ScriptInterpreter *interp =
-          target.GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+      ScriptInterpreter *interp = target.GetDebugger().GetScriptInterpreter();
       if (!interp) {
         error.SetErrorStringWithFormat(
             "Can't set script commands - no script interpreter");
         return nullptr;
       }
       if (interp->GetLanguage() != cmd_data_up->interpreter) {
         error.SetErrorStringWithFormat(
             "Current script language doesn't match breakpoint's language: %s",

source/Breakpoint/BreakpointResolverScripted.cpp

if (m_implementation_sp)
     return;
   
   if (m_class_name.empty())
     return;
   
   if (m_breakpoint) {
     TargetSP target_sp = m_breakpoint->GetTargetSP();
     ScriptInterpreter *script_interp = target_sp->GetDebugger()
-                                                .GetCommandInterpreter()
                                                 .GetScriptInterpreter();
     if (!script_interp)
       return;
     lldb::BreakpointSP bkpt_sp(m_breakpoint->shared_from_this());
     m_implementation_sp = script_interp->CreateScriptedBreakpointResolver(
         m_class_name.c_str(), m_args_ptr, bkpt_sp);
   }
 }
if (success) {
     // FIXME: The resolver needs a copy of the ARGS dict that it can own,
     // so I need to make a copy constructor for the Dictionary so I can pass
     // that to it here.  For now the args are empty.
     //StructuredData::Dictionary *dict_copy = new StructuredData::Dictionary(args_dict);
     
   }
   ScriptInterpreter *script_interp = bkpt->GetTarget()
                                          .GetDebugger()
-                                         .GetCommandInterpreter()
                                          .GetScriptInterpreter();
   return new BreakpointResolverScripted(bkpt, class_name, depth, args_data_impl,
                                       *script_interp);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverScripted::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());
 
   options_dict_sp->AddStringItem(GetKey(OptionNames::PythonClassName),
                                    m_class_name);
   return WrapOptionsDict(options_dict_sp);
 }
 
 ScriptInterpreter *BreakpointResolverScripted::GetScriptInterpreter() {
-    return m_breakpoint->GetTarget().GetDebugger().GetCommandInterpreter()
-        .GetScriptInterpreter();
+  return m_breakpoint->GetTarget().GetDebugger().GetScriptInterpreter();
 }
 
 Searcher::CallbackReturn
 BreakpointResolverScripted::SearchCallback(SearchFilter &filter,
                                           SymbolContext &context, Address *addr,
                                           bool containing) {
   assert(m_breakpoint != NULL);
   bool should_continue = true;

source/Commands/CommandObjectBreakpointCommand.cpp

if (result.Succeeded()) {
             m_bp_options_vec.push_back(bp_options);
         }
       }
 
       // If we are using script language, get the script interpreter in order
       // to set or collect command callback.  Otherwise, call the methods
       // associated with this object.
       if (m_options.m_use_script_language) {
-        ScriptInterpreter *script_interp = m_interpreter.GetScriptInterpreter();
+        ScriptInterpreter *script_interp = GetDebugger().GetScriptInterpreter();
         // Special handling for one-liner specified inline.
         if (m_options.m_use_one_liner) {
           script_interp->SetBreakpointCommandCallback(
               m_bp_options_vec, m_options.m_one_liner.c_str());
         } else if (!m_options.m_function_name.empty()) {
           script_interp->SetBreakpointCommandCallbackFunction(
               m_bp_options_vec, m_options.m_function_name.c_str());
         } else {

source/Commands/CommandObjectCommands.cpp

public:
   const std::string &GetFunctionName() { return m_function_name; }
 
   ScriptedCommandSynchronicity GetSynchronicity() { return m_synchro; }
 
   llvm::StringRef GetHelpLong() override {
     if (m_fetched_help_long)
       return CommandObjectRaw::GetHelpLong();
 
-    ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *scripter = GetDebugger().GetScriptInterpreter();
     if (!scripter)
       return CommandObjectRaw::GetHelpLong();
 
     std::string docstring;
     m_fetched_help_long =
         scripter->GetDocumentationForItem(m_function_name.c_str(), docstring);
     if (!docstring.empty())
       SetHelpLong(docstring);
     return CommandObjectRaw::GetHelpLong();
   }
 
 protected:
   bool DoExecute(llvm::StringRef raw_command_line,
                  CommandReturnObject &result) override {
-    ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *scripter = GetDebugger().GetScriptInterpreter();
 
     Status error;
 
     result.SetStatus(eReturnStatusInvalid);
 
     if (!scripter ||
         !scripter->RunScriptBasedCommand(m_function_name.c_str(),
                                          raw_command_line, m_synchro, result,
CommandObjectScriptingObject(CommandInterpreter &interpreter,
                                StructuredData::GenericSP cmd_obj_sp,
                                ScriptedCommandSynchronicity synch)
       : CommandObjectRaw(interpreter, name),
         m_cmd_obj_sp(cmd_obj_sp), m_synchro(synch), m_fetched_help_short(false),
         m_fetched_help_long(false) {
     StreamString stream;
     stream.Printf("For more information run 'help %s'", name.c_str());
     SetHelp(stream.GetString());
-    if (ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter())
+    if (ScriptInterpreter *scripter = GetDebugger().GetScriptInterpreter())
       GetFlags().Set(scripter->GetFlagsForCommandObject(cmd_obj_sp));
   }
 
   ~CommandObjectScriptingObject() override = default;
 
   bool IsRemovable() const override { return true; }
 
   StructuredData::GenericSP GetImplementingObject() { return m_cmd_obj_sp; }
 
   ScriptedCommandSynchronicity GetSynchronicity() { return m_synchro; }
 
   llvm::StringRef GetHelp() override {
     if (m_fetched_help_short)
       return CommandObjectRaw::GetHelp();
-    ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *scripter = GetDebugger().GetScriptInterpreter();
     if (!scripter)
       return CommandObjectRaw::GetHelp();
     std::string docstring;
     m_fetched_help_short =
         scripter->GetShortHelpForCommandObject(m_cmd_obj_sp, docstring);
     if (!docstring.empty())
       SetHelp(docstring);
 
     return CommandObjectRaw::GetHelp();
   }
 
   llvm::StringRef GetHelpLong() override {
     if (m_fetched_help_long)
       return CommandObjectRaw::GetHelpLong();
 
-    ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *scripter = GetDebugger().GetScriptInterpreter();
     if (!scripter)
       return CommandObjectRaw::GetHelpLong();
 
     std::string docstring;
     m_fetched_help_long =
         scripter->GetLongHelpForCommandObject(m_cmd_obj_sp, docstring);
     if (!docstring.empty())
       SetHelpLong(docstring);
     return CommandObjectRaw::GetHelpLong();
   }
 
 protected:
   bool DoExecute(llvm::StringRef raw_command_line,
                  CommandReturnObject &result) override {
-    ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *scripter = GetDebugger().GetScriptInterpreter();
 
     Status error;
 
     result.SetStatus(eReturnStatusInvalid);
 
     if (!scripter ||
         !scripter->RunScriptBasedCommand(m_cmd_obj_sp, raw_command_line,
                                          m_synchro, result, error, m_exe_ctx)) {
for (auto &entry : command.entries()) {
       // assumes that commands won't ever be recursively invoked, but it's
       // actually possible to craft a Python script that does other "command
       // script imports" in __lldb_init_module the real fix is to have
       // recursive commands possible with a CommandInvocation object separate
       // from the CommandObject itself, so that recursive command invocations
       // won't stomp on each other (wrt to execution contents, options, and
       // more)
       m_exe_ctx.Clear();
-      if (m_interpreter.GetScriptInterpreter()->LoadScriptingModule(
+      if (GetDebugger().GetScriptInterpreter()->LoadScriptingModule(
               entry.c_str(), m_options.m_allow_reload, init_session, error)) {
         result.SetStatus(eReturnStatusSuccessFinishNoResult);
       } else {
         result.AppendErrorWithFormat("module importing failed: %s",
                                      error.AsCString());
         result.SetStatus(eReturnStatusFailed);
       }
     }
if (output_sp && interactive) {
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
     StreamFileSP error_sp = io_handler.GetErrorStreamFile();
 
-    ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
 
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         std::string funct_name_str;
         if (interpreter->GenerateScriptAliasFunction(lines, funct_name_str)) {
           if (funct_name_str.empty()) {
if (m_options.m_class_name.empty()) {
         if (m_interpreter.AddUserCommand(m_cmd_name, new_cmd, true)) {
           result.SetStatus(eReturnStatusSuccessFinishNoResult);
         } else {
           result.AppendError("cannot add command");
           result.SetStatus(eReturnStatusFailed);
         }
       }
     } else {
-      ScriptInterpreter *interpreter =
-          GetCommandInterpreter().GetScriptInterpreter();
+      ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
       if (!interpreter) {
         result.AppendError("cannot find ScriptInterpreter");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       auto cmd_obj_sp = interpreter->CreateScriptCommandObject(
           m_options.m_class_name.c_str());

source/Commands/CommandObjectFrame.cpp

#ifndef LLDB_DISABLE_PYTHON
 
   if (m_options.m_function.empty()) {
     result.AppendErrorWithFormat("%s needs a function name (-n argument).\n",
                                  m_cmd_name.c_str());
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
-  ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+  ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
 
   if (interpreter &&
       !interpreter->CheckObjectExists(m_options.m_class_name.c_str())) {
     result.AppendWarning(
         "The provided class does not exist - please define it "
         "before attempting to use this frame recognizer");
   }
 

source/Commands/CommandObjectThread.cpp

if (command.GetArgumentCount() == 0) {
       }
     }
 
     if (m_step_type == eStepTypeScripted) {
       if (m_options.m_class_name.empty()) {
         result.AppendErrorWithFormat("empty class name for scripted step.");
         result.SetStatus(eReturnStatusFailed);
         return false;
-      } else if (!m_interpreter.GetScriptInterpreter()->CheckObjectExists(
+      } else if (!GetDebugger().GetScriptInterpreter()->CheckObjectExists(
                      m_options.m_class_name.c_str())) {
         result.AppendErrorWithFormat(
             "class for scripted step: \"%s\" does not exist.",
             m_options.m_class_name.c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }

source/Commands/CommandObjectType.cpp

void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
     StreamFileSP error_sp = io_handler.GetErrorStreamFile();
 
 #ifndef LLDB_DISABLE_PYTHON
-    ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         ScriptAddOptions *options_ptr =
             ((ScriptAddOptions *)io_handler.GetUserData());
         if (options_ptr) {
           ScriptAddOptions::SharedPointer options(
               options_ptr); // this will ensure that we get rid of the pointer
                             // when going out of scope
 
-          ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+          ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
           if (interpreter) {
             std::string funct_name_str;
             if (interpreter->GenerateTypeScriptFunction(lines,
                                                         funct_name_str)) {
               if (funct_name_str.empty()) {
                 error_sp->Printf("unable to obtain a valid function name from "
                                  "the script interpreter.\n");
                 error_sp->Flush();
void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
     StreamFileSP error_sp = io_handler.GetErrorStreamFile();
 
 #ifndef LLDB_DISABLE_PYTHON
-    ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         SynthAddOptions *options_ptr =
             ((SynthAddOptions *)io_handler.GetUserData());
         if (options_ptr) {
           SynthAddOptions::SharedPointer options(
               options_ptr); // this will ensure that we get rid of the pointer
                             // when going out of scope
 
-          ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+          ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
           if (interpreter) {
             std::string class_name_str;
             if (interpreter->GenerateTypeSynthClass(lines, class_name_str)) {
               if (class_name_str.empty()) {
                 error_sp->Printf(
                     "error: unable to obtain a proper name for the class.\n");
                 error_sp->Flush();
               } else {
if (!m_options.m_python_function
     }
 
     std::string code =
         ("    " + m_options.m_python_function + "(valobj,internal_dict)");
 
     script_format = std::make_shared<ScriptSummaryFormat>(
         m_options.m_flags, funct_name, code.c_str());
 
-    ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
 
     if (interpreter && !interpreter->CheckObjectExists(funct_name))
       result.AppendWarningWithFormat(
           "The provided function \"%s\" does not exist - "
           "please define it before attempting to use this summary.\n",
           funct_name);
   } else if (!m_options.m_python_script
                   .empty()) // we have a quick 1-line script, just use it
   {
-    ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+    ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (!interpreter) {
       result.AppendError("script interpreter missing - unable to generate "
                          "function wrapper.\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
     StringList funct_sl;
     funct_sl << m_options.m_python_script.c_str();
ScriptedSyntheticChildren *impl = new ScriptedSyntheticChildren(
       SyntheticChildren::Flags()
           .SetCascades(m_options.m_cascade)
           .SetSkipPointers(m_options.m_skip_pointers)
           .SetSkipReferences(m_options.m_skip_references),
       m_options.m_class_name.c_str());
 
   entry.reset(impl);
 
-  ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
+  ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
 
   if (interpreter &&
       !interpreter->CheckObjectExists(impl->GetPythonClassName()))
     result.AppendWarning("The provided class does not exist - please define it "
                          "before attempting to use this synthetic provider");
 
   // now I have a valid provider, let's add it to every type
 

source/Commands/CommandObjectWatchpointCommand.cpp

for (size_t i = 0; i < count; ++i) {
           continue;
 
         // If we are using script language, get the script interpreter in order
         // to set or collect command callback.  Otherwise, call the methods
         // associated with this object.
         if (m_options.m_use_script_language) {
           // Special handling for one-liner specified inline.
           if (m_options.m_use_one_liner) {
-            m_interpreter.GetScriptInterpreter()->SetWatchpointCommandCallback(
+            GetDebugger().GetScriptInterpreter()->SetWatchpointCommandCallback(
                 wp_options, m_options.m_one_liner.c_str());
           }
           // Special handling for using a Python function by name instead of
           // extending the watchpoint callback data structures, we just
           // automatize what the user would do manually: make their watchpoint
           // command be a function call
           else if (!m_options.m_function_name.empty()) {
             std::string oneliner(m_options.m_function_name);
             oneliner += "(frame, wp, internal_dict)";
-            m_interpreter.GetScriptInterpreter()->SetWatchpointCommandCallback(
+            GetDebugger().GetScriptInterpreter()->SetWatchpointCommandCallback(
                 wp_options, oneliner.c_str());
           } else {
-            m_interpreter.GetScriptInterpreter()
+            GetDebugger()
+                .GetScriptInterpreter()
                 ->CollectDataForWatchpointCommandCallback(wp_options, result);
           }
         } else {
           // Special handling for one-liner specified inline.
           if (m_options.m_use_one_liner)
             SetWatchpointCommandCallback(wp_options,
                                          m_options.m_one_liner.c_str());
           else

source/Core/Debugger.cpp

: UserID(g_unique_id++),
       m_error_file_sp(std::make_shared<StreamFile>(stderr, false)),
       m_input_recorder(nullptr),
       m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
       m_terminal_state(), m_target_list(*this), m_platform_list(),
       m_listener_sp(Listener::MakeListener("lldb.Debugger")),
       m_source_manager_up(), m_source_file_cache(),
       m_command_interpreter_up(
           llvm::make_unique<CommandInterpreter>(*this, false)),
-      m_input_reader_stack(), m_instance_name(), m_loaded_plugins(),
-      m_event_handler_thread(), m_io_handler_thread(),
+      m_script_interpreter_sp(), m_input_reader_stack(), m_instance_name(),
+      m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(),
       m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
       m_forward_listener_sp(), m_clear_once() {
   char instance_cstr[256];
   snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
   m_instance_name.SetCString(instance_cstr);
   if (log_callback)
     m_log_callback_stream_sp =
         std::make_shared<StreamCallback>(log_callback, baton);
if (m_output_file_sp)
     m_output_file_sp->GetFile().SetStream(fh, tranfer_ownership);
   else
     m_output_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
 
   File &out_file = m_output_file_sp->GetFile();
   if (!out_file.IsValid())
     out_file.SetStream(stdout, false);
 
-  // do not create the ScriptInterpreter just for setting the output file
-  // handle as the constructor will know how to do the right thing on its own
-  const bool can_create = false;
-  ScriptInterpreter *script_interpreter =
-      GetCommandInterpreter().GetScriptInterpreter(can_create);
-  if (script_interpreter)
+  // Do not create the ScriptInterpreter just for setting the output file
+  // handle as the constructor will know how to do the right thing on its own.
+  if (ScriptInterpreter *script_interpreter =
+          GetScriptInterpreter(/*can_create=*/false))
     script_interpreter->ResetOutputFileHandle(fh);
 }
 
 void Debugger::SetErrorFileHandle(FILE *fh, bool tranfer_ownership) {
   if (m_error_file_sp)
     m_error_file_sp->GetFile().SetStream(fh, tranfer_ownership);
   else
     m_error_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
bool Debugger::EnableLog(llvm::StringRef channel,
   if (log_options == 0)
     log_options =
         LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
 
   return Log::EnableLogChannel(log_stream_sp, log_options, channel, categories,
                                error_stream);
 }
 
+ScriptInterpreter *Debugger::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;
+    m_script_interpreter_sp = PluginManager::GetScriptInterpreterForLanguage(
+        GetScriptLanguage(), *this);
+  }
+
+  return m_script_interpreter_sp.get();
+}
+
 SourceManager &Debugger::GetSourceManager() {
   if (!m_source_manager_up)
     m_source_manager_up = llvm::make_unique<SourceManager>(shared_from_this());
   return *m_source_manager_up;
 }
 
 // This function handles events that were broadcast by the process.
 void Debugger::HandleBreakpointEvent(const EventSP &event_sp) {

source/Core/FormatEntity.cpp

 template <typename T>
 static bool RunScriptFormatKeyword(Stream &s, const SymbolContext *sc,
                                    const ExecutionContext *exe_ctx, T t,
                                    const char *script_function_name) {
   Target *target = Target::GetTargetFromContexts(exe_ctx, sc);
 
   if (target) {
     ScriptInterpreter *script_interpreter =
-        target->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+        target->GetDebugger().GetScriptInterpreter();
     if (script_interpreter) {
       Status error;
       std::string script_output;
 
       if (script_interpreter->RunScriptFormatKeyword(script_function_name, t,
                                                      script_output, error) &&
           error.Success()) {
         s.Printf("%s", script_output.c_str());

source/Core/Module.cpp

if (!platform_sp) {
       return false;
     }
 
     FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources(
         target, *this, feedback_stream);
 
     const uint32_t num_specs = file_specs.GetSize();
     if (num_specs) {
-      ScriptInterpreter *script_interpreter =
-          debugger.GetCommandInterpreter().GetScriptInterpreter();
+      ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
       if (script_interpreter) {
         for (uint32_t i = 0; i < num_specs; ++i) {
           FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i));
           if (scripting_fspec &&
               FileSystem::Instance().Exists(scripting_fspec)) {
             if (should_load == eLoadScriptFromSymFileWarn) {
               if (feedback_stream)
                 feedback_stream->Printf(

source/DataFormatters/TypeSummary.cpp

bool ScriptSummaryFormat::FormatObject(ValueObject *valobj, std::string &retval,
   TargetSP target_sp(valobj->GetTargetSP());
 
   if (!target_sp) {
     retval.assign("error: no target");
     return false;
   }
 
   ScriptInterpreter *script_interpreter =
-      target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+      target_sp->GetDebugger().GetScriptInterpreter();
 
   if (!script_interpreter) {
     retval.assign("error: no ScriptInterpreter");
     return false;
   }
 
   return script_interpreter->GetScriptedSummary(
       m_function_name.c_str(), valobj->GetSP(), m_script_function_sp, options,

source/DataFormatters/TypeSynthetic.cpp

ScriptedSyntheticChildren::FrontEnd::FrontEnd(std::string pclass,
   if (backend == LLDB_INVALID_UID)
     return;
 
   TargetSP target_sp = backend.GetTargetSP();
 
   if (!target_sp)
     return;
 
-  m_interpreter =
-      target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+  m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
 
   if (m_interpreter != NULL)
     m_wrapper_sp = m_interpreter->CreateSyntheticScriptedProvider(
         m_python_class.c_str(), backend.GetSP());
 }
 
 ScriptedSyntheticChildren::FrontEnd::~FrontEnd() {}
 

source/Interpreter/CommandInterpreter.cpp

CommandInterpreter::CommandInterpreter(Debugger &debugger,
                                        bool synchronous_execution)
     : Broadcaster(debugger.GetBroadcasterManager(),
                   CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
       Properties(OptionValuePropertiesSP(
           new OptionValueProperties(ConstString("interpreter")))),
       IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
       m_debugger(debugger), m_synchronous_execution(synchronous_execution),
       m_skip_lldbinit_files(false), m_skip_app_init_files(false),
-      m_script_interpreter_sp(), m_command_io_handler_sp(), m_comment_char('#'),
+      m_command_io_handler_sp(), m_comment_char('#'),
       m_batch_command_mode(false), m_truncation_warning(eNoTruncation),
       m_command_source_depth(0), m_num_errors(0), m_quit_requested(false),
       m_stopped_for_crash(false) {
   SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
   SetEventName(eBroadcastBitResetPrompt, "reset-prompt");
   SetEventName(eBroadcastBitQuitCommandReceived, "quit");
   CheckInWithManager();
   m_collection_sp->Initialize(g_properties);
if (cmd_obj_sp) {
     AddAlias("v", cmd_obj_sp);
     AddAlias("var", cmd_obj_sp);
     AddAlias("vo", cmd_obj_sp, "--object-description");
   }
 }
 
 void CommandInterpreter::Clear() {
   m_command_io_handler_sp.reset();
-
-  if (m_script_interpreter_sp)
-    m_script_interpreter_sp->Clear();
 }
 
 const char *CommandInterpreter::ProcessEmbeddedScriptCommands(const char *arg) {
   // This function has not yet been implemented.
 
   // Look for any embedded script command
   // If found,
   //    get interpreter object from the command dictionary,
void CommandInterpreter::HandleCommandsFromFile(
   debugger.RunIOHandler(io_handler_sp);
   if (!m_command_source_flags.empty())
     m_command_source_flags.pop_back();
   m_command_source_depth--;
   result.SetStatus(eReturnStatusSuccessFinishNoResult);
   debugger.SetAsyncExecution(old_async_execution);
 }
 
-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, m_debugger);
-  }
-  return m_script_interpreter_sp.get();
-}
-
 bool CommandInterpreter::GetSynchronous() { return m_synchronous_execution; }
 
 void CommandInterpreter::SetSynchronous(bool value) {
   m_synchronous_execution = value;
 }
 
 void CommandInterpreter::OutputFormattedHelpText(Stream &strm,
                                                  llvm::StringRef prefix,
bool CommandInterpreter::IOHandlerInterrupt(IOHandler &io_handler) {
   if (process) {
     StateType state = process->GetState();
     if (StateIsRunningState(state)) {
       process->Halt();
       return true; // Don't do any updating when we are running
     }
   }
 
-  ScriptInterpreter *script_interpreter = GetScriptInterpreter(false);
+  ScriptInterpreter *script_interpreter =
+      m_debugger.GetScriptInterpreter(false);
   if (script_interpreter) {
     if (script_interpreter->Interrupt())
       return true;
   }
   return false;
 }
 
 void CommandInterpreter::GetLLDBCommandsFromIOHandler(

source/Interpreter/CommandObject.cpp

: m_interpreter(interpreter), m_cmd_name(name),
       m_arguments(), m_deprecated_command_override_callback(nullptr),
       m_command_override_callback(nullptr), m_command_override_baton(nullptr) {
   m_cmd_help_short = help;
   m_cmd_syntax = syntax;
 }
 
 CommandObject::~CommandObject() {}
 
+Debugger &CommandObject::GetDebugger() { return m_interpreter.GetDebugger(); }
+
 llvm::StringRef CommandObject::GetHelp() { return m_cmd_help_short; }
 
 llvm::StringRef CommandObject::GetHelpLong() { return m_cmd_help_long; }
 
 llvm::StringRef CommandObject::GetSyntax() {
   if (!m_cmd_syntax.empty())
     return m_cmd_syntax;
 

source/Interpreter/CommandObjectScript.cpp

#else
   if (m_interpreter.GetDebugger().GetScriptLanguage() ==
       lldb::eScriptLanguageNone) {
     result.AppendError(
         "the script-lang setting is set to none - scripting not available");
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
-  ScriptInterpreter *script_interpreter = m_interpreter.GetScriptInterpreter();
+  ScriptInterpreter *script_interpreter = GetDebugger().GetScriptInterpreter();
 
   if (script_interpreter == nullptr) {
     result.AppendError("no script interpreter");
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
   DataVisualization::ForceUpdate(); // script might change Python code we use

source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

OperatingSystemPython::OperatingSystemPython(lldb_private::Process *process,
                                              const FileSpec &python_module_path)
     : OperatingSystem(process), m_thread_list_valobj_sp(), m_register_info_up(),
       m_interpreter(NULL), m_python_object_sp() {
   if (!process)
     return;
   TargetSP target_sp = process->CalculateTarget();
   if (!target_sp)
     return;
-  m_interpreter =
-      target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+  m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
   if (m_interpreter) {
 
     std::string os_plugin_class_name(
         python_module_path.GetFilename().AsCString(""));
     if (!os_plugin_class_name.empty()) {
       const bool init_session = false;
       const bool allow_reload = true;
       char python_module_path_cstr[PATH_MAX];

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (module_spec) {
                 // Python we will need to rework this
                 std::replace(module_basename.begin(), module_basename.end(),
                              '.', '_');
                 std::replace(module_basename.begin(), module_basename.end(),
                              ' ', '_');
                 std::replace(module_basename.begin(), module_basename.end(),
                              '-', '_');
                 ScriptInterpreter *script_interpreter =
-                  target->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+                    target->GetDebugger().GetScriptInterpreter();
                 if (script_interpreter &&
                     script_interpreter->IsReservedWord(
                         module_basename.c_str())) {
                   module_basename.insert(module_basename.begin(), '_');
                   was_keyword = true;
                 }
 
                 StreamString path_string;

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

 // PluginInterface
 ConstString ProcessGDBRemote::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t ProcessGDBRemote::GetPluginVersion() { return 1; }
 
 bool ProcessGDBRemote::ParsePythonTargetDefinition(
     const FileSpec &target_definition_fspec) {
   ScriptInterpreter *interpreter =
-      GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+      GetTarget().GetDebugger().GetScriptInterpreter();
   Status error;
   StructuredData::ObjectSP module_object_sp(
       interpreter->LoadPluginModule(target_definition_fspec, error));
   if (module_object_sp) {
     StructuredData::DictionarySP target_definition_sp(
         interpreter->GetDynamicSettings(module_object_sp, &GetTarget(),
                                         "gdb-server-target-definition", error));
 

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 }
 
 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_debugger.GetCommandInterpreter()
-      .GetScriptInterpreter()
-      ->SetBreakpointCommandCallback(bp_options, oneliner.c_str());
+  m_debugger.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);
StructuredData::ObjectSP ScriptInterpreterPythonImpl::CreateScriptedThreadPlan(
     const char *class_name, lldb::ThreadPlanSP thread_plan_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::ObjectSP();
 
   if (!thread_plan_sp.get())
     return StructuredData::ObjectSP();
 
   Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
-  ScriptInterpreter *script_interpreter =
-      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
       static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
 
   if (!script_interpreter)
     return StructuredData::ObjectSP();
 
   void *ret_val;
 
ScriptInterpreterPythonImpl::CreateScriptedBreakpointResolver(
 
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!bkpt_sp.get())
     return StructuredData::GenericSP();
 
   Debugger &debugger = bkpt_sp->GetTarget().GetDebugger();
-  ScriptInterpreter *script_interpreter =
-      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
       static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
 
   if (!script_interpreter)
     return StructuredData::GenericSP();
 
   void *ret_val;
 
ScriptInterpreterPythonImpl::CreateSyntheticScriptedProvider(
 
   ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return StructuredData::ObjectSP();
 
   Debugger &debugger = target->GetDebugger();
-  ScriptInterpreter *script_interpreter =
-      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
       (ScriptInterpreterPythonImpl *)script_interpreter;
 
   if (!script_interpreter)
     return StructuredData::ObjectSP();
 
   void *ret_val = nullptr;
 
bool ScriptInterpreterPythonImpl::BreakpointCallbackFunction(
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return true;
 
   Debugger &debugger = target->GetDebugger();
-  ScriptInterpreter *script_interpreter =
-      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
       (ScriptInterpreterPythonImpl *)script_interpreter;
 
   if (!script_interpreter)
     return true;
 
   if (python_function_name && python_function_name[0]) {
     const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
bool ScriptInterpreterPythonImpl::WatchpointCallbackFunction(
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return true;
 
   Debugger &debugger = target->GetDebugger();
-  ScriptInterpreter *script_interpreter =
-      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
       (ScriptInterpreterPythonImpl *)script_interpreter;
 
   if (!script_interpreter)
     return true;
 
   if (python_function_name && python_function_name[0]) {
     const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());

source/Target/Target.cpp

Target::CreateScriptedBreakpoint(const llvm::StringRef class_name,
   } else {
     filter_sp = std::make_shared<SearchFilterForUnconstrainedSearches>(
         shared_from_this());
   }
   
   StructuredDataImpl *extra_args_impl = new StructuredDataImpl();
   if (extra_args_sp)
     extra_args_impl->SetObjectSP(extra_args_sp);
-  
-  BreakpointResolverSP resolver_sp(new 
-                                   BreakpointResolverScripted(nullptr, class_name,
-                                   depth,
-                                   extra_args_impl,
-                                   *GetDebugger().GetCommandInterpreter()
-                                       .GetScriptInterpreter()));
+  BreakpointResolverSP resolver_sp(new BreakpointResolverScripted(
+      nullptr, class_name, depth, extra_args_impl,
+      *GetDebugger().GetScriptInterpreter()));
   return CreateBreakpoint(filter_sp, resolver_sp, internal, false, true);
 
 }
 
 
 BreakpointSP Target::CreateBreakpoint(SearchFilterSP &filter_sp,
                                       BreakpointResolverSP &resolver_sp,
                                       bool internal, bool request_hardware,

source/Target/ThreadPlanPython.cpp

 void ThreadPlanPython::DidPush() {
   // We set up the script side in DidPush, so that it can push other plans in
   // the constructor, and doesn't have to care about the details of DidPush.
   m_did_push = true;
   if (!m_class_name.empty()) {
     ScriptInterpreter *script_interp = m_thread.GetProcess()
                                            ->GetTarget()
                                            .GetDebugger()
-                                           .GetCommandInterpreter()
                                            .GetScriptInterpreter();
     if (script_interp) {
       m_implementation_sp = script_interp->CreateScriptedThreadPlan(
           m_class_name.c_str(), this->shared_from_this());
     }
   }
 }
 
 bool ThreadPlanPython::ShouldStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
                 m_class_name.c_str());
 
   bool should_stop = true;
   if (m_implementation_sp) {
     ScriptInterpreter *script_interp = m_thread.GetProcess()
                                            ->GetTarget()
                                            .GetDebugger()
-                                           .GetCommandInterpreter()
                                            .GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       should_stop = script_interp->ScriptedThreadPlanShouldStop(
           m_implementation_sp, event_ptr, script_error);
       if (script_error)
         SetPlanComplete(false);
     }
   }
   return should_stop;
 }
 
 bool ThreadPlanPython::IsPlanStale() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
                 m_class_name.c_str());
 
   bool is_stale = true;
   if (m_implementation_sp) {
     ScriptInterpreter *script_interp = m_thread.GetProcess()
                                            ->GetTarget()
                                            .GetDebugger()
-                                           .GetCommandInterpreter()
                                            .GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       is_stale = script_interp->ScriptedThreadPlanIsStale(m_implementation_sp,
                                                           script_error);
       if (script_error)
         SetPlanComplete(false);
     }
   }
   return is_stale;
 }
 
 bool ThreadPlanPython::DoPlanExplainsStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
                 m_class_name.c_str());
 
   bool explains_stop = true;
   if (m_implementation_sp) {
     ScriptInterpreter *script_interp = m_thread.GetProcess()
                                            ->GetTarget()
                                            .GetDebugger()
-                                           .GetCommandInterpreter()
                                            .GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       explains_stop = script_interp->ScriptedThreadPlanExplainsStop(
           m_implementation_sp, event_ptr, script_error);
       if (script_error)
         SetPlanComplete(false);
     }
lldb::StateType ThreadPlanPython::GetPlanRunState() {
   if (log)
     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
                 m_class_name.c_str());
   lldb::StateType run_state = eStateRunning;
   if (m_implementation_sp) {
     ScriptInterpreter *script_interp = m_thread.GetProcess()
                                            ->GetTarget()
                                            .GetDebugger()
-                                           .GetCommandInterpreter()
                                            .GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       run_state = script_interp->ScriptedThreadPlanGetRunState(
           m_implementation_sp, script_error);
     }
   }
   return run_state;