[lldb] Mark most SBAPI methods involving private types as protected or private

[bulbazord]

Summary

Many SB classes have public constructors or methods involving types that
are private. Some are more obvious (e.g. containing lldb_private in the
name) than others (lldb::FooSP is usually std::shared_pointer<lldb_private::Foo>).

This commit explicitly does not address FileSP, so I'm leaving that one
alone for now.

Some of these were for other SB classes to use and should have been made
protected/private with a friend class entry added. Some of these were
public for some of the swig python helpers to use. I put all of those
functions into a class and made them static methods. The relevant SB
classes mark that class as a friend so they can access those
private/protected members.

I've also removed an outdated SBStructuredData test (can you guess which
constructor it was using?) and updated the other relevant tests.

[mib]

LGTM with some comments.

lldb/include/lldb/API/SBBreakpoint.h

18–19

We've talked about this offline, but I think we should stay language agnostic in the SBAPI, so exposing a python namespace here is bothering me a little bit.

lldb/source/API/SBCommandInterpreter.cpp

37

I find it a bit odd to have this here ... May be we should move this class out the the API directory ?

lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h

64–90

Although this is nested in the python namespace, I think SWIGBridge should be a templated class defined in the ScriptedInterpreter header and this class should be instead renamed as SWIGPythonBridge and be a specialization of the SWIGBridge class. We can do that as a follow-up but a TODO comment would be nice.

248–254

Can we move these in the python namespace as well ?

[bulbazord]

lldb/include/lldb/API/SBBreakpoint.h

18–19

I agree, but we can refactor this later. Removing and/or changing forward declarations doesn't break ABI.

lldb/source/API/SBCommandInterpreter.cpp

37

It's a little odd for sure, but it is an implementation detail so having it in the cpp file seems alright. Where would you put it?

lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h

64–90

Sure, I can add the TODO. I'd rather not add the templates or subclass in this patch as it is complicated enough already.

248–254

Sure

[bulbazord]

Address feedback and add TODOs for follow-up

[jingham]

This seems like a pretty non-intrusive way of protecting the lldb_private side of the SB API construction.

Looking at the patch makes it seem like we've been semi-randomly assorting members of the SB classes to "protected" and "private". We have NO intentions of ever subclassing these classes, so protected vrs. private is a meaningless distinction (thus the seeming randomness of the assignment, maybe?) It would be cleaner to go make them all private, since we don't intend to offer these for subclassing... But this patch is getting big already, probably don't want to fold that into this one.

lldb/unittests/API/SBCommandInterpreterTest.cpp

24–25

It isn't clear to me how the changes in this file fit in with your overall goal?

[bulbazord]

lldb/unittests/API/SBCommandInterpreterTest.cpp

24–25

I'm removing the SBCommandInterpreter member of this class because in order to construct an object of this class, SBCommandInterpreter would need to have an empty default constructor (which we do not have currently). I didn't want to add a constructor for SBCommandInterpreter just to avoid changing the test.

[jingham]

lldb/unittests/API/SBCommandInterpreterTest.cpp

24–25

Sounds reasonable.

[bulbazord]

This broke Lua support, so I am fixing it in D150624.

lldb/bindings/python/python-swigsafecast.swig

 namespace lldb_private {
 namespace python {
 
 PythonObject ToSWIGHelper(void *obj, swig_type_info *info) {
   return {PyRefType::Owned, SWIG_NewPointerObj(obj, info, SWIG_POINTER_OWN)};
 }
 
-PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBValue> value_sb) {
+PythonObject SWIGBridge::ToSWIGWrapper(std::unique_ptr<lldb::SBValue> value_sb) {
   return ToSWIGHelper(value_sb.release(), SWIGTYPE_p_lldb__SBValue);
 }
 
-PythonObject ToSWIGWrapper(lldb::ValueObjectSP value_sp) {
-  return ToSWIGWrapper(std::make_unique<lldb::SBValue>(std::move(value_sp)));
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::ValueObjectSP value_sp) {
+  return ToSWIGWrapper(std::unique_ptr<lldb::SBValue>(new lldb::SBValue(value_sp)));
 }
 
-PythonObject ToSWIGWrapper(lldb::TargetSP target_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::TargetSP target_sp) {
   return ToSWIGHelper(new lldb::SBTarget(std::move(target_sp)),
                       SWIGTYPE_p_lldb__SBTarget);
 }
 
-PythonObject ToSWIGWrapper(lldb::ProcessSP process_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::ProcessSP process_sp) {
   return ToSWIGHelper(new lldb::SBProcess(std::move(process_sp)),
                       SWIGTYPE_p_lldb__SBProcess);
 }
 
-PythonObject ToSWIGWrapper(lldb::ThreadPlanSP thread_plan_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::ThreadPlanSP thread_plan_sp) {
   return ToSWIGHelper(new lldb::SBThreadPlan(std::move(thread_plan_sp)),
                       SWIGTYPE_p_lldb__SBThreadPlan);
 }
 
-PythonObject ToSWIGWrapper(lldb::BreakpointSP breakpoint_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::BreakpointSP breakpoint_sp) {
   return ToSWIGHelper(new lldb::SBBreakpoint(std::move(breakpoint_sp)),
                       SWIGTYPE_p_lldb__SBBreakpoint);
 }
 
-PythonObject ToSWIGWrapper(const Status& status) {
+PythonObject SWIGBridge::ToSWIGWrapper(const Status& status) {
   return ToSWIGHelper(new lldb::SBError(status), SWIGTYPE_p_lldb__SBError);
 }
 
-PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStream> stream_sb) {
+PythonObject SWIGBridge::ToSWIGWrapper(std::unique_ptr<lldb::SBStream> stream_sb) {
   return ToSWIGHelper(stream_sb.release(), SWIGTYPE_p_lldb__SBStream);
 }
 
-PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb) {
+PythonObject SWIGBridge::ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb) {
   return ToSWIGHelper(data_sb.release(), SWIGTYPE_p_lldb__SBStructuredData);
 }
 
-PythonObject ToSWIGWrapper(const StructuredDataImpl &data_impl) {
-  return ToSWIGWrapper(std::make_unique<lldb::SBStructuredData>(data_impl));
+PythonObject SWIGBridge::ToSWIGWrapper(const StructuredDataImpl &data_impl) {
+  return ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData>(new lldb::SBStructuredData(data_impl)));
 }
 
-PythonObject ToSWIGWrapper(lldb::ThreadSP thread_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::ThreadSP thread_sp) {
   return ToSWIGHelper(new lldb::SBThread(std::move(thread_sp)),
                       SWIGTYPE_p_lldb__SBThread);
 }
 
-PythonObject ToSWIGWrapper(lldb::StackFrameSP frame_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::StackFrameSP frame_sp) {
   return ToSWIGHelper(new lldb::SBFrame(std::move(frame_sp)),
                       SWIGTYPE_p_lldb__SBFrame);
 }
 
-PythonObject ToSWIGWrapper(lldb::DebuggerSP debugger_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::DebuggerSP debugger_sp) {
   return ToSWIGHelper(new lldb::SBDebugger(std::move(debugger_sp)),
                       SWIGTYPE_p_lldb__SBDebugger);
 }
 
-PythonObject ToSWIGWrapper(lldb::WatchpointSP watchpoint_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::WatchpointSP watchpoint_sp) {
   return ToSWIGHelper(new lldb::SBWatchpoint(std::move(watchpoint_sp)),
                       SWIGTYPE_p_lldb__SBWatchpoint);
 }
 
-PythonObject ToSWIGWrapper(lldb::BreakpointLocationSP bp_loc_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::BreakpointLocationSP bp_loc_sp) {
   return ToSWIGHelper(new lldb::SBBreakpointLocation(std::move(bp_loc_sp)),
                       SWIGTYPE_p_lldb__SBBreakpointLocation);
 }
 
-PythonObject ToSWIGWrapper(lldb::ExecutionContextRefSP ctx_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::ExecutionContextRefSP ctx_sp) {
   return ToSWIGHelper(new lldb::SBExecutionContext(std::move(ctx_sp)),
                       SWIGTYPE_p_lldb__SBExecutionContext);
 }
 
-PythonObject ToSWIGWrapper(lldb::TypeImplSP type_impl_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::TypeImplSP type_impl_sp) {
   return ToSWIGHelper(new lldb::SBType(type_impl_sp), SWIGTYPE_p_lldb__SBType);
 }
 
-PythonObject ToSWIGWrapper(const TypeSummaryOptions &summary_options) {
+PythonObject SWIGBridge::ToSWIGWrapper(const TypeSummaryOptions &summary_options) {
   return ToSWIGHelper(new lldb::SBTypeSummaryOptions(summary_options),
                       SWIGTYPE_p_lldb__SBTypeSummaryOptions);
 }
 
-PythonObject ToSWIGWrapper(const SymbolContext &sym_ctx) {
+PythonObject SWIGBridge::ToSWIGWrapper(const SymbolContext &sym_ctx) {
   return ToSWIGHelper(new lldb::SBSymbolContext(sym_ctx),
                       SWIGTYPE_p_lldb__SBSymbolContext);
 }
 
-PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp) {
    return ToSWIGHelper(new lldb::ProcessLaunchInfoSP(std::move(launch_info_sp)),
                        SWIGTYPE_p_lldb__SBLaunchInfo);
  }
 
- PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp) {
+ PythonObject SWIGBridge::ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp) {
    return ToSWIGHelper(new lldb::ProcessAttachInfoSP(std::move(attach_info_sp)),
                        SWIGTYPE_p_lldb__SBAttachInfo);
  }
 
-PythonObject ToSWIGWrapper(lldb::DataExtractorSP data_sp) {
+PythonObject SWIGBridge::ToSWIGWrapper(lldb::DataExtractorSP data_sp) {
   return ToSWIGHelper(new lldb::DataExtractorSP(std::move(data_sp)),
                       SWIGTYPE_p_lldb__SBData);
 }
 
 ScopedPythonObject<lldb::SBCommandReturnObject>
-ToSWIGWrapper(CommandReturnObject &cmd_retobj) {
+SWIGBridge::ToSWIGWrapper(CommandReturnObject &cmd_retobj) {
   return ScopedPythonObject<lldb::SBCommandReturnObject>(
       new lldb::SBCommandReturnObject(cmd_retobj),
       SWIGTYPE_p_lldb__SBCommandReturnObject);
 }
 
-ScopedPythonObject<lldb::SBEvent> ToSWIGWrapper(Event *event) {
+ScopedPythonObject<lldb::SBEvent> SWIGBridge::ToSWIGWrapper(Event *event) {
   return ScopedPythonObject<lldb::SBEvent>(new lldb::SBEvent(event),
                                            SWIGTYPE_p_lldb__SBEvent);
 }
 
 } // namespace python
 } // namespace lldb_private

lldb/bindings/python/python-wrapper.swig

if (PyErr_Occurred()) {
       PyErr_Clear();
     }
   }
 
 private:
   bool m_print;
 };
 
-llvm::Expected<bool> lldb_private::LLDBSwigPythonBreakpointCallbackFunction(
+llvm::Expected<bool> lldb_private::python::SWIGBridge::LLDBSwigPythonBreakpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &frame_sp,
     const lldb::BreakpointLocationSP &bp_loc_sp,
     const lldb_private::StructuredDataImpl &args_impl) {
   using namespace llvm;
 
   lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
 
   PyErr_Cleaner py_err_cleaner(true);
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   unsigned max_positional_args;
   if (auto arg_info = pfunc.GetArgInfo())
     max_positional_args = arg_info.get().max_positional_args;
   else
     return arg_info.takeError();
 
-  PythonObject frame_arg = ToSWIGWrapper(frame_sp);
-  PythonObject bp_loc_arg = ToSWIGWrapper(bp_loc_sp);
+  PythonObject frame_arg = SWIGBridge::ToSWIGWrapper(frame_sp);
+  PythonObject bp_loc_arg = SWIGBridge::ToSWIGWrapper(bp_loc_sp);
 
   auto result =
       max_positional_args < 4
           ? pfunc.Call(frame_arg, bp_loc_arg, dict)
-          : pfunc.Call(frame_arg, bp_loc_arg, ToSWIGWrapper(args_impl), dict);
+          : pfunc.Call(frame_arg, bp_loc_arg, SWIGBridge::ToSWIGWrapper(args_impl), dict);
 
   if (!result)
     return result.takeError();
 
   // Only False counts as false!
   return result.get().get() != Py_False;
 }
 
 // resolve a dotted Python name in the form
 // foo.bar.baz.Foobar to an actual Python object
 // if pmodule is NULL, the __main__ module will be used
 // as the starting point for the search
 
 // This function is called by
 // lldb_private::ScriptInterpreterPython::BreakpointCallbackFunction(...) and is
 // used when a script command is attached to a breakpoint for execution.
 
 // This function is called by
 // lldb_private::ScriptInterpreterPython::WatchpointCallbackFunction(...) and is
 // used when a script command is attached to a watchpoint for execution.
 
-bool lldb_private::LLDBSwigPythonWatchpointCallbackFunction(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonWatchpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &frame_sp, const lldb::WatchpointSP &wp_sp) {
 
   bool stop_at_watchpoint = true;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return stop_at_watchpoint;
 
   PythonObject result =
-      pfunc(ToSWIGWrapper(frame_sp), ToSWIGWrapper(wp_sp), dict);
+      pfunc(SWIGBridge::ToSWIGWrapper(frame_sp), SWIGBridge::ToSWIGWrapper(wp_sp), dict);
 
   if (result.get() == Py_False)
     stop_at_watchpoint = false;
 
   return stop_at_watchpoint;
 }
 
 // This function is called by
 // ScriptInterpreterPython::FormatterMatchingCallbackFunction and it's used when
 // a data formatter provides the name of a callback to inspect a candidate type
 // before considering a match.
-bool lldb_private::LLDBSwigPythonFormatterCallbackFunction(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonFormatterCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::TypeImplSP type_impl_sp) {
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return false;
 
   PythonObject result =
-      pfunc(ToSWIGWrapper(type_impl_sp), dict);
+      pfunc(SWIGBridge::ToSWIGWrapper(type_impl_sp), dict);
 
   // Only if everything goes okay and the function returns True we'll consider
   // it a match.
   return result.get() == Py_True;
 }
 
-bool lldb_private::LLDBSwigPythonCallTypeScript(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallTypeScript(
     const char *python_function_name, const void *session_dictionary,
     const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
     const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval) {
 
   retval.clear();
 
   if (!python_function_name || !session_dictionary)
     return false;
bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallTypeScript(
 
   PythonObject result;
   auto argc = pfunc.GetArgInfo();
   if (!argc) {
     llvm::consumeError(argc.takeError());
     return false;
   }
 
-  PythonObject value_arg = ToSWIGWrapper(valobj_sp);
+  PythonObject value_arg = SWIGBridge::ToSWIGWrapper(valobj_sp);
 
   if (argc.get().max_positional_args < 3)
     result = pfunc(value_arg, dict);
   else
-    result = pfunc(value_arg, dict, ToSWIGWrapper(*options_sp));
+    result = pfunc(value_arg, dict, SWIGBridge::ToSWIGWrapper(*options_sp));
 
   retval = result.Str().GetString().str();
 
   return true;
 }
 
-PythonObject lldb_private::LLDBSwigPythonCreateSyntheticProvider(
+PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateSyntheticProvider(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::ValueObjectSP &valobj_sp) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     return PythonObject();
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_class_name, dict);
 
   if (!pfunc.IsAllocated())
     return PythonObject();
 
-  auto sb_value = std::make_unique<lldb::SBValue>(valobj_sp);
+  auto sb_value = std::unique_ptr<lldb::SBValue>(new lldb::SBValue(valobj_sp));
   sb_value->SetPreferSyntheticValue(false);
 
-  PythonObject val_arg = ToSWIGWrapper(std::move(sb_value));
+  PythonObject val_arg = SWIGBridge::ToSWIGWrapper(std::move(sb_value));
   if (!val_arg.IsAllocated())
     return PythonObject();
 
   PythonObject result = pfunc(val_arg, dict);
 
   if (result.IsAllocated())
     return result;
 
   return PythonObject();
 }
 
-PythonObject lldb_private::LLDBSwigPythonCreateCommandObject(
+PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateCommandObject(
     const char *python_class_name, const char *session_dictionary_name,
     lldb::DebuggerSP debugger_sp) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     return PythonObject();
 
   PyErr_Cleaner py_err_cleaner(true);
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_class_name, dict);
 
   if (!pfunc.IsAllocated())
     return PythonObject();
 
-  return pfunc(ToSWIGWrapper(std::move(debugger_sp)), dict);
+  return pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger_sp)), dict);
 }
 
-PythonObject lldb_private::LLDBSwigPythonCreateScriptedObject(
+PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedObject(
     const char *python_class_name, const char *session_dictionary_name,
     lldb::ExecutionContextRefSP exe_ctx_sp,
     const lldb_private::StructuredDataImpl &args_impl,
     std::string &error_string) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     return PythonObject();
 
llvm::handleAllErrors(
         [&](const llvm::ErrorInfoBase &E) {
           error_string.append(E.message());
         });
     return PythonObject();
   }
 
   PythonObject result = {};
   if (arg_info.get().max_positional_args == 2) {
-      result = pfunc(ToSWIGWrapper(exe_ctx_sp), ToSWIGWrapper(args_impl));
+      result = pfunc(SWIGBridge::ToSWIGWrapper(exe_ctx_sp), SWIGBridge::ToSWIGWrapper(args_impl));
   } else {
     error_string.assign("wrong number of arguments in __init__, should be 2 "
                         "(not including self)");
   }
   return result;
 }
 
-PythonObject lldb_private::LLDBSwigPythonCreateScriptedThreadPlan(
+PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb_private::StructuredDataImpl &args_impl,
     std::string &error_string, const lldb::ThreadPlanSP &thread_plan_sp) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     return PythonObject();
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_class_name, dict);
 
   if (!pfunc.IsAllocated()) {
     error_string.append("could not find script class: ");
     error_string.append(python_class_name);
     return PythonObject();
   }
 
-  PythonObject tp_arg = ToSWIGWrapper(thread_plan_sp);
+  PythonObject tp_arg = SWIGBridge::ToSWIGWrapper(thread_plan_sp);
 
   llvm::Expected<PythonCallable::ArgInfo> arg_info = pfunc.GetArgInfo();
   if (!arg_info) {
     llvm::handleAllErrors(
         arg_info.takeError(),
         [&](PythonException &E) { error_string.append(E.ReadBacktrace()); },
         [&](const llvm::ErrorInfoBase &E) {
           error_string.append(E.message());
         });
     return PythonObject();
   }
 
   PythonObject result = {};
-  auto args_sb = std::make_unique<lldb::SBStructuredData>(args_impl);
+  auto args_sb = std::unique_ptr<lldb::SBStructuredData>(new lldb::SBStructuredData(args_impl));
   if (arg_info.get().max_positional_args == 2) {
     if (args_sb->IsValid()) {
       error_string.assign(
           "args passed, but __init__ does not take an args dictionary");
       return PythonObject();
     }
     result = pfunc(tp_arg, dict);
   } else if (arg_info.get().max_positional_args >= 3) {
-    result = pfunc(tp_arg, ToSWIGWrapper(std::move(args_sb)), dict);
+    result = pfunc(tp_arg, SWIGBridge::ToSWIGWrapper(std::move(args_sb)), dict);
   } else {
     error_string.assign("wrong number of arguments in __init__, should be 2 or "
                         "3 (not including self)");
     return PythonObject();
   }
 
   // FIXME: At this point we should check that the class we found supports all
   // the methods that we need.
 
   return result;
 }
 
-bool lldb_private::LLDBSWIGPythonCallThreadPlan(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonCallThreadPlan(
     void *implementor, const char *method_name, lldb_private::Event *event,
     bool &got_error) {
   got_error = false;
 
   PyErr_Cleaner py_err_cleaner(false);
   PythonObject self(PyRefType::Borrowed, static_cast<PyObject *>(implementor));
   auto pfunc = self.ResolveName<PythonCallable>(method_name);
 
   if (!pfunc.IsAllocated())
     return false;
 
   PythonObject result;
   if (event != nullptr) {
-    ScopedPythonObject<SBEvent> event_arg = ToSWIGWrapper(event);
+    ScopedPythonObject<SBEvent> event_arg = SWIGBridge::ToSWIGWrapper(event);
     result = pfunc(event_arg.obj());
   } else
     result = pfunc();
 
   if (PyErr_Occurred()) {
     got_error = true;
     printf("Return value was neither false nor true for call to %s.\n",
            method_name);
     PyErr_Print();
     return false;
   }
 
   if (result.get() == Py_True)
     return true;
   else if (result.get() == Py_False)
     return false;
 
   // Somebody returned the wrong thing...
   got_error = true;
   printf("Wrong return value type for call to %s.\n", method_name);
   return false;
 }
 
-bool lldb_private::LLDBSWIGPythonCallThreadPlan(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonCallThreadPlan(
     void *implementor, const char *method_name, lldb_private::Stream *stream,
     bool &got_error) {
   got_error = false;
 
   PyErr_Cleaner py_err_cleaner(false);
   PythonObject self(PyRefType::Borrowed, static_cast<PyObject *>(implementor));
   auto pfunc = self.ResolveName<PythonCallable>(method_name);
 
   if (!pfunc.IsAllocated()) 
     return false;
 
   auto *sb_stream = new lldb::SBStream();
   PythonObject sb_stream_arg =
-      ToSWIGWrapper(std::unique_ptr<lldb::SBStream>(sb_stream));
+      SWIGBridge::ToSWIGWrapper(std::unique_ptr<lldb::SBStream>(sb_stream));
 
   PythonObject result;
   result = pfunc(sb_stream_arg);
 
   if (PyErr_Occurred()) {
     printf("Error occured for call to %s.\n",
            method_name);
     PyErr_Print();
     got_error = true;
     return false;
   }
   if (stream)
     stream->PutCString(sb_stream->GetData());
   return true;
 
 }
 
-PythonObject lldb_private::LLDBSwigPythonCreateScriptedBreakpointResolver(
+PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedBreakpointResolver(
     const char *python_class_name, const char *session_dictionary_name,
     const StructuredDataImpl &args_impl,
     const lldb::BreakpointSP &breakpoint_sp) {
 
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     return PythonObject();
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_class_name, dict);
 
   if (!pfunc.IsAllocated())
     return PythonObject();
 
   PythonObject result =
-      pfunc(ToSWIGWrapper(breakpoint_sp), ToSWIGWrapper(args_impl), dict);
+      pfunc(SWIGBridge::ToSWIGWrapper(breakpoint_sp), SWIGBridge::ToSWIGWrapper(args_impl), dict);
   // FIXME: At this point we should check that the class we found supports all
   // the methods that we need.
 
   if (result.IsAllocated()) {
     // Check that __callback__ is defined:
     auto callback_func = result.ResolveName<PythonCallable>("__callback__");
     if (callback_func.IsAllocated())
       return result;
   }
   return PythonObject();
 }
 
-unsigned int lldb_private::LLDBSwigPythonCallBreakpointResolver(
+unsigned int lldb_private::python::SWIGBridge::LLDBSwigPythonCallBreakpointResolver(
     void *implementor, const char *method_name,
     lldb_private::SymbolContext *sym_ctx) {
   PyErr_Cleaner py_err_cleaner(false);
   PythonObject self(PyRefType::Borrowed, static_cast<PyObject *>(implementor));
   auto pfunc = self.ResolveName<PythonCallable>(method_name);
 
   if (!pfunc.IsAllocated())
     return 0;
 
-  PythonObject result = sym_ctx ? pfunc(ToSWIGWrapper(*sym_ctx)) : pfunc();
+  PythonObject result = sym_ctx ? pfunc(SWIGBridge::ToSWIGWrapper(*sym_ctx)) : pfunc();
 
   if (PyErr_Occurred()) {
     PyErr_Print();
     PyErr_Clear();
     return 0;
   }
 
   // The callback will return a bool, but we're need to also return ints
if (PyErr_Occurred()) {
     PyErr_Print();
     PyErr_Clear();
     return 0;
   }
 
   return ret_val;
 }
 
-PythonObject lldb_private::LLDBSwigPythonCreateScriptedStopHook(
+PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedStopHook(
     lldb::TargetSP target_sp, const char *python_class_name,
     const char *session_dictionary_name, const StructuredDataImpl &args_impl,
     Status &error) {
   if (python_class_name == NULL || python_class_name[0] == '\0') {
     error.SetErrorString("Empty class name.");
     return PythonObject();
   }
   if (!session_dictionary_name) {
PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedStopHook(
 
   if (!pfunc.IsAllocated()) {
     error.SetErrorStringWithFormat("Could not find class: %s.",
                                    python_class_name);
     return PythonObject();
   }
 
   PythonObject result =
-      pfunc(ToSWIGWrapper(target_sp), ToSWIGWrapper(args_impl), dict);
+      pfunc(SWIGBridge::ToSWIGWrapper(target_sp), SWIGBridge::ToSWIGWrapper(args_impl), dict);
 
   if (result.IsAllocated()) {
     // Check that the handle_stop callback is defined:
     auto callback_func = result.ResolveName<PythonCallable>("handle_stop");
     if (callback_func.IsAllocated()) {
       if (auto args_info = callback_func.GetArgInfo()) {
         size_t num_args = (*args_info).max_positional_args;
         if (num_args != 2) {
if (callback_func.IsAllocated()) {
       error.SetErrorStringWithFormat("Class \"%s\" is missing the required "
                                      "handle_stop callback.",
                                      python_class_name);
     }
   }
   return PythonObject();
 }
 
-bool lldb_private::LLDBSwigPythonStopHookCallHandleStop(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonStopHookCallHandleStop(
     void *implementor, lldb::ExecutionContextRefSP exc_ctx_sp,
     lldb::StreamSP stream) {
   // handle_stop will return a bool with the meaning "should_stop"...
   // If you return nothing we'll assume we are going to stop.
   // Also any errors should return true, since we should stop on error.
 
   PyErr_Cleaner py_err_cleaner(false);
   PythonObject self(PyRefType::Borrowed, static_cast<PyObject *>(implementor));
   auto pfunc = self.ResolveName<PythonCallable>("handle_stop");
 
   if (!pfunc.IsAllocated())
     return true;
 
   auto *sb_stream = new lldb::SBStream();
   PythonObject sb_stream_arg =
-      ToSWIGWrapper(std::unique_ptr<lldb::SBStream>(sb_stream));
+      SWIGBridge::ToSWIGWrapper(std::unique_ptr<lldb::SBStream>(sb_stream));
   PythonObject result =
-      pfunc(ToSWIGWrapper(std::move(exc_ctx_sp)), sb_stream_arg);
+      pfunc(SWIGBridge::ToSWIGWrapper(std::move(exc_ctx_sp)), sb_stream_arg);
 
   if (PyErr_Occurred()) {
     stream->PutCString("Python error occurred handling stop-hook.");
     PyErr_Print();
     PyErr_Clear();
     return true;
   }
 
static PyObject *LLDBSwigPython_CallOptionalMember(
 
   if (was_found)
     *was_found = true;
 
   PythonObject result = pfunc();
   return result.release();
 }
 
-size_t lldb_private::LLDBSwigPython_CalculateNumChildren(PyObject * implementor,
+size_t lldb_private::python::SWIGBridge::LLDBSwigPython_CalculateNumChildren(PyObject * implementor,
                                                          uint32_t max) {
   PythonObject self(PyRefType::Borrowed, implementor);
   auto pfunc = self.ResolveName<PythonCallable>("num_children");
 
   if (!pfunc.IsAllocated())
     return 0;
 
   auto arg_info = pfunc.GetArgInfo();
size_t lldb_private::python::SWIGBridge::LLDBSwigPython_CalculateNumChildren(PyObject * implementor,
   }
 
   if (arg_info.get().max_positional_args < 1)
     ret_val = std::min(ret_val, static_cast<size_t>(max));
 
   return ret_val;
 }
 
-PyObject *lldb_private::LLDBSwigPython_GetChildAtIndex(PyObject * implementor,
+PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetChildAtIndex(PyObject * implementor,
                                                        uint32_t idx) {
   PyErr_Cleaner py_err_cleaner(true);
 
   PythonObject self(PyRefType::Borrowed, implementor);
   auto pfunc = self.ResolveName<PythonCallable>("get_child_at_index");
 
   if (!pfunc.IsAllocated())
     return nullptr;
if (SWIG_ConvertPtr(result.get(), (void **)&sbvalue_ptr,
     return nullptr;
 
   if (sbvalue_ptr == nullptr)
     return nullptr;
 
   return result.release();
 }
 
-int lldb_private::LLDBSwigPython_GetIndexOfChildWithName(
+int lldb_private::python::SWIGBridge::LLDBSwigPython_GetIndexOfChildWithName(
     PyObject * implementor, const char *child_name) {
   PyErr_Cleaner py_err_cleaner(true);
 
   PythonObject self(PyRefType::Borrowed, implementor);
   auto pfunc = self.ResolveName<PythonCallable>("get_child_index");
 
   if (!pfunc.IsAllocated())
     return UINT32_MAX;
int lldb_private::python::SWIGBridge::LLDBSwigPython_GetIndexOfChildWithName(
   }
 
   if (retval >= 0)
     return (uint32_t)retval;
 
   return UINT32_MAX;
 }
 
-bool lldb_private::LLDBSwigPython_UpdateSynthProviderInstance(PyObject *
+bool lldb_private::python::SWIGBridge::LLDBSwigPython_UpdateSynthProviderInstance(PyObject *
                                                               implementor) {
   bool ret_val = false;
 
   static char callee_name[] = "update";
 
   PyObject *py_return =
       LLDBSwigPython_CallOptionalMember(implementor, callee_name);
 
   if (py_return == Py_True)
     ret_val = true;
 
   Py_XDECREF(py_return);
 
   return ret_val;
 }
 
-bool lldb_private::LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
+bool lldb_private::python::SWIGBridge::LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
     PyObject * implementor) {
   bool ret_val = false;
 
   static char callee_name[] = "has_children";
 
   PyObject *py_return =
       LLDBSwigPython_CallOptionalMember(implementor, callee_name, Py_True);
 
   if (py_return == Py_True)
     ret_val = true;
 
   Py_XDECREF(py_return);
 
   return ret_val;
 }
 
-PyObject *lldb_private::LLDBSwigPython_GetValueSynthProviderInstance(
+PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetValueSynthProviderInstance(
     PyObject * implementor) {
   PyObject *ret_val = nullptr;
 
   static char callee_name[] = "get_value";
 
   PyObject *py_return =
       LLDBSwigPython_CallOptionalMember(implementor, callee_name, Py_None);
 
int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr,
                                    SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0);
 
   if (valid_cast == -1)
     return NULL;
 
   return sb_ptr;
 }
 
-bool lldb_private::LLDBSwigPythonCallCommand(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommand(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
 
   PyErr_Cleaner py_err_cleaner(true);
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return false;
 
   auto argc = pfunc.GetArgInfo();
   if (!argc) {
     llvm::consumeError(argc.takeError());
     return false;
   }
-  PythonObject debugger_arg = ToSWIGWrapper(std::move(debugger));
-  auto cmd_retobj_arg = ToSWIGWrapper(cmd_retobj);
+  PythonObject debugger_arg = SWIGBridge::ToSWIGWrapper(std::move(debugger));
+  auto cmd_retobj_arg = SWIGBridge::ToSWIGWrapper(cmd_retobj);
 
   if (argc.get().max_positional_args < 5u)
     pfunc(debugger_arg, PythonString(args), cmd_retobj_arg.obj(), dict);
   else
     pfunc(debugger_arg, PythonString(args),
-          ToSWIGWrapper(std::move(exe_ctx_ref_sp)), cmd_retobj_arg.obj(), dict);
+          SWIGBridge::ToSWIGWrapper(std::move(exe_ctx_ref_sp)), cmd_retobj_arg.obj(), dict);
 
   return true;
 }
 
-bool lldb_private::LLDBSwigPythonCallCommandObject(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommandObject(
     PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
 
   PyErr_Cleaner py_err_cleaner(true);
 
   PythonObject self(PyRefType::Borrowed, implementor);
   auto pfunc = self.ResolveName<PythonCallable>("__call__");
 
   if (!pfunc.IsAllocated())
     return false;
 
-  auto cmd_retobj_arg = ToSWIGWrapper(cmd_retobj);
+  auto cmd_retobj_arg = SWIGBridge::ToSWIGWrapper(cmd_retobj);
 
-  pfunc(ToSWIGWrapper(std::move(debugger)), PythonString(args),
-        ToSWIGWrapper(exe_ctx_ref_sp), cmd_retobj_arg.obj());
+  pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), PythonString(args),
+        SWIGBridge::ToSWIGWrapper(exe_ctx_ref_sp), cmd_retobj_arg.obj());
 
   return true;
 }
 
-PythonObject lldb_private::LLDBSWIGPythonCreateOSPlugin(
+PythonObject lldb_private::python::SWIGBridge::LLDBSWIGPythonCreateOSPlugin(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::ProcessSP &process_sp) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     return PythonObject();
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_class_name, dict);
 
   if (!pfunc.IsAllocated())
     return PythonObject();
 
-  return pfunc(ToSWIGWrapper(process_sp));
+  return pfunc(SWIGBridge::ToSWIGWrapper(process_sp));
 }
 
-PythonObject lldb_private::LLDBSWIGPython_CreateFrameRecognizer(
+PythonObject lldb_private::python::SWIGBridge::LLDBSWIGPython_CreateFrameRecognizer(
     const char *python_class_name, const char *session_dictionary_name) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     return PythonObject();
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_class_name, dict);
 
   if (!pfunc.IsAllocated())
     return PythonObject();
 
   return pfunc();
 }
 
-PyObject *lldb_private::LLDBSwigPython_GetRecognizedArguments(
+PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetRecognizedArguments(
     PyObject * implementor, const lldb::StackFrameSP &frame_sp) {
   static char callee_name[] = "get_recognized_arguments";
 
-  PythonObject arg = ToSWIGWrapper(frame_sp);
+  PythonObject arg = SWIGBridge::ToSWIGWrapper(frame_sp);
 
   PythonString str(callee_name);
   PyObject *result =
       PyObject_CallMethodObjArgs(implementor, str.get(), arg.get(), NULL);
   return result;
 }
 
-void *lldb_private::LLDBSWIGPython_GetDynamicSetting(
+void *lldb_private::python::SWIGBridge::LLDBSWIGPython_GetDynamicSetting(
     void *module, const char *setting, const lldb::TargetSP &target_sp) {
   if (!module || !setting)
     Py_RETURN_NONE;
 
   PyErr_Cleaner py_err_cleaner(true);
   PythonObject py_module(PyRefType::Borrowed, (PyObject *)module);
   auto pfunc = py_module.ResolveName<PythonCallable>("get_dynamic_setting");
 
   if (!pfunc.IsAllocated())
     Py_RETURN_NONE;
 
-  auto result = pfunc(ToSWIGWrapper(target_sp), PythonString(setting));
+  auto result = pfunc(SWIGBridge::ToSWIGWrapper(target_sp), PythonString(setting));
 
   return result.release();
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordProcess(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordProcess(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::ProcessSP &process, std::string &output) {
 
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
     return false;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return false;
 
-  auto result = pfunc(ToSWIGWrapper(process), dict);
+  auto result = pfunc(SWIGBridge::ToSWIGWrapper(process), dict);
 
   output = result.Str().GetString().str();
 
   return true;
 }
 
-std::optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordThread(
+std::optional<std::string> lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordThread(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::ThreadSP thread) {
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
     return std::nullopt;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return std::nullopt;
 
-  auto result = pfunc(ToSWIGWrapper(std::move(thread)), dict);
+  auto result = pfunc(SWIGBridge::ToSWIGWrapper(std::move(thread)), dict);
 
   return result.Str().GetString().str();
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordTarget(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordTarget(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::TargetSP &target, std::string &output) {
 
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
     return false;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return false;
 
-  auto result = pfunc(ToSWIGWrapper(target), dict);
+  auto result = pfunc(SWIGBridge::ToSWIGWrapper(target), dict);
 
   output = result.Str().GetString().str();
 
   return true;
 }
 
-std::optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordFrame(
+std::optional<std::string> lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordFrame(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::StackFrameSP frame) {
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
     return std::nullopt;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return std::nullopt;
 
-  auto result = pfunc(ToSWIGWrapper(std::move(frame)), dict);
+  auto result = pfunc(SWIGBridge::ToSWIGWrapper(std::move(frame)), dict);
 
   return result.Str().GetString().str();
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordValue(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordValue(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::ValueObjectSP &value, std::string &output) {
 
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
     return false;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return false;
 
-  auto result = pfunc(ToSWIGWrapper(value), dict);
+  auto result = pfunc(SWIGBridge::ToSWIGWrapper(value), dict);
 
   output = result.Str().GetString().str();
 
   return true;
 }
 
-bool lldb_private::LLDBSwigPythonCallModuleInit(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallModuleInit(
     const char *python_module_name, const char *session_dictionary_name,
     lldb::DebuggerSP debugger) {
   std::string python_function_name_string = python_module_name;
   python_function_name_string += ".__lldb_init_module";
   const char *python_function_name = python_function_name_string.c_str();
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   // This method is optional and need not exist.  So if we don't find it,
   // it's actually a success, not a failure.
   if (!pfunc.IsAllocated())
     return true;
 
-  pfunc(ToSWIGWrapper(std::move(debugger)), dict);
+  pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), dict);
 
   return true;
 }
 
-lldb::ValueObjectSP lldb_private::LLDBSWIGPython_GetValueObjectSPFromSBValue(
+lldb::ValueObjectSP lldb_private::python::SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue(
     void *data) {
   lldb::ValueObjectSP valobj_sp;
   if (data) {
     lldb::SBValue *sb_ptr = (lldb::SBValue *)data;
     valobj_sp = sb_ptr->GetSP();
   }
   return valobj_sp;
 }

lldb/include/lldb/API/SBBreakpoint.h

 #define LLDB_API_SBBREAKPOINT_H
 
 #include "lldb/API/SBDefines.h"
 
 class SBBreakpointListImpl;
 
 namespace lldb_private {
 class ScriptInterpreter;
+namespace python {
+class SWIGBridge;
 }
+} // namespace lldb_private
 
 namespace lldb {
 
 class LLDB_API SBBreakpoint {
 public:
 
   SBBreakpoint();
 
   SBBreakpoint(const lldb::SBBreakpoint &rhs);
 
-#ifndef SWIG
-  SBBreakpoint(const lldb::BreakpointSP &bp_sp);
-#endif
-
   ~SBBreakpoint();
 
   const lldb::SBBreakpoint &operator=(const lldb::SBBreakpoint &rhs);
 
   // Tests to see if the opaque breakpoint object in this object matches the
   // opaque breakpoint object in "rhs".
   bool operator==(const lldb::SBBreakpoint &rhs);
 

 
 private:
   friend class SBBreakpointList;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
   friend class SBTarget;
 
   friend class lldb_private::ScriptInterpreter;
+  friend class lldb_private::python::SWIGBridge;
+
+  SBBreakpoint(const lldb::BreakpointSP &bp_sp);
 
   lldb::BreakpointSP GetSP() const;
 
   lldb::BreakpointWP m_opaque_wp;
 };
 
 class LLDB_API SBBreakpointList {
 public:

lldb/include/lldb/API/SBBreakpointLocation.h

 //===-- SBBreakpointLocation.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_SBBREAKPOINTLOCATION_H
 #define LLDB_API_SBBREAKPOINTLOCATION_H
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class LLDB_API SBBreakpointLocation {
 public:
   SBBreakpointLocation();
 
   SBBreakpointLocation(const lldb::SBBreakpointLocation &rhs);
 
#endif
   const char *GetQueueName() const;
 
   bool IsResolved();
 
   bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
 
   SBBreakpoint GetBreakpoint();
 
-#ifndef SWIG
+protected:
+  friend class lldb_private::python::SWIGBridge;
   SBBreakpointLocation(const lldb::BreakpointLocationSP &break_loc_sp);
-#endif
 
 private:
   friend class SBBreakpoint;
   friend class SBBreakpointCallbackBaton;
 
   void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp);
   BreakpointLocationSP GetSP() const;
 
   lldb::BreakpointLocationWP m_opaque_wp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBBREAKPOINTLOCATION_H

lldb/include/lldb/API/SBCommandInterpreter.h

 //===-- SBCommandInterpreter.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_SBCOMMANDINTERPRETER_H
 #define LLDB_API_SBCOMMANDINTERPRETER_H
 
 #include <memory>
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+class CommandPluginInterfaceImplementation;
+}
+
 namespace lldb {
 
 class SBCommandInterpreter {
 public:
   enum {
     eBroadcastBitThreadShouldExit = (1 << 0),
     eBroadcastBitResetPrompt = (1 << 1),
     eBroadcastBitQuitCommandReceived = (1 << 2), // User entered quit
#endif
 
   // Catch commands before they execute by registering a callback that will get
   // called when the command gets executed. This allows GUI or command line
   // interfaces to intercept a command and stop it from happening
 #ifndef SWIG
   bool SetCommandOverrideCallback(const char *command_name,
                                   lldb::CommandOverrideCallback callback,
                                   void *baton);
-  SBCommandInterpreter(
-      lldb_private::CommandInterpreter *interpreter_ptr =
-          nullptr); // Access using SBDebugger::GetCommandInterpreter();
 #endif
 
   /// Return true if the command interpreter is the active IO handler.
   ///
   /// This indicates that any input coming into the debugger handles will
   /// go to the command interpreter and will result in LLDB command line
   /// commands being executed.
   bool IsActive();
#endif
   /// without a custom exit code.
   int GetQuitStatus();
 
   /// Resolve the command just as HandleCommand would, expanding abbreviations
   /// and aliases.  If successful, result->GetOutput has the full expansion.
   void ResolveCommand(const char *command_line, SBCommandReturnObject &result);
 
 protected:
+  friend class lldb_private::CommandPluginInterfaceImplementation;
+
+  SBCommandInterpreter(
+      lldb_private::CommandInterpreter *interpreter_ptr =
+          nullptr); // Access using SBDebugger::GetCommandInterpreter();
   lldb_private::CommandInterpreter &ref();
 
   lldb_private::CommandInterpreter *get();
 
   void reset(lldb_private::CommandInterpreter *);
 
 private:
   friend class SBDebugger;

lldb/include/lldb/API/SBCommandReturnObject.h

 
 #include <cstdio>
 
 #include <memory>
 
 #include "lldb/API/SBDefines.h"
 
 namespace lldb_private {
+class CommandPluginInterfaceImplementation;
 class SBCommandReturnObjectImpl;
+namespace python {
+class SWIGBridge;
 }
+} // namespace lldb_private
 
 namespace lldb {
 
 class LLDB_API SBCommandReturnObject {
 public:
   SBCommandReturnObject();
 
-#ifndef SWIG
-  SBCommandReturnObject(lldb_private::CommandReturnObject &ref);
-#endif
-
   // rvalue ctor+assignment are incompatible with Reproducers.
 
   SBCommandReturnObject(const lldb::SBCommandReturnObject &rhs);
 
   ~SBCommandReturnObject();
 
   lldb::SBCommandReturnObject &
   operator=(const lldb::SBCommandReturnObject &rhs);
void SetError(lldb::SBError &error,
                 const char *fallback_error_cstr = nullptr);
 
   void SetError(const char *error_cstr);
 
 protected:
   friend class SBCommandInterpreter;
   friend class SBOptions;
 
+  friend class lldb_private::CommandPluginInterfaceImplementation;
+  friend class lldb_private::python::SWIGBridge;
+
+  SBCommandReturnObject(lldb_private::CommandReturnObject &ref);
+
   lldb_private::CommandReturnObject *operator->() const;
 
   lldb_private::CommandReturnObject *get() const;
 
   lldb_private::CommandReturnObject &operator*() const;
 
 private:
   lldb_private::CommandReturnObject &ref() const;
 
   std::unique_ptr<lldb_private::SBCommandReturnObjectImpl> m_opaque_up;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBCOMMANDRETURNOBJECT_H

lldb/include/lldb/API/SBDebugger.h

 //===-- SBDebugger.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_SBDEBUGGER_H
 #define LLDB_API_SBDEBUGGER_H
 
 #include <cstdio>
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBPlatform.h"
 
+namespace lldb_private {
+class CommandPluginInterfaceImplementation;
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 #ifndef SWIG
 class LLDB_API SBInputReader {
 public:
   SBInputReader() = default;
   ~SBInputReader() = default;
 
FLAGS_ANONYMOUS_ENUM(){
       eBroadcastBitWarning = (1 << 1),
       eBroadcastBitError = (1 << 2),
   };
 
   SBDebugger();
 
   SBDebugger(const lldb::SBDebugger &rhs);
 
-#ifndef SWIG
-  SBDebugger(const lldb::DebuggerSP &debugger_sp);
-#endif
-
   ~SBDebugger();
 
   static const char *GetBroadcasterClass();
 
   lldb::SBBroadcaster GetBroadcaster();
 
   /// Get progress data from a SBEvent whose type is eBroadcastBitProgress.
   ///
#endif
   /// \param[out] error
   ///   An error if the trace could not be created.
   ///
   /// \param[in] trace_description_file
   ///   The file containing the necessary information to load the trace.
   SBTrace LoadTraceFromFile(SBError &error,
                             const SBFileSpec &trace_description_file);
 
+protected:
+  friend class lldb_private::CommandPluginInterfaceImplementation;
+  friend class lldb_private::python::SWIGBridge;
+
+  SBDebugger(const lldb::DebuggerSP &debugger_sp);
+
 private:
   friend class SBCommandInterpreter;
   friend class SBInputReader;
   friend class SBListener;
   friend class SBProcess;
   friend class SBSourceManager;
   friend class SBTarget;
   friend class SBTrace;

lldb/include/lldb/API/SBError.h

 //===-- SBError.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_SBERROR_H
 #define LLDB_API_SBERROR_H
 
 #include "lldb/API/SBDefines.h"
 
 namespace lldb_private {
 class ScriptInterpreter;
+namespace python {
+class SWIGBridge;
+}
 } // namespace lldb_private
 
 namespace lldb {
 
 class LLDB_API SBError {
 public:
   SBError();
 
   SBError(const lldb::SBError &rhs);
 
   SBError(const char *message);
 
-#ifndef SWIG
-  SBError(const lldb_private::Status &error);
-#endif
-
   ~SBError();
 
   const SBError &operator=(const lldb::SBError &rhs);
 
   /// Get the error string as a NULL terminated UTF8 c-string.
   ///
   /// This SBError object owns the returned string and this object must be kept
   /// around long enough to use the returned string.
protected:
   friend class SBTarget;
   friend class SBThread;
   friend class SBTrace;
   friend class SBValue;
   friend class SBValueList;
   friend class SBWatchpoint;
 
   friend class lldb_private::ScriptInterpreter;
+  friend class lldb_private::python::SWIGBridge;
+
+  SBError(const lldb_private::Status &error);
 
   lldb_private::Status *get();
 
   lldb_private::Status *operator->();
 
   const lldb_private::Status &operator*() const;
 
   lldb_private::Status &ref();

lldb/include/lldb/API/SBEvent.h

 //===-- SBEvent.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_SBEVENT_H
 #define LLDB_API_SBEVENT_H
 
 #include "lldb/API/SBDefines.h"
 
 #include <cstdio>
 #include <vector>
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class SBBroadcaster;
 
 class LLDB_API SBEvent {
 public:
   SBEvent();
 
   SBEvent(const lldb::SBEvent &rhs);
 
   // Make an event that contains a C string.
   SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len);
 
-#ifndef SWIG
-  SBEvent(lldb::EventSP &event_sp);
-
-  SBEvent(lldb_private::Event *event_sp);
-#endif
-
   ~SBEvent();
 
   const SBEvent &operator=(const lldb::SBEvent &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
protected:
   friend class SBBroadcaster;
   friend class SBBreakpoint;
   friend class SBDebugger;
   friend class SBProcess;
   friend class SBTarget;
   friend class SBThread;
   friend class SBWatchpoint;
 
+  friend class lldb_private::python::SWIGBridge;
+
+  SBEvent(lldb::EventSP &event_sp);
+
+  SBEvent(lldb_private::Event *event_sp);
+
   lldb::EventSP &GetSP() const;
 
   void reset(lldb::EventSP &event_sp);
 
   void reset(lldb_private::Event *event);
 
   lldb_private::Event *get() const;
 
 private:
   mutable lldb::EventSP m_event_sp;
   mutable lldb_private::Event *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBEVENT_H

lldb/include/lldb/API/SBExecutionContext.h

 #ifndef LLDB_API_SBEXECUTIONCONTEXT_H
 #define LLDB_API_SBEXECUTIONCONTEXT_H
 
 #include "lldb/API/SBDefines.h"
 
 #include <cstdio>
 #include <vector>
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class LLDB_API SBExecutionContext {
   friend class SBCommandInterpreter;
 
 public:
   SBExecutionContext();
 
   SBExecutionContext(const lldb::SBExecutionContext &rhs);
 
-#ifndef SWIG
-  SBExecutionContext(lldb::ExecutionContextRefSP exe_ctx_ref_sp);
-#endif
-
   SBExecutionContext(const lldb::SBTarget &target);
 
   SBExecutionContext(const lldb::SBProcess &process);
 
   SBExecutionContext(lldb::SBThread thread); // can't be a const& because
                                              // SBThread::get() isn't itself a
                                              // const function
 
   SBExecutionContext(const lldb::SBFrame &frame);
 
   ~SBExecutionContext();
 
   const SBExecutionContext &operator=(const lldb::SBExecutionContext &rhs);
 
   SBTarget GetTarget() const;
 
   SBProcess GetProcess() const;
 
   SBThread GetThread() const;
 
   SBFrame GetFrame() const;
 
 protected:
+  friend class lldb_private::python::SWIGBridge;
+
   lldb_private::ExecutionContextRef *get() const;
 
+  SBExecutionContext(lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+
 private:
   mutable lldb::ExecutionContextRefSP m_exe_ctx_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBEXECUTIONCONTEXT_H

lldb/include/lldb/API/SBFrame.h

 //===-- SBFrame.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_SBFRAME_H
 #define LLDB_API_SBFRAME_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBValueList.h"
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class LLDB_API SBFrame {
 public:
   SBFrame();
 
   SBFrame(const lldb::SBFrame &rhs);
 
public:
   /// target's default.
   lldb::SBValue FindValue(const char *name, ValueType value_type);
 
   lldb::SBValue FindValue(const char *name, ValueType value_type,
                           lldb::DynamicValueType use_dynamic);
 
   bool GetDescription(lldb::SBStream &description);
 
-#ifndef SWIG
-  SBFrame(const lldb::StackFrameSP &lldb_object_sp);
-#endif
-
 protected:
   friend class SBBlock;
   friend class SBExecutionContext;
   friend class SBInstruction;
   friend class SBThread;
   friend class SBValue;
 
+  friend class lldb_private::python::SWIGBridge;
+
+  SBFrame(const lldb::StackFrameSP &lldb_object_sp);
+
   lldb::StackFrameSP GetFrameSP() const;
 
   void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp);
 
   lldb::ExecutionContextRefSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBFRAME_H

lldb/include/lldb/API/SBProcess.h

 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBProcessInfo.h"
 #include "lldb/API/SBQueue.h"
 #include "lldb/API/SBTarget.h"
 #include <cstdio>
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class SBEvent;
 
 class LLDB_API SBProcess {
 public:
   /// Broadcaster event bits definitions.
   FLAGS_ANONYMOUS_ENUM(){eBroadcastBitStateChanged = (1 << 0),
                          eBroadcastBitInterrupt = (1 << 1),
                          eBroadcastBitSTDOUT = (1 << 2),
                          eBroadcastBitSTDERR = (1 << 3),
                          eBroadcastBitProfileData = (1 << 4),
                          eBroadcastBitStructuredData = (1 << 5)};
 
   SBProcess();
 
   SBProcess(const lldb::SBProcess &rhs);
 
   const lldb::SBProcess &operator=(const lldb::SBProcess &rhs);
 
-#ifndef SWIG
-  SBProcess(const lldb::ProcessSP &process_sp);
-#endif
-
   ~SBProcess();
 
   static const char *GetBroadcasterClassName();
 
   const char *GetPluginName();
 
   // DEPRECATED: use GetPluginName()
   const char *GetShortPluginName();
#endif
   ///
   lldb::SBError DeallocateMemory(lldb::addr_t ptr);
 
   lldb::ScriptedObject GetScriptedImplementation();
 
 protected:
   friend class SBAddress;
   friend class SBBreakpoint;
+  friend class SBBreakpointCallbackBaton;
   friend class SBBreakpointLocation;
   friend class SBCommandInterpreter;
   friend class SBDebugger;
   friend class SBExecutionContext;
   friend class SBFunction;
   friend class SBModule;
   friend class SBTarget;
   friend class SBThread;
   friend class SBValue;
   friend class lldb_private::QueueImpl;
 
+  friend class lldb_private::python::SWIGBridge;
+
+  SBProcess(const lldb::ProcessSP &process_sp);
+
   lldb::ProcessSP GetSP() const;
 
   void SetSP(const lldb::ProcessSP &process_sp);
 
   lldb::ProcessWP m_opaque_wp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBPROCESS_H

lldb/include/lldb/API/SBQueue.h

 #include "lldb/lldb-forward.h"
 
 namespace lldb {
 
 class LLDB_API SBQueue {
 public:
   SBQueue();
 
-  SBQueue(const QueueSP &queue_sp);
-
   SBQueue(const SBQueue &rhs);
 
   const SBQueue &operator=(const lldb::SBQueue &rhs);
 
   ~SBQueue();
 
   explicit operator bool() const;
 
public:
   uint32_t GetNumRunningItems();
 
   lldb::QueueKind GetKind();
 
 protected:
   friend class SBProcess;
   friend class SBThread;
 
+  SBQueue(const QueueSP &queue_sp);
+
   void SetQueue(const lldb::QueueSP &queue_sp);
 
 private:
   std::shared_ptr<lldb_private::QueueImpl> m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBQUEUE_H

lldb/include/lldb/API/SBQueueItem.h

 //===-- SBQueueItem.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_SBQUEUEITEM_H
 #define LLDB_API_SBQUEUEITEM_H
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+class QueueImpl;
+}
+
 namespace lldb {
 
 class LLDB_API SBQueueItem {
 public:
   SBQueueItem();
 
-  SBQueueItem(const lldb::QueueItemSP &queue_item_sp);
-
   ~SBQueueItem();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   void Clear();
 
   lldb::QueueItemKind GetKind() const;
 
   void SetKind(lldb::QueueItemKind kind);
 
   lldb::SBAddress GetAddress() const;
 
   void SetAddress(lldb::SBAddress addr);
 
-  void SetQueueItem(const lldb::QueueItemSP &queue_item_sp);
-
   SBThread GetExtendedBacktraceThread(const char *type);
 
+protected:
+  friend class lldb_private::QueueImpl;
+
+  SBQueueItem(const lldb::QueueItemSP &queue_item_sp);
+
+  void SetQueueItem(const lldb::QueueItemSP &queue_item_sp);
+
 private:
   lldb::QueueItemSP m_queue_item_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBQUEUEITEM_H

lldb/include/lldb/API/SBStructuredData.h

 //===-- SBStructuredData.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_SBSTRUCTUREDDATA_H
 #define LLDB_API_SBSTRUCTUREDDATA_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class SBStructuredData {
 public:
   SBStructuredData();
 
   SBStructuredData(const lldb::SBStructuredData &rhs);
 
-  SBStructuredData(const lldb::EventSP &event_sp);
-
-#ifndef SWIG
-  SBStructuredData(const lldb_private::StructuredDataImpl &impl);
-#endif
-
   ~SBStructuredData();
 
   lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
protected:
   friend class SBTarget;
   friend class SBProcess;
   friend class SBThread;
   friend class SBThreadPlan;
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
   friend class SBTrace;
+  friend class lldb_private::python::SWIGBridge;
+
+  SBStructuredData(const lldb_private::StructuredDataImpl &impl);
+
+  SBStructuredData(const lldb::EventSP &event_sp);
 
   StructuredDataImplUP m_impl_up;
 };
 } // namespace lldb
 
 #endif // LLDB_API_SBSTRUCTUREDDATA_H

lldb/include/lldb/API/SBSymbolContext.h

 #include "lldb/API/SBBlock.h"
 #include "lldb/API/SBCompileUnit.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBSymbol.h"
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class LLDB_API SBSymbolContext {
 public:
   SBSymbolContext();
 
   SBSymbolContext(const lldb::SBSymbolContext &rhs);
 
-#ifndef SWIG
-  SBSymbolContext(const lldb_private::SymbolContext &sc_ptr);
-#endif
-
   ~SBSymbolContext();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   const lldb::SBSymbolContext &operator=(const lldb::SBSymbolContext &rhs);
 

 protected:
   friend class SBAddress;
   friend class SBFrame;
   friend class SBModule;
   friend class SBThread;
   friend class SBTarget;
   friend class SBSymbolContextList;
 
+  friend class lldb_private::python::SWIGBridge;
+
+  SBSymbolContext(const lldb_private::SymbolContext &sc_ptr);
+
   lldb_private::SymbolContext *operator->() const;
 
   lldb_private::SymbolContext &operator*();
 
   lldb_private::SymbolContext &ref();
 
   const lldb_private::SymbolContext &operator*() const;
 

lldb/include/lldb/API/SBTarget.h

 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBSymbolContextList.h"
 #include "lldb/API/SBType.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/API/SBWatchpoint.h"
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class SBPlatform;
 
 class LLDB_API SBTarget {
 public:
   // Broadcaster bits.
   enum {
     eBroadcastBitBreakpointChanged = (1 << 0),
     eBroadcastBitModulesLoaded = (1 << 1),
     eBroadcastBitModulesUnloaded = (1 << 2),
     eBroadcastBitWatchpointChanged = (1 << 3),
     eBroadcastBitSymbolsLoaded = (1 << 4)
   };
 
   // Constructors
   SBTarget();
 
   SBTarget(const lldb::SBTarget &rhs);
 
-#ifndef SWIG
-  SBTarget(const lldb::TargetSP &target_sp);
-#endif
-
   // Destructor
   ~SBTarget();
 
   const lldb::SBTarget &operator=(const lldb::SBTarget &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;
#endif
   ///
   /// \param[out] error
   ///     An error if a Trace already exists or the trace couldn't be created.
   lldb::SBTrace CreateTrace(SBError &error);
 
 protected:
   friend class SBAddress;
   friend class SBBlock;
+  friend class SBBreakpoint;
   friend class SBBreakpointList;
   friend class SBBreakpointNameImpl;
   friend class SBDebugger;
   friend class SBExecutionContext;
+  friend class SBFrame;
   friend class SBFunction;
   friend class SBInstruction;
   friend class SBModule;
   friend class SBPlatform;
   friend class SBProcess;
   friend class SBSection;
   friend class SBSourceManager;
   friend class SBSymbol;
   friend class SBValue;
   friend class SBVariablesOptions;
 
+  friend class lldb_private::python::SWIGBridge;
+
   // Constructors are private, use static Target::Create function to create an
   // instance of this class.
 
+  SBTarget(const lldb::TargetSP &target_sp);
+
   lldb::TargetSP GetSP() const;
 
   void SetSP(const lldb::TargetSP &target_sp);
 
 private:
   lldb::TargetSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBTARGET_H

lldb/include/lldb/API/SBThread.h

 //===-- SBThread.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_SBTHREAD_H
 #define LLDB_API_SBTHREAD_H
 
 #include "lldb/API/SBDefines.h"
 
 #include <cstdio>
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class SBFrame;
 
 class LLDB_API SBThread {
 public:
   enum {
     eBroadcastBitStackChanged = (1 << 0),
     eBroadcastBitThreadSuspended = (1 << 1),
     eBroadcastBitThreadResumed = (1 << 2),
     eBroadcastBitSelectedFrameChanged = (1 << 3),
     eBroadcastBitThreadSelected = (1 << 4)
   };
 
   static const char *GetBroadcasterClassName();
 
   SBThread();
 
   SBThread(const lldb::SBThread &thread);
 
-#ifndef SWIG
-  SBThread(const lldb::ThreadSP &lldb_object_sp);
-#endif
-
   ~SBThread();
 
   lldb::SBQueue GetQueue() const;
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
private:
   friend class SBBreakpointCallbackBaton;
   friend class SBExecutionContext;
   friend class SBFrame;
   friend class SBProcess;
   friend class SBDebugger;
   friend class SBValue;
   friend class lldb_private::QueueImpl;
   friend class SBQueueItem;
+  friend class SBThreadCollection;
   friend class SBThreadPlan;
   friend class SBTrace;
 
+  friend class lldb_private::python::SWIGBridge;
+
+  SBThread(const lldb::ThreadSP &lldb_object_sp);
+
   void SetThread(const lldb::ThreadSP &lldb_object_sp);
 
   SBError ResumeNewPlan(lldb_private::ExecutionContext &exe_ctx,
                         lldb_private::ThreadPlan *new_plan);
 
   lldb::ExecutionContextRefSP m_opaque_sp;
 
   lldb_private::Thread *operator->();
 
   lldb_private::Thread *get();
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBTHREAD_H

lldb/include/lldb/API/SBThreadPlan.h

 //===-- SBThreadPlan.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_SBTHREADPLAN_H
 #define LLDB_API_SBTHREADPLAN_H
 
 #include "lldb/API/SBDefines.h"
 
 #include <cstdio>
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class LLDB_API SBThreadPlan {
 
 public:
   SBThreadPlan();
 
   SBThreadPlan(const lldb::SBThreadPlan &threadPlan);
 
-  SBThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
-
   SBThreadPlan(lldb::SBThread &thread, const char *class_name);
 
   SBThreadPlan(lldb::SBThread &thread, const char *class_name, 
                lldb::SBStructuredData &args_data);
 
   ~SBThreadPlan();
 
   explicit operator bool() const;
public:
 
   SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name);
   SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
                                               SBError &error);
   SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
                                               lldb::SBStructuredData &args_data,
                                               SBError &error);
 
+protected:
+  friend class lldb_private::python::SWIGBridge;
+
+  SBThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
+
 private:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBFrame;
   friend class SBProcess;
   friend class SBDebugger;
   friend class SBValue;
   friend class lldb_private::QueueImpl;

lldb/include/lldb/API/SBTrace.h

 
 namespace lldb {
 
 class LLDB_API SBTrace {
 public:
   /// Default constructor for an invalid Trace object.
   SBTrace();
 
-#ifndef SWIG
-  SBTrace(const lldb::TraceSP &trace_sp);
-#endif
-
   /// See SBDebugger::LoadTraceFromFile.
   static SBTrace LoadTraceFromFile(SBError &error, SBDebugger &debugger,
                                    const SBFileSpec &trace_description_file);
 
   /// Get a \a TraceCursor for the given thread's trace.
   ///
   /// \param[out] error
   ///   This will be set with an error in case of failures.
public:
   ///     An error explaining any failures.
   SBError Stop(const SBThread &thread);
 
   explicit operator bool() const;
 
   bool IsValid();
 
 protected:
+  friend class SBTarget;
+
+  SBTrace(const lldb::TraceSP &trace_sp);
+
   lldb::TraceSP m_opaque_sp;
   /// deprecated
   lldb::ProcessWP m_opaque_wp;
 };
 } // namespace lldb
 
 #endif // LLDB_API_SBTRACE_H

lldb/include/lldb/API/SBTraceCursor.h

 
 namespace lldb {
 
 class LLDB_API SBTraceCursor {
 public:
   /// Default constructor for an invalid \a SBTraceCursor object.
   SBTraceCursor();
 
-  /// Create a cursor that initially points to the end of the trace, i.e. the
-  /// most recent item.
-  SBTraceCursor(lldb::TraceCursorSP trace_cursor_sp);
-
   /// Set the direction to use in the \a SBTraceCursor::Next() method.
   ///
   /// \param[in] forwards
   ///     If \b true, then the traversal will be forwards, otherwise backwards.
   void SetForwards(bool forwards);
 
   /// Check if the direction to use in the \a SBTraceCursor::Next() method is
   /// forwards.
public:
   ///    not available for the current item.
   lldb::cpu_id_t GetCPU() const;
 
   bool IsValid() const;
 
   explicit operator bool() const;
 
 protected:
+  friend class SBTrace;
+
+  /// Create a cursor that initially points to the end of the trace, i.e. the
+  /// most recent item.
+  SBTraceCursor(lldb::TraceCursorSP trace_cursor_sp);
+
   lldb::TraceCursorSP m_opaque_sp;
 };
 } // namespace lldb
 
 #endif // LLDB_API_SBTRACECURSOR_H

lldb/include/lldb/API/SBType.h

 //===-- SBType.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_SBTYPE_H
 #define LLDB_API_SBTYPE_H
 
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class SBTypeList;
 
 class LLDB_API SBTypeMember {
 public:
   SBTypeMember();
 
protected:
   lldb::TypeMemberFunctionImplSP m_opaque_sp;
 };
 
 class SBType {
 public:
   SBType();
 
   SBType(const lldb::SBType &rhs);
-#ifndef SWIG
-  SBType(const lldb::TypeImplSP &);
-#endif
 
   ~SBType();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   uint64_t GetByteSize();
protected:
   friend class SBTypeEnumMemberList;
   friend class SBTypeNameSpecifier;
   friend class SBTypeMember;
   friend class SBTypeMemberFunction;
   friend class SBTypeList;
   friend class SBValue;
   friend class SBWatchpoint;
 
+  friend class lldb_private::python::SWIGBridge;
+
   SBType(const lldb_private::CompilerType &);
   SBType(const lldb::TypeSP &);
+  SBType(const lldb::TypeImplSP &);
 };
 
 class SBTypeList {
 public:
   SBTypeList();
 
   SBTypeList(const lldb::SBTypeList &rhs);
 

lldb/include/lldb/API/SBTypeSummary.h

 //===-- SBTypeSummary.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_SBTYPESUMMARY_H
 #define LLDB_API_SBTYPESUMMARY_H
 
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 class LLDB_API SBTypeSummaryOptions {
 public:
   SBTypeSummaryOptions();
 
   SBTypeSummaryOptions(const lldb::SBTypeSummaryOptions &rhs);
 
-#ifndef SWIG
-  SBTypeSummaryOptions(const lldb_private::TypeSummaryOptions &lldb_object);
-#endif
 
   ~SBTypeSummaryOptions();
 
   explicit operator bool() const;
 
   bool IsValid();
 
   lldb::LanguageType GetLanguage();
 
   lldb::TypeSummaryCapping GetCapping();
 
   void SetLanguage(lldb::LanguageType);
 
   void SetCapping(lldb::TypeSummaryCapping);
 
 protected:
   friend class SBValue;
+  friend class SBTypeSummary;
+
+  friend class lldb_private::python::SWIGBridge;
+
+  SBTypeSummaryOptions(const lldb_private::TypeSummaryOptions &lldb_object);
 
   lldb_private::TypeSummaryOptions *operator->();
 
   const lldb_private::TypeSummaryOptions *operator->() const;
 
   lldb_private::TypeSummaryOptions *get();
 
   lldb_private::TypeSummaryOptions &ref();

lldb/include/lldb/API/SBValue.h

 
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBType.h"
 
 class ValueImpl;
 class ValueLocker;
 
+namespace lldb_private {
+namespace python {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class LLDB_API SBValue {
 public:
   SBValue();
 
   SBValue(const lldb::SBValue &rhs);
 
public:
 
   lldb::SBValue EvaluateExpression(const char *expr) const;
   lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options) const;
   lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options,
                                    const char *name) const;
 
-#ifndef SWIG
-  SBValue(const lldb::ValueObjectSP &value_sp);
-#endif
-
   /// Watch this value if it resides in memory.
   ///
   /// Sets a watchpoint on the value.
   ///
   /// \param[in] resolve_location
   ///     Resolve the location of this value once and watch its address.
   ///     This value must currently be set to \b true as watching all
   ///     locations of a variable or a variable path is not yet supported,
public:
   /// \return
   ///     An SBWatchpoint object. This object might not be valid upon
   ///     return due to a value not being contained in memory, too
   ///     large, or watchpoint resources are not available or all in
   ///     use.
   lldb::SBWatchpoint WatchPointee(bool resolve_location, bool read, bool write,
                                   SBError &error);
 
-#ifndef SWIG
+protected:
+  friend class SBBlock;
+  friend class SBFrame;
+  friend class SBModule;
+  friend class SBTarget;
+  friend class SBThread;
+  friend class SBTypeSummary;
+  friend class SBValueList;
+
+  friend class lldb_private::python::SWIGBridge;
+
+  SBValue(const lldb::ValueObjectSP &value_sp);
+
   /// Same as the protected version of GetSP that takes a locker, except that we
   /// make the
   /// locker locally in the function.  Since the Target API mutex is recursive,
   /// and the
   /// StopLocker is a read lock, you can call this function even if you are
   /// already
   /// holding the two above-mentioned locks.
   ///
   /// \return
   ///     A ValueObjectSP of the best kind (static, dynamic or synthetic) we
   ///     can cons up, in accordance with the SBValue's settings.
   lldb::ValueObjectSP GetSP() const;
-#endif
-
-protected:
-  friend class SBBlock;
-  friend class SBFrame;
-  friend class SBTarget;
-  friend class SBThread;
-  friend class SBValueList;
 
   /// Get the appropriate ValueObjectSP from this SBValue, consulting the
   /// use_dynamic and use_synthetic options passed in to SetSP when the
   /// SBValue's contents were set.  Since this often requires examining memory,
   /// and maybe even running code, it needs to acquire the Target API and
   /// Process StopLock.
   /// Those are held in an opaque class ValueLocker which is currently local to
   /// SBValue.cpp.

lldb/include/lldb/API/SBWatchpoint.h

 //===-- SBWatchpoint.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_SBWATCHPOINT_H
 #define LLDB_API_SBWATCHPOINT_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBType.h"
 
+namespace lldb_private {
+namespace ptyhon {
+class SWIGBridge;
+}
+} // namespace lldb_private
+
 namespace lldb {
 
 class LLDB_API SBWatchpoint {
 public:
   SBWatchpoint();
 
   SBWatchpoint(const lldb::SBWatchpoint &rhs);
 
-#ifndef SWIG
-  SBWatchpoint(const lldb::WatchpointSP &wp_sp);
-#endif
-
   ~SBWatchpoint();
 
   const lldb::SBWatchpoint &operator=(const lldb::SBWatchpoint &rhs);
 
   explicit operator bool() const;
 
   bool operator==(const SBWatchpoint &rhs) const;
 
public:
   const char *GetCondition();
 
   void SetCondition(const char *condition);
 
   bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
 
   void Clear();
 
-#ifndef SWIG
-  lldb::WatchpointSP GetSP() const;
-
-  void SetSP(const lldb::WatchpointSP &sp);
-#endif
-
   static bool EventIsWatchpointEvent(const lldb::SBEvent &event);
 
   static lldb::WatchpointEventType
   GetWatchpointEventTypeFromEvent(const lldb::SBEvent &event);
 
   static lldb::SBWatchpoint GetWatchpointFromEvent(const lldb::SBEvent &event);
 
   lldb::SBType GetType();
 
   WatchpointValueKind GetWatchValueKind();
 
   const char *GetWatchSpec();
 
   bool IsWatchingReads();
 
   bool IsWatchingWrites();
 
+protected:
+  friend class lldb_private::python::SWIGBridge;
+
+  SBWatchpoint(const lldb::WatchpointSP &wp_sp);
+
+  lldb::WatchpointSP GetSP() const;
+
+  void SetSP(const lldb::WatchpointSP &sp);
+
 private:
   friend class SBTarget;
   friend class SBValue;
 
   std::weak_ptr<lldb_private::Watchpoint> m_opaque_wp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBWATCHPOINT_H

lldb/source/API/SBCommandInterpreter.cpp

 #include "lldb/API/SBTarget.h"
 
 #include <memory>
 #include <optional>
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace lldb_private {
 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,
                                        const char *auto_repeat_command = "")
else
       return m_auto_repeat_command;
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     SBCommandReturnObject sb_return(result);
     SBCommandInterpreter sb_interpreter(&m_interpreter);
     SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
-    bool ret = m_backend->DoExecute(
-        debugger_sb, command.GetArgumentVector(), sb_return);
+    bool ret = m_backend->DoExecute(debugger_sb, command.GetArgumentVector(),
+                                    sb_return);
     return ret;
   }
   std::shared_ptr<lldb::SBCommandPluginInterface> m_backend;
   std::optional<std::string> m_auto_repeat_command;
 };
+} // namespace lldb_private
 
 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
     : m_opaque_ptr(interpreter) {
   LLDB_INSTRUMENT_VA(this, interpreter);
 }
 
 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
     : m_opaque_ptr(rhs.m_opaque_ptr) {

lldb/source/API/SBDebugger.cpp

 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
-                                            const FileSpec &spec,
-                                            Status &error) {
-  llvm::sys::DynamicLibrary dynlib =
-      llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
-  if (dynlib.isValid()) {
-    typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
-
-    lldb::SBDebugger debugger_sb(debugger_sp);
-    // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
-    // function.
-    // TODO: mangle this differently for your system - on OSX, the first
-    // underscore needs to be removed and the second one stays
-    LLDBCommandPluginInit init_func =
-        (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol(
-            "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
-    if (init_func) {
-      if (init_func(debugger_sb))
-        return dynlib;
-      else
-        error.SetErrorString("plug-in refused to load "
-                             "(lldb::PluginInitialize(lldb::SBDebugger) "
-                             "returned false)");
-    } else {
-      error.SetErrorString("plug-in is missing the required initialization: "
-                           "lldb::PluginInitialize(lldb::SBDebugger)");
-    }
-  } else {
-    if (FileSystem::Instance().Exists(spec))
-      error.SetErrorString("this file does not represent a loadable dylib");
-    else
-      error.SetErrorString("no such file");
-  }
-  return llvm::sys::DynamicLibrary();
-}
-
 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
 
 SBError SBInputReader::Initialize(
     lldb::SBDebugger &sb_debugger,
     unsigned long (*callback)(void *, lldb::SBInputReader *,
                               lldb::InputReaderAction, char const *,
                               unsigned long),
     void *a, lldb::InputReaderGranularity b, char const *c, char const *d,

 void SBDebugger::Initialize() {
   LLDB_INSTRUMENT();
   SBError ignored = SBDebugger::InitializeWithErrorHandling();
 }
 
 lldb::SBError SBDebugger::InitializeWithErrorHandling() {
   LLDB_INSTRUMENT();
 
+  auto LoadPlugin = [](const lldb::DebuggerSP &debugger_sp,
+                       const FileSpec &spec,
+                       Status &error) -> llvm::sys::DynamicLibrary {
+    llvm::sys::DynamicLibrary dynlib =
+        llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
+    if (dynlib.isValid()) {
+      typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
+
+      lldb::SBDebugger debugger_sb(debugger_sp);
+      // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
+      // function.
+      // TODO: mangle this differently for your system - on OSX, the first
+      // underscore needs to be removed and the second one stays
+      LLDBCommandPluginInit init_func =
+          (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol(
+              "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
+      if (init_func) {
+        if (init_func(debugger_sb))
+          return dynlib;
+        else
+          error.SetErrorString("plug-in refused to load "
+                               "(lldb::PluginInitialize(lldb::SBDebugger) "
+                               "returned false)");
+      } else {
+        error.SetErrorString("plug-in is missing the required initialization: "
+                             "lldb::PluginInitialize(lldb::SBDebugger)");
+      }
+    } else {
+      if (FileSystem::Instance().Exists(spec))
+        error.SetErrorString("this file does not represent a loadable dylib");
+      else
+        error.SetErrorString("no such file");
+    }
+    return llvm::sys::DynamicLibrary();
+  };
+
   SBError error;
   if (auto e = g_debugger_lifetime->Initialize(
           std::make_unique<SystemInitializerFull>(), LoadPlugin)) {
     error.SetError(Status(std::move(e)));
   }
   return error;
 }
 

lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h

public:
   ScopedPythonObject &operator=(ScopedPythonObject &&) = delete;
 
   const PythonObject &obj() const { return *this; }
 
 private:
   T *m_sb;
 };
 
-PythonObject ToSWIGWrapper(lldb::ValueObjectSP value_sp);
-PythonObject ToSWIGWrapper(lldb::TargetSP target_sp);
-PythonObject ToSWIGWrapper(lldb::ProcessSP process_sp);
-PythonObject ToSWIGWrapper(lldb::ThreadPlanSP thread_plan_sp);
-PythonObject ToSWIGWrapper(lldb::BreakpointSP breakpoint_sp);
-PythonObject ToSWIGWrapper(const Status &status);
-PythonObject ToSWIGWrapper(const StructuredDataImpl &data_impl);
-PythonObject ToSWIGWrapper(lldb::ThreadSP thread_sp);
-PythonObject ToSWIGWrapper(lldb::StackFrameSP frame_sp);
-PythonObject ToSWIGWrapper(lldb::DebuggerSP debugger_sp);
-PythonObject ToSWIGWrapper(lldb::WatchpointSP watchpoint_sp);
-PythonObject ToSWIGWrapper(lldb::BreakpointLocationSP bp_loc_sp);
-PythonObject ToSWIGWrapper(lldb::ExecutionContextRefSP ctx_sp);
-PythonObject ToSWIGWrapper(const TypeSummaryOptions &summary_options);
-PythonObject ToSWIGWrapper(const SymbolContext &sym_ctx);
-
-PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp);
-PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp);
-PythonObject ToSWIGWrapper(lldb::DataExtractorSP data_extractor_sp);
-
-PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBValue> value_sb);
-PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStream> stream_sb);
-PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb);
+class SWIGBridge {
+public:
+  static PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBValue> value_sb);
+  static PythonObject ToSWIGWrapper(lldb::ValueObjectSP value_sp);
+  static PythonObject ToSWIGWrapper(lldb::TargetSP target_sp);
+  static PythonObject ToSWIGWrapper(lldb::ProcessSP process_sp);
+  static PythonObject ToSWIGWrapper(lldb::ThreadPlanSP thread_plan_sp);
+  static PythonObject ToSWIGWrapper(lldb::BreakpointSP breakpoint_sp);
+  static PythonObject ToSWIGWrapper(const Status &status);
+  static PythonObject ToSWIGWrapper(const StructuredDataImpl &data_impl);
+  static PythonObject ToSWIGWrapper(lldb::ThreadSP thread_sp);
+  static PythonObject ToSWIGWrapper(lldb::StackFrameSP frame_sp);
+  static PythonObject ToSWIGWrapper(lldb::DebuggerSP debugger_sp);
+  static PythonObject ToSWIGWrapper(lldb::WatchpointSP watchpoint_sp);
+  static PythonObject ToSWIGWrapper(lldb::BreakpointLocationSP bp_loc_sp);
+  static PythonObject ToSWIGWrapper(lldb::TypeImplSP type_impl_sp);
+  static PythonObject ToSWIGWrapper(lldb::ExecutionContextRefSP ctx_sp);
+  static PythonObject ToSWIGWrapper(const TypeSummaryOptions &summary_options);
+  static PythonObject ToSWIGWrapper(const SymbolContext &sym_ctx);
+
+  static PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp);
+  static PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp);
+  static PythonObject ToSWIGWrapper(lldb::DataExtractorSP data_extractor_sp);
+
+  static PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStream> stream_sb);
+  static PythonObject
+  ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb);
 
-python::ScopedPythonObject<lldb::SBCommandReturnObject>
+  static python::ScopedPythonObject<lldb::SBCommandReturnObject>
   ToSWIGWrapper(CommandReturnObject &cmd_retobj);
-python::ScopedPythonObject<lldb::SBEvent> ToSWIGWrapper(Event *event);
-
-} // namespace python
+  static python::ScopedPythonObject<lldb::SBEvent> ToSWIGWrapper(Event *event);
+  // These prototypes are the Pythonic implementations of the required
+  // callbacks. Although these are scripting-language specific, their definition
+  // depends on the public API.
 
-void *LLDBSWIGPython_CastPyObjectToSBData(PyObject *data);
-void *LLDBSWIGPython_CastPyObjectToSBBreakpoint(PyObject *data);
-void *LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject *data);
-void *LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data);
-void *LLDBSWIGPython_CastPyObjectToSBError(PyObject *data);
-void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data);
-void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data);
-
-// These prototypes are the Pythonic implementations of the required callbacks.
-// Although these are scripting-language specific, their definition depends on
-// the public API.
-
-python::PythonObject LLDBSwigPythonCreateScriptedObject(
+  static python::PythonObject LLDBSwigPythonCreateScriptedObject(
       const char *python_class_name, const char *session_dictionary_name,
       lldb::ExecutionContextRefSP exe_ctx_sp,
       const lldb_private::StructuredDataImpl &args_impl,
       std::string &error_string);
 
-llvm::Expected<bool> LLDBSwigPythonBreakpointCallbackFunction(
+  static llvm::Expected<bool> LLDBSwigPythonBreakpointCallbackFunction(
       const char *python_function_name, const char *session_dictionary_name,
       const lldb::StackFrameSP &sb_frame,
       const lldb::BreakpointLocationSP &sb_bp_loc,
       const lldb_private::StructuredDataImpl &args_impl);
 
-bool LLDBSwigPythonWatchpointCallbackFunction(
+  static bool LLDBSwigPythonWatchpointCallbackFunction(
       const char *python_function_name, const char *session_dictionary_name,
       const lldb::StackFrameSP &sb_frame, const lldb::WatchpointSP &sb_wp);
 
-bool LLDBSwigPythonFormatterCallbackFunction(
-    const char *python_function_name, const char *session_dictionary_name,
+  static bool
+  LLDBSwigPythonFormatterCallbackFunction(const char *python_function_name,
+                                          const char *session_dictionary_name,
                                           lldb::TypeImplSP type_impl_sp);
 
-bool LLDBSwigPythonCallTypeScript(const char *python_function_name,
-                                  const void *session_dictionary,
-                                  const lldb::ValueObjectSP &valobj_sp,
-                                  void **pyfunct_wrapper,
-                                  const lldb::TypeSummaryOptionsSP &options_sp,
-                                  std::string &retval);
+  static bool LLDBSwigPythonCallTypeScript(
+      const char *python_function_name, const void *session_dictionary,
+      const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
+      const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval);
 
-python::PythonObject
+  static python::PythonObject
   LLDBSwigPythonCreateSyntheticProvider(const char *python_class_name,
                                         const char *session_dictionary_name,
                                         const lldb::ValueObjectSP &valobj_sp);
 
-python::PythonObject
+  static python::PythonObject
   LLDBSwigPythonCreateCommandObject(const char *python_class_name,
                                     const char *session_dictionary_name,
                                     lldb::DebuggerSP debugger_sp);
 
-python::PythonObject LLDBSwigPythonCreateScriptedThreadPlan(
+  static python::PythonObject LLDBSwigPythonCreateScriptedThreadPlan(
       const char *python_class_name, const char *session_dictionary_name,
       const StructuredDataImpl &args_data, std::string &error_string,
       const lldb::ThreadPlanSP &thread_plan_sp);
 
-bool LLDBSWIGPythonCallThreadPlan(void *implementor, const char *method_name,
+  static bool LLDBSWIGPythonCallThreadPlan(void *implementor,
+                                           const char *method_name,
                                            lldb_private::Event *event_sp,
                                            bool &got_error);
-                                  
-bool LLDBSWIGPythonCallThreadPlan(void *implementor, 
+  static bool LLDBSWIGPythonCallThreadPlan(void *implementor,
                                            const char *method_name,
                                            lldb_private::Stream *stream,
                                            bool &got_error);
 
-python::PythonObject LLDBSwigPythonCreateScriptedBreakpointResolver(
+  static python::PythonObject LLDBSwigPythonCreateScriptedBreakpointResolver(
       const char *python_class_name, const char *session_dictionary_name,
       const StructuredDataImpl &args, const lldb::BreakpointSP &bkpt_sp);
 
-unsigned int
-LLDBSwigPythonCallBreakpointResolver(void *implementor, const char *method_name,
+  static unsigned int
+  LLDBSwigPythonCallBreakpointResolver(void *implementor,
+                                       const char *method_name,
                                        lldb_private::SymbolContext *sym_ctx);
 
-python::PythonObject LLDBSwigPythonCreateScriptedStopHook(
+  static python::PythonObject LLDBSwigPythonCreateScriptedStopHook(
       lldb::TargetSP target_sp, const char *python_class_name,
       const char *session_dictionary_name, const StructuredDataImpl &args,
       lldb_private::Status &error);
 
-bool LLDBSwigPythonStopHookCallHandleStop(void *implementor,
-                                          lldb::ExecutionContextRefSP exc_ctx,
-                                          lldb::StreamSP stream);
+  static bool
+  LLDBSwigPythonStopHookCallHandleStop(void *implementor,
 
-size_t LLDBSwigPython_CalculateNumChildren(PyObject *implementor, uint32_t max);
+  static size_t LLDBSwigPython_CalculateNumChildren(PyObject *implementor,
+                                                    uint32_t max);
 
-PyObject *LLDBSwigPython_GetChildAtIndex(PyObject *implementor, uint32_t idx);
+  static PyObject *LLDBSwigPython_GetChildAtIndex(PyObject *implementor,
+                                                  uint32_t idx);
 
-int LLDBSwigPython_GetIndexOfChildWithName(PyObject *implementor,
+  static int LLDBSwigPython_GetIndexOfChildWithName(PyObject *implementor,
                                                     const char *child_name);
 
-lldb::ValueObjectSP LLDBSWIGPython_GetValueObjectSPFromSBValue(void *data);
+  static lldb::ValueObjectSP
+  LLDBSWIGPython_GetValueObjectSPFromSBValue(void *data);
 
-bool LLDBSwigPython_UpdateSynthProviderInstance(PyObject *implementor);
+  static bool LLDBSwigPython_UpdateSynthProviderInstance(PyObject *implementor);
 
-bool LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
-    PyObject *implementor);
+  static bool
+  LLDBSwigPython_MightHaveChildrenSynthProviderInstance(PyObject *implementor);
 
-PyObject *LLDBSwigPython_GetValueSynthProviderInstance(PyObject *implementor);
+  static PyObject *
+  LLDBSwigPython_GetValueSynthProviderInstance(PyObject *implementor);
 
-bool LLDBSwigPythonCallCommand(const char *python_function_name,
-                               const char *session_dictionary_name,
-                               lldb::DebuggerSP debugger, const char *args,
-                               lldb_private::CommandReturnObject &cmd_retobj,
-                               lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+  static bool
+  LLDBSwigPythonCallCommand(const char *python_function_name,
 
-bool LLDBSwigPythonCallCommandObject(
-    PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
+  static bool
+  LLDBSwigPythonCallCommandObject(PyObject *implementor,
+                                  lldb::DebuggerSP debugger, const char *args,
                                   lldb_private::CommandReturnObject &cmd_retobj,
                                   lldb::ExecutionContextRefSP exe_ctx_ref_sp);
 
-bool LLDBSwigPythonCallModuleInit(const char *python_module_name,
+  static bool LLDBSwigPythonCallModuleInit(const char *python_module_name,
                                            const char *session_dictionary_name,
                                            lldb::DebuggerSP debugger);
 
-python::PythonObject
+  static python::PythonObject
   LLDBSWIGPythonCreateOSPlugin(const char *python_class_name,
                                const char *session_dictionary_name,
                                const lldb::ProcessSP &process_sp);
 
-python::PythonObject
+  static python::PythonObject
   LLDBSWIGPython_CreateFrameRecognizer(const char *python_class_name,
                                        const char *session_dictionary_name);
 
-PyObject *
+  static PyObject *
   LLDBSwigPython_GetRecognizedArguments(PyObject *implementor,
                                         const lldb::StackFrameSP &frame_sp);
 
-bool LLDBSWIGPythonRunScriptKeywordProcess(const char *python_function_name,
-                                           const char *session_dictionary_name,
-                                           const lldb::ProcessSP &process,
-                                           std::string &output);
+  static bool LLDBSWIGPythonRunScriptKeywordProcess(
+      const char *python_function_name, const char *session_dictionary_name,
+      const lldb::ProcessSP &process, std::string &output);
 
-std::optional<std::string>
+  static std::optional<std::string>
   LLDBSWIGPythonRunScriptKeywordThread(const char *python_function_name,
                                        const char *session_dictionary_name,
                                        lldb::ThreadSP thread);
 
-bool LLDBSWIGPythonRunScriptKeywordTarget(const char *python_function_name,
-                                          const char *session_dictionary_name,
-                                          const lldb::TargetSP &target,
-                                          std::string &output);
+  static bool LLDBSWIGPythonRunScriptKeywordTarget(
+      const char *python_function_name, const char *session_dictionary_name,
+      const lldb::TargetSP &target, std::string &output);
 
-std::optional<std::string>
+  static std::optional<std::string>
   LLDBSWIGPythonRunScriptKeywordFrame(const char *python_function_name,
                                       const char *session_dictionary_name,
                                       lldb::StackFrameSP frame);
 
-bool LLDBSWIGPythonRunScriptKeywordValue(const char *python_function_name,
-                                         const char *session_dictionary_name,
-                                         const lldb::ValueObjectSP &value,
-                                         std::string &output);
+  static bool LLDBSWIGPythonRunScriptKeywordValue(
+      const char *python_function_name, const char *session_dictionary_name,
+      const lldb::ValueObjectSP &value, std::string &output);
 
-void *LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
-                                       const lldb::TargetSP &target_sp);
+  static void *
+  LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
+};
+
+} // namespace python
+
+void *LLDBSWIGPython_CastPyObjectToSBData(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBBreakpoint(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBError(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data);
 
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SWIGPYTHONBRIDGE_H

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

 }
 
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::CreateFrameRecognizer(const char *class_name) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
-  PythonObject ret_val = LLDBSWIGPython_CreateFrameRecognizer(
+  PythonObject ret_val = SWIGBridge::LLDBSWIGPython_CreateFrameRecognizer(
       class_name, m_dictionary_name.c_str());
 
   return StructuredData::GenericSP(
       new StructuredPythonObject(std::move(ret_val)));
 }
 
 lldb::ValueObjectListSP ScriptInterpreterPythonImpl::GetRecognizedArguments(
     const StructuredData::ObjectSP &os_plugin_object_sp,
     lldb::StackFrameSP frame_sp) {
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
   if (!os_plugin_object_sp)
     return ValueObjectListSP();
 
   StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
   if (!generic)
     return nullptr;
 
   PythonObject implementor(PyRefType::Borrowed,
                            (PyObject *)generic->GetValue());
 
   if (!implementor.IsAllocated())
     return ValueObjectListSP();
 
-  PythonObject py_return(
-      PyRefType::Owned,
-      LLDBSwigPython_GetRecognizedArguments(implementor.get(), frame_sp));
+  PythonObject py_return(PyRefType::Owned,
+                         SWIGBridge::LLDBSwigPython_GetRecognizedArguments(
+                             implementor.get(), frame_sp));
 
   // if it fails, print the error but otherwise go on
   if (PyErr_Occurred()) {
     PyErr_Print();
     PyErr_Clear();
   }
   if (py_return.get()) {
     PythonList result_list(PyRefType::Borrowed, py_return.get());
     ValueObjectListSP result = ValueObjectListSP(new ValueObjectList());
     for (size_t i = 0; i < result_list.GetSize(); i++) {
       PyObject *item = result_list.GetItemAtIndex(i).get();
       lldb::SBValue *sb_value_ptr =
           (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(item);
-      auto valobj_sp = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
+      auto valobj_sp =
+          SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
       if (valobj_sp)
         result->Append(valobj_sp);
     }
     return result;
   }
   return ValueObjectListSP();
 }
 
 ScriptedProcessInterfaceUP
 ScriptInterpreterPythonImpl::CreateScriptedProcessInterface() {
   return std::make_unique<ScriptedProcessPythonInterface>(*this);
 }
 
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::OSPlugin_CreatePluginObject(
     const char *class_name, lldb::ProcessSP process_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!process_sp)
     return StructuredData::GenericSP();
 
   Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
-  PythonObject ret_val = LLDBSWIGPythonCreateOSPlugin(
+  PythonObject ret_val = SWIGBridge::LLDBSWIGPythonCreateOSPlugin(
       class_name, m_dictionary_name.c_str(), process_sp);
 
   return StructuredData::GenericSP(
       new StructuredPythonObject(std::move(ret_val)));
 }
 
 StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_RegisterInfo(
     StructuredData::ObjectSP os_plugin_object_sp) {
StructuredData::ObjectSP ScriptInterpreterPythonImpl::CreateScriptedThreadPlan(
   ScriptInterpreterPythonImpl *python_interpreter =
       GetPythonInterpreter(debugger);
 
   if (!python_interpreter)
     return {};
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-  PythonObject ret_val = LLDBSwigPythonCreateScriptedThreadPlan(
+  PythonObject ret_val = SWIGBridge::LLDBSwigPythonCreateScriptedThreadPlan(
       class_name, python_interpreter->m_dictionary_name.c_str(), args_data,
       error_str, thread_plan_sp);
   if (!ret_val)
     return {};
 
   return StructuredData::ObjectSP(
       new StructuredPythonObject(std::move(ret_val)));
 }
 
 bool ScriptInterpreterPythonImpl::ScriptedThreadPlanExplainsStop(
     StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error) {
   bool explains_stop = true;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    explains_stop = LLDBSWIGPythonCallThreadPlan(
+    explains_stop = SWIGBridge::LLDBSWIGPythonCallThreadPlan(
         generic->GetValue(), "explains_stop", event, script_error);
     if (script_error)
       return true;
   }
   return explains_stop;
 }
 
 bool ScriptInterpreterPythonImpl::ScriptedThreadPlanShouldStop(
     StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error) {
   bool should_stop = true;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    should_stop = LLDBSWIGPythonCallThreadPlan(
+    should_stop = SWIGBridge::LLDBSWIGPythonCallThreadPlan(
         generic->GetValue(), "should_stop", event, script_error);
     if (script_error)
       return true;
   }
   return should_stop;
 }
 
 bool ScriptInterpreterPythonImpl::ScriptedThreadPlanIsStale(
     StructuredData::ObjectSP implementor_sp, bool &script_error) {
   bool is_stale = true;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    is_stale = LLDBSWIGPythonCallThreadPlan(generic->GetValue(), "is_stale",
-                                            (Event *) nullptr, script_error);
+    is_stale = SWIGBridge::LLDBSWIGPythonCallThreadPlan(
+        generic->GetValue(), "is_stale", (Event *)nullptr, script_error);
     if (script_error)
       return true;
   }
   return is_stale;
 }
 
 lldb::StateType ScriptInterpreterPythonImpl::ScriptedThreadPlanGetRunState(
     StructuredData::ObjectSP implementor_sp, bool &script_error) {
   bool should_step = false;
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (generic) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    should_step = LLDBSWIGPythonCallThreadPlan(
-        generic->GetValue(), "should_step", (Event *) nullptr, script_error);
+    should_step = SWIGBridge::LLDBSWIGPythonCallThreadPlan(
+        generic->GetValue(), "should_step", (Event *)nullptr, script_error);
     if (script_error)
       should_step = true;
   }
   if (should_step)
     return lldb::eStateStepping;
   return lldb::eStateRunning;
 }
 
 bool
 ScriptInterpreterPythonImpl::ScriptedThreadPlanGetStopDescription(
     StructuredData::ObjectSP implementor_sp, lldb_private::Stream *stream, 
     bool &script_error) {
   StructuredData::Generic *generic = nullptr;
   if (implementor_sp)
     generic = implementor_sp->GetAsGeneric();
   if (!generic) {
     script_error = true;
     return false;
   }
   Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-  return LLDBSWIGPythonCallThreadPlan(generic->GetValue(), "stop_description", 
-      stream, script_error);
+  return SWIGBridge::LLDBSWIGPythonCallThreadPlan(
+      generic->GetValue(), "stop_description", stream, script_error);
 }
 
 
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::CreateScriptedBreakpointResolver(
     const char *class_name, const StructuredDataImpl &args_data,
     lldb::BreakpointSP &bkpt_sp) {
 
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!bkpt_sp.get())
     return StructuredData::GenericSP();
 
   Debugger &debugger = bkpt_sp->GetTarget().GetDebugger();
   ScriptInterpreterPythonImpl *python_interpreter =
       GetPythonInterpreter(debugger);
 
   if (!python_interpreter)
     return StructuredData::GenericSP();
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
-  PythonObject ret_val = LLDBSwigPythonCreateScriptedBreakpointResolver(
+  PythonObject ret_val =
+      SWIGBridge::LLDBSwigPythonCreateScriptedBreakpointResolver(
           class_name, python_interpreter->m_dictionary_name.c_str(), args_data,
           bkpt_sp);
 
   return StructuredData::GenericSP(
       new StructuredPythonObject(std::move(ret_val)));
 }
 
 bool ScriptInterpreterPythonImpl::ScriptedBreakpointResolverSearchCallback(
     StructuredData::GenericSP implementor_sp, SymbolContext *sym_ctx) {
   bool should_continue = false;
 
   if (implementor_sp) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    should_continue = LLDBSwigPythonCallBreakpointResolver(
+    should_continue = SWIGBridge::LLDBSwigPythonCallBreakpointResolver(
         implementor_sp->GetValue(), "__callback__", sym_ctx);
     if (PyErr_Occurred()) {
       PyErr_Print();
       PyErr_Clear();
     }
   }
   return should_continue;
 }
 
 lldb::SearchDepth
 ScriptInterpreterPythonImpl::ScriptedBreakpointResolverSearchDepth(
     StructuredData::GenericSP implementor_sp) {
   int depth_as_int = lldb::eSearchDepthModule;
   if (implementor_sp) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    depth_as_int = LLDBSwigPythonCallBreakpointResolver(
+    depth_as_int = SWIGBridge::LLDBSwigPythonCallBreakpointResolver(
         implementor_sp->GetValue(), "__get_depth__", nullptr);
     if (PyErr_Occurred()) {
       PyErr_Print();
       PyErr_Clear();
     }
   }
   if (depth_as_int == lldb::eSearchDepthInvalid)
     return lldb::eSearchDepthModule;
StructuredData::GenericSP ScriptInterpreterPythonImpl::CreateScriptedStopHook(
   if (!python_interpreter) {
     error.SetErrorString("No script interpreter for scripted stop-hook.");
     return StructuredData::GenericSP();
   }
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
-  PythonObject ret_val = LLDBSwigPythonCreateScriptedStopHook(
+  PythonObject ret_val = SWIGBridge::LLDBSwigPythonCreateScriptedStopHook(
       target_sp, class_name, python_interpreter->m_dictionary_name.c_str(),
       args_data, error);
 
   return StructuredData::GenericSP(
       new StructuredPythonObject(std::move(ret_val)));
 }
 
 bool ScriptInterpreterPythonImpl::ScriptedStopHookHandleStop(
     StructuredData::GenericSP implementor_sp, ExecutionContext &exc_ctx,
     lldb::StreamSP stream_sp) {
   assert(implementor_sp &&
          "can't call a stop hook with an invalid implementor");
   assert(stream_sp && "can't call a stop hook with an invalid stream");
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
   lldb::ExecutionContextRefSP exc_ctx_ref_sp(new ExecutionContextRef(exc_ctx));
 
-  bool ret_val = LLDBSwigPythonStopHookCallHandleStop(
+  bool ret_val = SWIGBridge::LLDBSwigPythonStopHookCallHandleStop(
       implementor_sp->GetValue(), exc_ctx_ref_sp, stream_sp);
   return ret_val;
 }
 
 StructuredData::ObjectSP
 ScriptInterpreterPythonImpl::LoadPluginModule(const FileSpec &file_spec,
                                               lldb_private::Status &error) {
   if (!FileSystem::Instance().Exists(file_spec)) {
StructuredData::DictionarySP ScriptInterpreterPythonImpl::GetDynamicSettings(
   StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
   if (!generic)
     return StructuredData::DictionarySP();
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
   TargetSP target_sp(target->shared_from_this());
 
-  auto setting = (PyObject *)LLDBSWIGPython_GetDynamicSetting(
+  auto setting = (PyObject *)SWIGBridge::LLDBSWIGPython_GetDynamicSetting(
       generic->GetValue(), setting_name, target_sp);
 
   if (!setting)
     return StructuredData::DictionarySP();
 
   PythonDictionary py_dict =
       unwrapIgnoringErrors(As<PythonDictionary>(Take<PythonObject>(setting)));
 
ScriptInterpreterPythonImpl::CreateSyntheticScriptedProvider(
   ScriptInterpreterPythonImpl *python_interpreter =
       GetPythonInterpreter(debugger);
 
   if (!python_interpreter)
     return StructuredData::ObjectSP();
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-  PythonObject ret_val = LLDBSwigPythonCreateSyntheticProvider(
+  PythonObject ret_val = SWIGBridge::LLDBSwigPythonCreateSyntheticProvider(
       class_name, python_interpreter->m_dictionary_name.c_str(), valobj);
 
   return StructuredData::ObjectSP(
       new StructuredPythonObject(std::move(ret_val)));
 }
 
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::CreateScriptCommandObject(const char *class_name) {
   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();
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-  PythonObject ret_val = LLDBSwigPythonCreateCommandObject(
+  PythonObject ret_val = SWIGBridge::LLDBSwigPythonCreateCommandObject(
       class_name, m_dictionary_name.c_str(), debugger_sp);
 
   if (ret_val.IsValid())
     return StructuredData::GenericSP(
         new StructuredPythonObject(std::move(ret_val)));
   else
     return {};
 }
if (python_function_name && *python_function_name) {
     {
       Locker py_lock(this, Locker::AcquireLock | Locker::InitSession |
                                Locker::NoSTDIN);
       {
         TypeSummaryOptionsSP options_sp(new TypeSummaryOptions(options));
 
         static Timer::Category func_cat("LLDBSwigPythonCallTypeScript");
         Timer scoped_timer(func_cat, "LLDBSwigPythonCallTypeScript");
-        ret_val = LLDBSwigPythonCallTypeScript(
+        ret_val = SWIGBridge::LLDBSwigPythonCallTypeScript(
             python_function_name, GetSessionDictionary().get(), valobj,
             &new_callee, options_sp, retval);
       }
     }
   } else {
     retval.assign("<no function name>");
     return false;
   }
 
   if (new_callee && old_callee != new_callee) {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     callee_wrapper_sp = std::make_shared<StructuredPythonObject>(
         PythonObject(PyRefType::Borrowed, static_cast<PyObject *>(new_callee)));
   }
 
   return ret_val;
 }
 
 bool ScriptInterpreterPythonImpl::FormatterCallbackFunction(
     const char *python_function_name, TypeImplSP type_impl_sp) {
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-  return LLDBSwigPythonFormatterCallbackFunction(
+  return SWIGBridge::LLDBSwigPythonFormatterCallbackFunction(
       python_function_name, m_dictionary_name.c_str(), type_impl_sp);
 }
 
 bool ScriptInterpreterPythonImpl::BreakpointCallbackFunction(
     void *baton, StoppointCallbackContext *context, user_id_t break_id,
     user_id_t break_loc_id) {
   CommandDataPython *bp_option_data = (CommandDataPython *)baton;
   const char *python_function_name = bp_option_data->script_source.c_str();
if (breakpoint_sp) {
 
       if (stop_frame_sp && bp_loc_sp) {
         bool ret_val = true;
         {
           Locker py_lock(python_interpreter, Locker::AcquireLock |
                                                  Locker::InitSession |
                                                  Locker::NoSTDIN);
           Expected<bool> maybe_ret_val =
-              LLDBSwigPythonBreakpointCallbackFunction(
+              SWIGBridge::LLDBSwigPythonBreakpointCallbackFunction(
                   python_function_name,
                   python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
                   bp_loc_sp, bp_option_data->m_extra_args);
 
           if (!maybe_ret_val) {
 
             llvm::handleAllErrors(
                 maybe_ret_val.takeError(),
if (python_function_name && python_function_name[0]) {
     WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
     if (wp_sp) {
       if (stop_frame_sp && wp_sp) {
         bool ret_val = true;
         {
           Locker py_lock(python_interpreter, Locker::AcquireLock |
                                                  Locker::InitSession |
                                                  Locker::NoSTDIN);
-          ret_val = LLDBSwigPythonWatchpointCallbackFunction(
+          ret_val = SWIGBridge::LLDBSwigPythonWatchpointCallbackFunction(
               python_function_name,
               python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
               wp_sp);
         }
         return ret_val;
       }
     }
   }
size_t ScriptInterpreterPythonImpl::CalculateNumChildren(
   if (!implementor)
     return 0;
 
   size_t ret_val = 0;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSwigPython_CalculateNumChildren(implementor, max);
+    ret_val = SWIGBridge::LLDBSwigPython_CalculateNumChildren(implementor, max);
   }
 
   return ret_val;
 }
 
 lldb::ValueObjectSP ScriptInterpreterPythonImpl::GetChildAtIndex(
     const StructuredData::ObjectSP &implementor_sp, uint32_t idx) {
   if (!implementor_sp)
     return lldb::ValueObjectSP();
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return lldb::ValueObjectSP();
   auto *implementor = static_cast<PyObject *>(generic->GetValue());
   if (!implementor)
     return lldb::ValueObjectSP();
 
   lldb::ValueObjectSP ret_val;
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    PyObject *child_ptr = LLDBSwigPython_GetChildAtIndex(implementor, idx);
+    PyObject *child_ptr =
+        SWIGBridge::LLDBSwigPython_GetChildAtIndex(implementor, idx);
     if (child_ptr != nullptr && child_ptr != Py_None) {
       lldb::SBValue *sb_value_ptr =
           (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(child_ptr);
       if (sb_value_ptr == nullptr)
         Py_XDECREF(child_ptr);
       else
-        ret_val = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
+        ret_val = SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue(
+            sb_value_ptr);
     } else {
       Py_XDECREF(child_ptr);
     }
   }
 
   return ret_val;
 }
 
int ScriptInterpreterPythonImpl::GetIndexOfChildWithName(
   if (!implementor)
     return UINT32_MAX;
 
   int ret_val = UINT32_MAX;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSwigPython_GetIndexOfChildWithName(implementor, child_name);
+    ret_val = SWIGBridge::LLDBSwigPython_GetIndexOfChildWithName(implementor, child_name);
   }
 
   return ret_val;
 }
 
 bool ScriptInterpreterPythonImpl::UpdateSynthProviderInstance(
     const StructuredData::ObjectSP &implementor_sp) {
   bool ret_val = false;
 
   if (!implementor_sp)
     return ret_val;
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return ret_val;
   auto *implementor = static_cast<PyObject *>(generic->GetValue());
   if (!implementor)
     return ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSwigPython_UpdateSynthProviderInstance(implementor);
+    ret_val =
+        SWIGBridge::LLDBSwigPython_UpdateSynthProviderInstance(implementor);
   }
 
   return ret_val;
 }
 
 bool ScriptInterpreterPythonImpl::MightHaveChildrenSynthProviderInstance(
     const StructuredData::ObjectSP &implementor_sp) {
   bool ret_val = false;
 
   if (!implementor_sp)
     return ret_val;
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return ret_val;
   auto *implementor = static_cast<PyObject *>(generic->GetValue());
   if (!implementor)
     return ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val =
-        LLDBSwigPython_MightHaveChildrenSynthProviderInstance(implementor);
+    ret_val = SWIGBridge::LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
+        implementor);
   }
 
   return ret_val;
 }
 
 lldb::ValueObjectSP ScriptInterpreterPythonImpl::GetSyntheticValue(
     const StructuredData::ObjectSP &implementor_sp) {
   lldb::ValueObjectSP ret_val(nullptr);
 
   if (!implementor_sp)
     return ret_val;
 
   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
   if (!generic)
     return ret_val;
   auto *implementor = static_cast<PyObject *>(generic->GetValue());
   if (!implementor)
     return ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     PyObject *child_ptr =
-        LLDBSwigPython_GetValueSynthProviderInstance(implementor);
+        SWIGBridge::LLDBSwigPython_GetValueSynthProviderInstance(implementor);
     if (child_ptr != nullptr && child_ptr != Py_None) {
       lldb::SBValue *sb_value_ptr =
           (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(child_ptr);
       if (sb_value_ptr == nullptr)
         Py_XDECREF(child_ptr);
       else
-        ret_val = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
+        ret_val = SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue(
+            sb_value_ptr);
     } else {
       Py_XDECREF(child_ptr);
     }
   }
 
   return ret_val;
 }
 
bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSWIGPythonRunScriptKeywordProcess(
+    ret_val = SWIGBridge::LLDBSWIGPythonRunScriptKeywordProcess(
         impl_function, m_dictionary_name.c_str(), process->shared_from_this(),
         output);
     if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, Thread *thread, std::string &output,
     Status &error) {
   if (!thread) {
     error.SetErrorString("no thread");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-  if (std::optional<std::string> result = LLDBSWIGPythonRunScriptKeywordThread(
+  if (std::optional<std::string> result =
+          SWIGBridge::LLDBSWIGPythonRunScriptKeywordThread(
               impl_function, m_dictionary_name.c_str(),
               thread->shared_from_this())) {
     output = std::move(*result);
     return true;
   }
   error.SetErrorString("python script evaluation failed");
   return false;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, Target *target, std::string &output,
     Status &error) {
   bool ret_val;
   if (!target) {
     error.SetErrorString("no thread");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   {
     TargetSP target_sp(target->shared_from_this());
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSWIGPythonRunScriptKeywordTarget(
+    ret_val = SWIGBridge::LLDBSWIGPythonRunScriptKeywordTarget(
         impl_function, m_dictionary_name.c_str(), target_sp, output);
     if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, StackFrame *frame, std::string &output,
     Status &error) {
   if (!frame) {
     error.SetErrorString("no frame");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-  if (std::optional<std::string> result = LLDBSWIGPythonRunScriptKeywordFrame(
+  if (std::optional<std::string> result =
+          SWIGBridge::LLDBSWIGPythonRunScriptKeywordFrame(
               impl_function, m_dictionary_name.c_str(),
               frame->shared_from_this())) {
     output = std::move(*result);
     return true;
   }
   error.SetErrorString("python script evaluation failed");
   return false;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, ValueObject *value, std::string &output,
     Status &error) {
   bool ret_val;
   if (!value) {
     error.SetErrorString("no value");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSWIGPythonRunScriptKeywordValue(
+    ret_val = SWIGBridge::LLDBSWIGPythonRunScriptKeywordValue(
         impl_function, m_dictionary_name.c_str(), value->GetSP(), output);
     if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
 uint64_t replace_all(std::string &str, const std::string &oldStr,
if (was_imported_globally || was_imported_locally) {
     command_stream.Printf("import %s", module_name.c_str());
 
   error = ExecuteMultipleLines(command_stream.GetData(), exc_options);
   if (error.Fail())
     return false;
 
   // if we are here, everything worked
   // call __lldb_init_module(debugger,dict)
-  if (!LLDBSwigPythonCallModuleInit(module_name.c_str(),
-                                    m_dictionary_name.c_str(),
-                                    m_debugger.shared_from_this())) {
+  if (!SWIGBridge::LLDBSwigPythonCallModuleInit(
+          module_name.c_str(), m_dictionary_name.c_str(),
     error.SetErrorString("calling __lldb_init_module failed");
     return false;
   }
 
   if (module_sp) {
     // everything went just great, now set the module object
     command_stream.Clear();
     command_stream.Printf("%s", module_name.c_str());
std::string err_msg;
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession |
                        (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
                    Locker::FreeLock | Locker::TearDownSession);
 
     SynchronicityHandler synch_handler(debugger_sp, synchronicity);
 
     std::string args_str = args.str();
-    ret_val = LLDBSwigPythonCallCommand(
+    ret_val = SWIGBridge::LLDBSwigPythonCallCommand(
         impl_function, m_dictionary_name.c_str(), debugger_sp, args_str.c_str(),
         cmd_retobj, exe_ctx_ref_sp);
   }
 
   if (!ret_val)
     error.SetErrorString("unable to execute script function");
   else if (cmd_retobj.GetStatus() == eReturnStatusFailed)
     return false;
std::string err_msg;
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession |
                        (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
                    Locker::FreeLock | Locker::TearDownSession);
 
     SynchronicityHandler synch_handler(debugger_sp, synchronicity);
 
     std::string args_str = args.str();
-    ret_val = LLDBSwigPythonCallCommandObject(
+    ret_val = SWIGBridge::LLDBSwigPythonCallCommandObject(
         static_cast<PyObject *>(impl_obj_sp->GetValue()), debugger_sp,
         args_str.c_str(), cmd_retobj, exe_ctx_ref_sp);
   }
 
   if (!ret_val)
     error.SetErrorString("unable to execute script function");
   else if (cmd_retobj.GetStatus() == eReturnStatusFailed)
     return false;

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPlatformPythonInterface.cpp

StructuredData::GenericSP ScriptedPlatformPythonInterface::CreatePluginObject(
   std::string error_string;
 
   Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
                  Locker::FreeLock);
 
   lldb::ExecutionContextRefSP exe_ctx_ref_sp =
       std::make_shared<ExecutionContextRef>(exe_ctx);
 
-  PythonObject ret_val = LLDBSwigPythonCreateScriptedObject(
+  PythonObject ret_val = SWIGBridge::LLDBSwigPythonCreateScriptedObject(
       class_name.str().c_str(), m_interpreter.GetDictionaryName(),
       exe_ctx_ref_sp, args_impl, error_string);
 
   m_object_instance_sp =
       StructuredData::GenericSP(new StructuredPythonObject(std::move(ret_val)));
 
   return m_object_instance_sp;
 }

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.cpp

StructuredData::GenericSP ScriptedProcessPythonInterface::CreatePluginObject(
   std::string error_string;
 
   Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
                  Locker::FreeLock);
 
   lldb::ExecutionContextRefSP exe_ctx_ref_sp =
       std::make_shared<ExecutionContextRef>(exe_ctx);
 
-  PythonObject ret_val = LLDBSwigPythonCreateScriptedObject(
+  PythonObject ret_val = SWIGBridge::LLDBSwigPythonCreateScriptedObject(
       class_name.str().c_str(), m_interpreter.GetDictionaryName(),
       exe_ctx_ref_sp, args_impl, error_string);
 
   m_object_instance_sp =
       StructuredData::GenericSP(new StructuredPythonObject(std::move(ret_val)));
 
   return m_object_instance_sp;
 }

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h

protected:
   }
 
   python::PythonObject Transform(bool arg) {
     // Boolean arguments need to be turned into python objects.
     return python::PythonBoolean(arg);
   }
 
   python::PythonObject Transform(Status arg) {
-    return python::ToSWIGWrapper(arg);
+    return python::SWIGBridge::ToSWIGWrapper(arg);
   }
 
   python::PythonObject Transform(lldb::ProcessAttachInfoSP arg) {
-    return python::ToSWIGWrapper(arg);
+    return python::SWIGBridge::ToSWIGWrapper(arg);
   }
 
   python::PythonObject Transform(lldb::ProcessLaunchInfoSP arg) {
-    return python::ToSWIGWrapper(arg);
+    return python::SWIGBridge::ToSWIGWrapper(arg);
   }
 
   python::PythonObject Transform(lldb::DataExtractorSP arg) {
-    return python::ToSWIGWrapper(arg);
+    return python::SWIGBridge::ToSWIGWrapper(arg);
   }
 
   template <typename T, typename U>
   void ReverseTransform(T &original_arg, U transformed_arg, Status &error) {
     // If U is not a PythonObject, don't touch it!
     return;
   }
 

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedThreadPythonInterface.cpp

StructuredData::GenericSP ScriptedThreadPythonInterface::CreatePluginObject(
   Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
                  Locker::FreeLock);
 
   PythonObject ret_val;
 
   if (!script_obj) {
     lldb::ExecutionContextRefSP exe_ctx_ref_sp =
         std::make_shared<ExecutionContextRef>(exe_ctx);
-    ret_val = LLDBSwigPythonCreateScriptedObject(
+    ret_val = SWIGBridge::LLDBSwigPythonCreateScriptedObject(
         class_name.str().c_str(), m_interpreter.GetDictionaryName(),
         exe_ctx_ref_sp, args_impl, error_string);
   } else
     ret_val = PythonObject(PyRefType::Borrowed,
                            static_cast<PyObject *>(script_obj->GetValue()));
 
   if (!ret_val)
     return {};

lldb/unittests/API/CMakeLists.txt

 add_lldb_unittest(APITests
   SBCommandInterpreterTest.cpp
-  SBStructuredDataTest.cpp
 
   LINK_LIBS
     liblldb
   )
 
 if(Python3_RPATH)
   set_property(TARGET APITests APPEND PROPERTY BUILD_RPATH "${Python3_RPATH}")
 endif()

lldb/unittests/API/SBCommandInterpreterTest.cpp

 #include <string>
 
 using namespace lldb;
 
 class SBCommandInterpreterTest : public testing::Test {
 protected:
   void SetUp() override {
     SBDebugger::Initialize();
     m_dbg = SBDebugger::Create(/*source_init_files=*/false);
-    m_interp = m_dbg.GetCommandInterpreter();
   }
 
   SBDebugger m_dbg;
-  SBCommandInterpreter m_interp;
 };
 
 class DummyCommand : public SBCommandPluginInterface {
 public:
   DummyCommand(const char *message) : m_message(message) {}
 
   bool DoExecute(SBDebugger dbg, char **command,
                  SBCommandReturnObject &result) override {
     result.PutCString(m_message.c_str());
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 
 private:
   std::string m_message;
 };
 
 TEST_F(SBCommandInterpreterTest, SingleWordCommand) {
   // We first test a command without autorepeat
   DummyCommand dummy("It worked");
-  m_interp.AddCommand("dummy", &dummy, /*help=*/nullptr);
+  SBCommandInterpreter interp = m_dbg.GetCommandInterpreter();
+  interp.AddCommand("dummy", &dummy, /*help=*/nullptr);
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("dummy", result, /*add_to_history=*/true);
+    interp.HandleCommand("dummy", result, /*add_to_history=*/true);
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked\n");
   }
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("", result);
+    interp.HandleCommand("", result);
     EXPECT_FALSE(result.Succeeded());
     EXPECT_STREQ(result.GetError(), "error: No auto repeat.\n");
   }
 
   // Now we test a command with autorepeat
-  m_interp.AddCommand("dummy_with_autorepeat", &dummy, /*help=*/nullptr,
-                      /*syntax=*/nullptr, /*auto_repeat_command=*/nullptr);
+  interp.AddCommand("dummy_with_autorepeat", &dummy, /*help=*/nullptr,
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("dummy_with_autorepeat", result,
-                           /*add_to_history=*/true);
+    interp.HandleCommand("dummy_with_autorepeat", result,
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked\n");
   }
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("", result);
+    interp.HandleCommand("", result);
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked\n");
   }
 }
 
 TEST_F(SBCommandInterpreterTest, MultiWordCommand) {
-  auto command = m_interp.AddMultiwordCommand("multicommand", /*help=*/nullptr);
+  SBCommandInterpreter interp = m_dbg.GetCommandInterpreter();
+  auto command = interp.AddMultiwordCommand("multicommand", /*help=*/nullptr);
   // We first test a subcommand without autorepeat
   DummyCommand subcommand("It worked again");
   command.AddCommand("subcommand", &subcommand, /*help=*/nullptr);
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("multicommand subcommand", result,
-                           /*add_to_history=*/true);
+    interp.HandleCommand("multicommand subcommand", result,
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked again\n");
   }
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("", result);
+    interp.HandleCommand("", result);
     EXPECT_FALSE(result.Succeeded());
     EXPECT_STREQ(result.GetError(), "error: No auto repeat.\n");
   }
 
   // We first test a subcommand with autorepeat
   command.AddCommand("subcommand_with_autorepeat", &subcommand,
                      /*help=*/nullptr, /*syntax=*/nullptr,
                      /*auto_repeat_command=*/nullptr);
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("multicommand subcommand_with_autorepeat", result,
-                           /*add_to_history=*/true);
+    interp.HandleCommand("multicommand subcommand_with_autorepeat", result,
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked again\n");
   }
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("", result);
+    interp.HandleCommand("", result);
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked again\n");
   }
 
   DummyCommand subcommand2("It worked again 2");
   // We now test a subcommand with autorepeat of the command name
   command.AddCommand(
       "subcommand_with_custom_autorepeat", &subcommand2, /*help=*/nullptr,
       /*syntax=*/nullptr,
       /*auto_repeat_command=*/"multicommand subcommand_with_autorepeat");
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("multicommand subcommand_with_custom_autorepeat",
-                           result, /*add_to_history=*/true);
+    interp.HandleCommand("multicommand subcommand_with_custom_autorepeat",
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked again 2\n");
   }
   {
     SBCommandReturnObject result;
-    m_interp.HandleCommand("", result);
+    interp.HandleCommand("", result);
     EXPECT_TRUE(result.Succeeded());
     EXPECT_STREQ(result.GetOutput(), "It worked again\n");
   }
 }

lldb/unittests/API/SBStructuredDataTest.cpp

-//===-- SBStructuredDataTest.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 "gtest/gtest.h"
-
-#include "lldb/API/SBStringList.h"
-#include "lldb/API/SBStructuredData.h"
-
-#include <cstring>
-#include <string>
-
-using namespace lldb;
-
-class SBStructuredDataTest : public testing::Test {};
-
-TEST_F(SBStructuredDataTest, NullImpl) {
-  SBStructuredData data(nullptr);
-  EXPECT_EQ(data.GetType(), eStructuredDataTypeInvalid);
-  EXPECT_EQ(data.GetSize(), 0ul);
-  SBStringList keys;
-  EXPECT_FALSE(data.GetKeys(keys));
-  EXPECT_EQ(data.GetValueForKey("key").GetType(), eStructuredDataTypeInvalid);
-  EXPECT_EQ(data.GetItemAtIndex(0).GetType(), eStructuredDataTypeInvalid);
-  EXPECT_EQ(data.GetIntegerValue(UINT64_MAX), UINT64_MAX);
-  EXPECT_EQ(data.GetFloatValue(DBL_MAX), DBL_MAX);
-  EXPECT_TRUE(data.GetBooleanValue(true));
-  EXPECT_FALSE(data.GetBooleanValue(false));
-  char dst[1];
-  EXPECT_EQ(data.GetStringValue(dst, sizeof(dst)), 0ul);
-}

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 }
 
 // The following functions are the Pythonic implementations of the required
 // callbacks. Because they're defined in libLLDB which we cannot link for the
 // unit test, we have a 'default' implementation here.
 
 extern "C" PyObject *PyInit__lldb(void) { return nullptr; }
 
-llvm::Expected<bool> lldb_private::LLDBSwigPythonBreakpointCallbackFunction(
+llvm::Expected<bool>
+lldb_private::python::SWIGBridge::LLDBSwigPythonBreakpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame,
     const lldb::BreakpointLocationSP &sb_bp_loc,
     const StructuredDataImpl &args_impl) {
   return false;
 }
 
-bool lldb_private::LLDBSwigPythonWatchpointCallbackFunction(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonWatchpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame, const lldb::WatchpointSP &sb_wp) {
   return false;
 }
 
-bool lldb_private::LLDBSwigPythonFormatterCallbackFunction(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonFormatterCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::TypeImplSP type_impl_sp) {
   return false;
 }
 
-bool lldb_private::LLDBSwigPythonCallTypeScript(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallTypeScript(
     const char *python_function_name, const void *session_dictionary,
     const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
     const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval) {
   return false;
 }
 
-python::PythonObject lldb_private::LLDBSwigPythonCreateSyntheticProvider(
+python::PythonObject
+lldb_private::python::SWIGBridge::LLDBSwigPythonCreateSyntheticProvider(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::ValueObjectSP &valobj_sp) {
   return python::PythonObject();
 }
 
-python::PythonObject lldb_private::LLDBSwigPythonCreateCommandObject(
+python::PythonObject
+lldb_private::python::SWIGBridge::LLDBSwigPythonCreateCommandObject(
     const char *python_class_name, const char *session_dictionary_name,
     lldb::DebuggerSP debugger_sp) {
   return python::PythonObject();
 }
 
-python::PythonObject lldb_private::LLDBSwigPythonCreateScriptedThreadPlan(
+python::PythonObject
+lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
     const StructuredDataImpl &args_data, std::string &error_string,
     const lldb::ThreadPlanSP &thread_plan_sp) {
   return python::PythonObject();
 }
 
-bool lldb_private::LLDBSWIGPythonCallThreadPlan(void *implementor,
-                                                const char *method_name,
-                                                Event *event_sp,
-                                                bool &got_error) {
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonCallThreadPlan(
+    void *implementor, const char *method_name, Event *event_sp,
   return false;
 }
 
-bool 
-lldb_private::LLDBSWIGPythonCallThreadPlan(void *implementor,
-                                                const char *method_name,
-                                                Stream *event_sp,
-                                                bool &got_error) {
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonCallThreadPlan(
+    void *implementor, const char *method_name, Stream *event_sp,
   return false;
 }
 
-python::PythonObject
-lldb_private::LLDBSwigPythonCreateScriptedBreakpointResolver(
+python::PythonObject lldb_private::python::SWIGBridge::
+    LLDBSwigPythonCreateScriptedBreakpointResolver(
         const char *python_class_name, const char *session_dictionary_name,
         const StructuredDataImpl &args, const lldb::BreakpointSP &bkpt_sp) {
   return python::PythonObject();
 }
 
-unsigned int lldb_private::LLDBSwigPythonCallBreakpointResolver(
+unsigned int
+lldb_private::python::SWIGBridge::LLDBSwigPythonCallBreakpointResolver(
     void *implementor, const char *method_name,
     lldb_private::SymbolContext *sym_ctx) {
   return 0;
 }
 
-size_t lldb_private::LLDBSwigPython_CalculateNumChildren(PyObject *implementor,
-                                                         uint32_t max) {
+size_t lldb_private::python::SWIGBridge::LLDBSwigPython_CalculateNumChildren(
+    PyObject *implementor, uint32_t max) {
   return 0;
 }
 
-PyObject *lldb_private::LLDBSwigPython_GetChildAtIndex(PyObject *implementor,
-                                                       uint32_t idx) {
+PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetChildAtIndex(
+    PyObject *implementor, uint32_t idx) {
   return nullptr;
 }
 
-int lldb_private::LLDBSwigPython_GetIndexOfChildWithName(
+int lldb_private::python::SWIGBridge::LLDBSwigPython_GetIndexOfChildWithName(
     PyObject *implementor, const char *child_name) {
   return 0;
 }
 
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBData(PyObject *data) {
   return nullptr;
 }
 

 }
 
 void *
 lldb_private::LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data) {
   return nullptr;
 }
 
 lldb::ValueObjectSP
-lldb_private::LLDBSWIGPython_GetValueObjectSPFromSBValue(void *data) {
+lldb_private::python::SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue(
+    void *data) {
   return nullptr;
 }
 
-bool lldb_private::LLDBSwigPython_UpdateSynthProviderInstance(
-    PyObject *implementor) {
+bool lldb_private::python::SWIGBridge::
+    LLDBSwigPython_UpdateSynthProviderInstance(PyObject *implementor) {
   return false;
 }
 
-bool lldb_private::LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
+bool lldb_private::python::SWIGBridge::
+    LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
         PyObject *implementor) {
   return false;
 }
 
-PyObject *lldb_private::LLDBSwigPython_GetValueSynthProviderInstance(
+PyObject *
+lldb_private::python::SWIGBridge::LLDBSwigPython_GetValueSynthProviderInstance(
     PyObject *implementor) {
   return nullptr;
 }
 
-bool lldb_private::LLDBSwigPythonCallCommand(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommand(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
   return false;
 }
 
-bool lldb_private::LLDBSwigPythonCallCommandObject(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommandObject(
     PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
   return false;
 }
 
-bool lldb_private::LLDBSwigPythonCallModuleInit(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallModuleInit(
     const char *python_module_name, const char *session_dictionary_name,
     lldb::DebuggerSP debugger) {
   return false;
 }
 
 python::PythonObject
-lldb_private::LLDBSWIGPythonCreateOSPlugin(const char *python_class_name,
-                                           const char *session_dictionary_name,
-                                           const lldb::ProcessSP &process_sp) {
+lldb_private::python::SWIGBridge::LLDBSWIGPythonCreateOSPlugin(
+    const char *python_class_name, const char *session_dictionary_name,
   return python::PythonObject();
 }
 
-python::PythonObject lldb_private::LLDBSwigPythonCreateScriptedObject(
+python::PythonObject
+lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedObject(
     const char *python_class_name, const char *session_dictionary_name,
     lldb::ExecutionContextRefSP exe_ctx_sp, const StructuredDataImpl &args_impl,
     std::string &error_string) {
   return python::PythonObject();
 }
 
-python::PythonObject lldb_private::LLDBSWIGPython_CreateFrameRecognizer(
+python::PythonObject
+lldb_private::python::SWIGBridge::LLDBSWIGPython_CreateFrameRecognizer(
     const char *python_class_name, const char *session_dictionary_name) {
   return python::PythonObject();
 }
 
-PyObject *lldb_private::LLDBSwigPython_GetRecognizedArguments(
+PyObject *
+lldb_private::python::SWIGBridge::LLDBSwigPython_GetRecognizedArguments(
     PyObject *implementor, const lldb::StackFrameSP &frame_sp) {
   return nullptr;
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordProcess(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordProcess(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::ProcessSP &process, std::string &output) {
   return false;
 }
 
-std::optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordThread(
+std::optional<std::string>
+lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordThread(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::ThreadSP thread) {
   return std::nullopt;
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordTarget(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordTarget(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::TargetSP &target, std::string &output) {
   return false;
 }
 
-std::optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordFrame(
+std::optional<std::string>
+lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordFrame(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::StackFrameSP frame) {
   return std::nullopt;
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordValue(
+bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordValue(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::ValueObjectSP &value, std::string &output) {
   return false;
 }
 
-void *lldb_private::LLDBSWIGPython_GetDynamicSetting(
+void *lldb_private::python::SWIGBridge::LLDBSWIGPython_GetDynamicSetting(
     void *module, const char *setting, const lldb::TargetSP &target_sp) {
   return nullptr;
 }
 
-python::PythonObject lldb_private::LLDBSwigPythonCreateScriptedStopHook(
+python::PythonObject
+lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedStopHook(
     lldb::TargetSP target_sp, const char *python_class_name,
     const char *session_dictionary_name, const StructuredDataImpl &args_impl,
     Status &error) {
   return python::PythonObject();
 }
 
-bool lldb_private::LLDBSwigPythonStopHookCallHandleStop(
+bool lldb_private::python::SWIGBridge::LLDBSwigPythonStopHookCallHandleStop(
     void *implementor, lldb::ExecutionContextRefSP exc_ctx_sp,
     lldb::StreamSP stream) {
   return false;
 }
 
-python::PythonObject lldb_private::python::ToSWIGWrapper(const Status &status) {
+python::PythonObject
+lldb_private::python::SWIGBridge::ToSWIGWrapper(const Status &status) {
   return python::PythonObject();
 }
 
 python::PythonObject
-lldb_private::python::ToSWIGWrapper(lldb::ProcessAttachInfoSP) {
+lldb_private::python::SWIGBridge::ToSWIGWrapper(lldb::ProcessAttachInfoSP) {
   return python::PythonObject();
 }
 
 python::PythonObject
-lldb_private::python::ToSWIGWrapper(lldb::ProcessLaunchInfoSP) {
+lldb_private::python::SWIGBridge::ToSWIGWrapper(lldb::ProcessLaunchInfoSP) {
   return python::PythonObject();
 }
 
 python::PythonObject
-lldb_private::python::ToSWIGWrapper(lldb::DataExtractorSP) {
+lldb_private::python::SWIGBridge::ToSWIGWrapper(lldb::DataExtractorSP) {
   return python::PythonObject();
 }