remove multi-argument form of PythonObject::Reset()

[lawrence_danna]

Summary

With this patch, only the no-argument form of Reset() remains in
PythonDataObjects. It also deletes PythonExceptionState in favor of
PythonException, because the only call-site of PythonExceptionState was
also using Reset, so I cleaned up both while I was there.

[lawrence_danna]

rebased

[labath]

No fudnamental issues with this patch (I'm ignoring the CStringArg topic here). I do think that it would be nice to have some more unit tests for the new APIs you're introducing (or elevating to API status). I'm mainly thinking of the PythonScript stuff (a test where we evaluate the script successfully) and the runString functions.

lldb/include/lldb/Interpreter/ScriptInterpreter.h

68–70

I should've mentioned this earlier, but llvm style is to generally use // comments https://llvm.org/docs/CodingStandards.html#comment-formatting.,

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

262–265

Do I understand correctly that the idea is to eventually replace these functions with constructor calls too?

1059

I just realized I don't actually know what this means. Is it that the object takes the GIL internally? Or that one must have the GIL taken before he starts to interact with it? Maybe it'd be better to clarify this in the class description and just delete these comments.

1066–1067

maybe just return toString(backtrace.takeError()) here?

1530

Use early return here (if (valid) return Success;)

1534–1535

if (Error error = ...)

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

327

Maybe it's time to move the entire PythonObject hierarchy into the python namespace? That would be consistent with some of the newer lldb plugins, which have all of their code inside a sub-namespace of lldb_private..

755

I'm wondering if there's a way to avoid passing in the function name argument. Perhaps if the callable is returned as a result of the script ("def foo: ...; return foo")? WDYT?

766–767

if (llvm::Error e = ...)

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

1172–1183

Would something like this also work?

llvm::Error error = handleErrors(return_value.takeError(), [](PythonException &E) {
  llvm::Error str = makeStringError(E.ReadBacktrace());
  if (!options.GetMaskoutErrors)
    E.Restore();
  return str;
});
return std::move(error);

1982–1983

If doesn't look like this Reset call is really needed here..

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

790–803

Maybe:

EXPECT_THAT_EXPECTED(foo(),
  llvm::Failed<PythonException>(testing::Property(&PythonException::ReadBacktrace,
     testing::ContainsRegex(...) )) ));

[lawrence_danna]

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

1059

Almost everything in PythonDataObjects requires you to call it with the GIL already locked. The only things that don't are the File methods because they're called by things that don't know anything about python.

Normally when I need to do something like this I would use dispatch_once, or whatever the LLVM version of that is, so you avoid static initializers, but also initialize the thing in a thread-safe way.

But in this case we already know that this function can only be called by a thread that has the GIL, so it's safe to just initialize a global variable without further synchronization.

[lawrence_danna]

fixes

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

262–265

yea

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

755

I can't use return, but i can have the scripts put their function in a well-known output variable.

766–767

Is that style considered normative?

I have a strong preference against putting function calls that are being run for their side effects inside an if.

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

790–803

that doesn't seem to support multiple regexes, and is doing it 5 times really any more clear than just doing it manually?

[lawrence_danna]

comment

[labath]

I'm at the airport, so I haven't had a chance to look over the full set of changes you made, but here's my responses to your comments.

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

755

Yea, I like that. Maybe instead of assigning the defined function to a well-known some variable, we could just use that name in the def declaration already? Also, aren't names starting with a single underscore considered "private" in python? Maybe it could just be "function" (or "main", or "script_main", ...)

766–767

I didn't find any mention of that in the official style guide, but i think there's a lot of informal consensus about that. I've seen a lot of reviewers asking for that style, and I've never seen anyone be asked to change it back.
The main advantage of that is that it reduces the scope of the Error object, which is particularly important given that Error objects tend to do funny things when being destroyed.

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

790–803

I was thinking you would just do a ContainsRegex("line 3.*line 5.*line 7...") If you want to emulate the current behavior precisely, you could do a MatchesAll(HasSubstr("line 3"), HasSubstr("line 5"), ...).

The main advantage I see here is in the error message that you get when this thing fails. In the current setup, you'll get " expected 0xffff != 0xffff, got 0xffff == 0xffff". This expression will end up producing the full error string as the "obtained" value, which will hopefully give you some clue about what went wrong. Which is particuarly useful if the failure happens only on some bot, whose configuration you can't easily reproduce.

[lawrence_danna]

fixes

[lawrence_danna]

fixed

[lawrence_danna]

oops

[labath]

lldb/scripts/Python/python-extensions.swig

683–686

You don't have to do this if you don't want, but I couldn't help noticing that the "else" branch is completely unnecessary in all of these scriptlets.

lldb/scripts/Python/python-typemaps.swig

4

Could you delete these empty lines too. You don't have to delete absolutely all of them, if you think they're useful for better visual separation, but I definitely don't think empty lines at the very beginning of a block are useful.

lldb/scripts/Python/python-wrapper.swig

193–194

These even have a double empty line now. :)

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

262–265

awesome.

1059

Ok, thanks for explaining. The new comment is much clearer now (though I am not sure if it's even needed TBH).

1069–1071

This won't work. The reason why the Twine class is so efficient, is that it establishes links between various temporary objects. Those temporaries will be destroyed when the enclosing full expression is evaluated. This means it's never safe to store Twine objects as local variables.

1078

How likely are we to get another exception while trying to retrieve the backtrace? I am wondering if all this complexity is worth it...

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

26–27

No using declarations in headers.

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

790–793

EXPECT_THAT_EXPECTED(As<long long>(factorial(5ll)), llvm::HasValue(120))

842–843

HasValue(foobarbaz)

[lawrence_danna]

fixes

lldb/scripts/Python/python-extensions.swig

683–686

good point.

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

1078

It's actually not that unusual that someone writes a __str__ method for their exception which is broken and also throws an exception.

1078

actually, it looks like traceback.print_exception already takes care of that situation, so you're right it's not very useful.

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

26–27

even an "Impl" header?

[labath]

lldb/scripts/Python/python-wrapper.swig

232

There are empty lines from this point on in this file. Before they made sense because they were separating the using directive from the actual code, but now they've just become useless empty lines at the start of a block. Please delete them.

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

26–27

Nope. The "impl" here comes from the class name, but this is still a header like any other. Theoretically you could also put everything declared in this header into the python namespace, but otoh we have to stop somewhere, and this patch has gotten quite big already.

[lawrence_danna]

removed blank lines from python-wrapper.swig

lldb/include/lldb/Interpreter/ScriptInterpreter.h

public:
   public:
     ExecuteScriptOptions()
         : m_enable_io(true), m_set_lldb_globals(true), m_maskout_errors(true) {}
 
     bool GetEnableIO() const { return m_enable_io; }
 
     bool GetSetLLDBGlobals() const { return m_set_lldb_globals; }
 
+    // If this is true then any exceptions raised by the script will be
+    // cleared with PyErr_Clear().   If false then they will be left for
+    // the caller to clean up
     bool GetMaskoutErrors() const { return m_maskout_errors; }
 
     ExecuteScriptOptions &SetEnableIO(bool enable) {
       m_enable_io = enable;
       return *this;
     }
 
     ExecuteScriptOptions &SetSetLLDBGlobals(bool set) {

lldb/scripts/Python/python-extensions.swig

 
 %extend lldb::SBAddress {
         %nothreadallow;
         PyObject *lldb::SBAddress::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBBlock {
         %nothreadallow;
         PyObject *lldb::SBBlock::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBBreakpoint {
         %nothreadallow;
         PyObject *lldb::SBBreakpoint::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
%extend lldb::SBBreakpointLocation {
         PyObject *lldb::SBBreakpointLocation::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelFull);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 
 %extend lldb::SBBreakpointName {
         %nothreadallow;
         PyObject *lldb::SBBreakpointName::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 
 %extend lldb::SBBroadcaster {
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
%extend lldb::SBCommandReturnObject {
         PyObject *lldb::SBCommandReturnObject::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
         /* the write() and flush() calls are not part of the SB API proper, and are solely for Python usage
         they are meant to make an SBCommandReturnObject into a file-like object so that instructions of the sort
         print >>sb_command_return_object, "something"
         will work correctly */
 
%extend lldb::SBCompileUnit {
         PyObject *lldb::SBCompileUnit::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
             return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
%extend lldb::SBData {
         PyObject *lldb::SBData::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBDebugger {
         %nothreadallow;
         PyObject *lldb::SBDebugger::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBDeclaration {
         %nothreadallow;
         PyObject *lldb::SBDeclaration::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
%extend lldb::SBError {
         PyObject *lldb::SBError::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBFileSpec {
         %nothreadallow;
         PyObject *lldb::SBFileSpec::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBFrame {
         %nothreadallow;
         PyObject *lldb::SBFrame::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBFunction {
         %nothreadallow;
         PyObject *lldb::SBFunction::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
%extend lldb::SBInstruction {
         PyObject *lldb::SBInstruction::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBInstructionList {
         %nothreadallow;
         PyObject *lldb::SBInstructionList::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBLineEntry {
         %nothreadallow;
         PyObject *lldb::SBLineEntry::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
%extend lldb::SBMemoryRegionInfo {
         PyObject *lldb::SBMemoryRegionInfo::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 
 %extend lldb::SBModule {
         %nothreadallow;
         PyObject *lldb::SBModule::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
%extend lldb::SBModuleSpec {
         PyObject *lldb::SBModuleSpec::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 
 %extend lldb::SBModuleSpecList {
         %nothreadallow;
         PyObject *lldb::SBModuleSpecList::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 
 %extend lldb::SBProcess {
         %nothreadallow;
         PyObject *lldb::SBProcess::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBSection {
         %nothreadallow;
         PyObject *lldb::SBSection::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
%extend lldb::SBSymbol {
         PyObject *lldb::SBSymbol::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
             return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
%extend lldb::SBSymbolContext {
         PyObject *lldb::SBSymbolContext::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBSymbolContextList {
         %nothreadallow;
         PyObject *lldb::SBSymbolContextList::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 
 %extend lldb::SBTarget {
         %nothreadallow;
         PyObject *lldb::SBTarget::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
%extend lldb::SBType {
         PyObject *lldb::SBType::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBTypeCategory {
         %nothreadallow;
         PyObject *lldb::SBTypeCategory::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBTypeFilter {
         %nothreadallow;
         PyObject *lldb::SBTypeFilter::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
             return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
%extend lldb::SBTypeFormat {
         %nothreadallow;
         PyObject *lldb::SBTypeFormat::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBTypeMember {
         %nothreadallow;
         PyObject *lldb::SBTypeMember::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBTypeMemberFunction {
         %nothreadallow;
         PyObject *lldb::SBTypeMemberFunction::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBTypeEnumMember {
         %nothreadallow;
         PyObject *lldb::SBTypeEnumMember::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBTypeNameSpecifier {
         %nothreadallow;
         PyObject *lldb::SBTypeNameSpecifier::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
             return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
%extend lldb::SBTypeSummary {
         PyObject *lldb::SBTypeSummary::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
             return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
%extend lldb::SBTypeSynthetic {
         PyObject *lldb::SBTypeSynthetic::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelBrief);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
             return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
%extend lldb::SBThread {
         PyObject *lldb::SBThread::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
     %pythoncode %{
         def __eq__(self, rhs):
             if not isinstance(rhs, type(self)):
                 return False
 
             return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)
%extend lldb::SBValue {
         PyObject *lldb::SBValue::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBValueList {
         %nothreadallow;
         PyObject *lldb::SBValueList::__str__ (){
                 lldb::SBStream description;
                 const size_t n = $self->GetSize();
                 if (n)
                 {
                     for (size_t i=0; i<n; ++i)
                         $self->GetValueAtIndex(i).GetDescription(description);
                 }
                 else
                 {
                     description.Printf("<empty> lldb.SBValueList()");
                 }
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 %extend lldb::SBWatchpoint {
         %nothreadallow;
         PyObject *lldb::SBWatchpoint::__str__ (){
                 lldb::SBStream description;
                 $self->GetDescription (description, lldb::eDescriptionLevelVerbose);
                 const char *desc = description.GetData();
                 size_t desc_len = description.GetSize();
                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
                     --desc_len;
                 if (desc_len > 0)
-                    return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
+                    return PythonString(llvm::StringRef(desc, desc_len)).release();
                 else
-                    return lldb_private::PythonString("").release();
+                    return PythonString("").release();
         }
         %clearnothreadallow;
 }
 
 
 // %extend lldb::SBDebugger {
 //         // FIXME: We can't get the callback and baton
 //         PyObject *lldb::SBDebugger (){

lldb/scripts/Python/python-typemaps.swig

 /* Typemap definitions, to allow SWIG to properly handle 'char**' data types. */
 
 %typemap(in) char ** {
-  using namespace lldb_private;
+
   /* Check if is a list  */
   if (PythonList::Check($input)) {
     PythonList list(PyRefType::Borrowed, $input);
     int size = list.GetSize();
     int i = 0;
     $1 = (char**)malloc((size+1)*sizeof(char*));
     for (i = 0; i < size; i++) {
       PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
if (PythonList::Check($input)) {
     PyErr_SetString(PyExc_TypeError,"not a list");
     return NULL;
   }
 }
 
 %typemap(typecheck) char ** {
   /* Check if is a list  */
   $1 = 1;
-  using namespace lldb_private;
+
   if (PythonList::Check($input)) {
     PythonList list(PyRefType::Borrowed, $input);
     int size = list.GetSize();
     int i = 0;
     for (i = 0; i < size; i++) {
       PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
       if (!s.IsAllocated()) { $1 = 0; }
     }
   }
   else
   {
     $1 = ( ($input == Py_None) ? 1 : 0);
   }
 }
 
 %typemap(freearg) char** {
   free((char *) $1);
 }
 
 %typemap(out) char** {
   int len;
   int i;
   len = 0;
   while ($1[len]) len++;
-  using namespace lldb_private;
+
   PythonList list(len);
   for (i = 0; i < len; i++)
     list.SetItemAtIndex(i, PythonString($1[i]));
   $result = list.release();
 }
 
 
 %typemap(in) lldb::tid_t {
-  using namespace lldb_private;
+
   if (PythonInteger::Check($input))
   {
     PythonInteger py_int(PyRefType::Borrowed, $input);
     $1 = static_cast<lldb::tid_t>(py_int.GetInteger());
   }
   else
   {
     PyErr_SetString(PyExc_ValueError, "Expecting an integer");
     return nullptr;
   }
 }
 
 %typemap(in) lldb::StateType {
-  using namespace lldb_private;
+
   if (PythonInteger::Check($input))
   {
     PythonInteger py_int(PyRefType::Borrowed, $input);
     int64_t state_type_value = py_int.GetInteger() ;
 
     if (state_type_value > lldb::StateType::kLastStateType) {
       PyErr_SetString(PyExc_ValueError, "Not a valid StateType value");
       return nullptr;

 // as char data instead of byte data.
 %typemap(in) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
 
 // Return the char buffer.  Discarding any previous return result
 // See also SBThread::GetStopDescription.
 %typemap(argout) (char *dst, size_t dst_len) {
    Py_XDECREF($result);   /* Blow away any previous result */
    if (result == 0) {
-      lldb_private::PythonString string("");
+      PythonString string("");
       $result = string.release();
       Py_INCREF($result);
    } else {
       llvm::StringRef ref(static_cast<const char*>($1), result);
-      lldb_private::PythonString string(ref);
+      PythonString string(ref);
       $result = string.release();
    }
    free($1);
 }
 // SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
 // as char data instead of byte data.
 %typemap(argout) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
 
 
 // typemap for an outgoing buffer
 // See also SBEvent::SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len).
 // Ditto for SBProcess::PutSTDIN(const char *src, size_t src_len).
 %typemap(in) (const char *cstr, uint32_t cstr_len),
              (const char *src, size_t src_len) {
-   using namespace lldb_private;
+
    if (PythonString::Check($input)) {
       PythonString str(PyRefType::Borrowed, $input);
       $1 = (char*)str.GetString().data();
       $2 = str.GetSize();
    }
    else if(PythonByteArray::Check($input)) {
       PythonByteArray bytearray(PyRefType::Borrowed, $input);
       $1 = (char*)bytearray.GetBytes().data();
       $2 = bytearray.GetSize();
    }
    else if (PythonBytes::Check($input)) {
       PythonBytes bytes(PyRefType::Borrowed, $input);
       $1 = (char*)bytes.GetBytes().data();
       $2 = bytes.GetSize();
    }
    else {
       PyErr_SetString(PyExc_ValueError, "Expecting a string");
       return NULL;
    }
 }
 // For SBProcess::WriteMemory, SBTarget::GetInstructions and SBDebugger::DispatchInput.
 %typemap(in) (const void *buf, size_t size),
              (const void *data, size_t data_len) {
-   using namespace lldb_private;
+
    if (PythonString::Check($input)) {
       PythonString str(PyRefType::Borrowed, $input);
       $1 = (void*)str.GetString().data();
       $2 = str.GetSize();
    }
    else if(PythonByteArray::Check($input)) {
       PythonByteArray bytearray(PyRefType::Borrowed, $input);
       $1 = (void*)bytearray.GetBytes().data();

 // Return the buffer.  Discarding any previous return result
 // See also SBProcess::ReadMemory.
 %typemap(argout) (void *buf, size_t size) {
    Py_XDECREF($result);   /* Blow away any previous result */
    if (result == 0) {
       $result = Py_None;
       Py_INCREF($result);
    } else {
-      lldb_private::PythonBytes bytes(static_cast<const uint8_t*>($1), result);
+      PythonBytes bytes(static_cast<const uint8_t*>($1), result);
       $result = bytes.release();
    }
    free($1);
 }
 
 %{
 namespace {
 template <class T>

 
 %typemap(typecheck) (lldb::LogOutputCallback log_callback, void *baton) {
   $1 = $input == Py_None;
   $1 = $1 || PyCallable_Check(reinterpret_cast<PyObject*>($input));
 }
 
 
 %typemap(in) lldb::FileSP {
-  using namespace lldb_private;
+
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
     return nullptr;
   }
   auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
   if (!sp)
     return nullptr;
   $1 = sp;
 }
 
 %typemap(in) lldb::FileSP FORCE_IO_METHODS {
-  using namespace lldb_private;
+
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
     return nullptr;
   }
   auto sp = unwrapOrSetPythonException(py_file.ConvertToFileForcingUseOfScriptingIOMethods());
   if (!sp)
     return nullptr;
   $1 = sp;
 }
 
 %typemap(in) lldb::FileSP BORROWED {
- using namespace lldb_private;
+
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
     return nullptr;
   }
   auto sp = unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
   if (!sp)
     return nullptr;
   $1 = sp;
 }
 
 %typemap(in) lldb::FileSP BORROWED_FORCE_IO_METHODS {
-  using namespace lldb_private;
+
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
     return nullptr;
   }
   auto sp = unwrapOrSetPythonException(py_file.ConvertToFileForcingUseOfScriptingIOMethods(/*borrowed=*/true));
   if (!sp)
     return nullptr;
   $1 = sp;
 }
 
 %typecheck(SWIG_TYPECHECK_POINTER) lldb::FileSP {
-  if (lldb_private::PythonFile::Check($input)) {
+  if (PythonFile::Check($input)) {
     $1 = 1;
   } else {
     PyErr_Clear();
     $1 = 0;
   }
 }
 
 %typemap(out) lldb::FileSP {
-  using namespace lldb_private;
+
   $result = nullptr;
   lldb::FileSP &sp = $1;
   if (sp) {
     PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp));
     if (!pyfile.IsValid())
       return nullptr;
     $result = pyfile.release();
   }
   if (!$result)
   {
       $result = Py_None;
       Py_INCREF(Py_None);
   }
 }
 
 %typemap(in) (const char* string, int len) {
-    using namespace lldb_private;
+
     if ($input == Py_None)
     {
         $1 = NULL;
         $2 = 0;
     }
     else if (PythonString::Check($input))
     {
         PythonString py_str(PyRefType::Borrowed, $input);

lldb/scripts/Python/python-wrapper.swig

 LLDBSwigPythonBreakpointCallbackFunction
 (
     const char *python_function_name,
     const char *session_dictionary_name,
     const lldb::StackFrameSP& frame_sp,
     const lldb::BreakpointLocationSP& bp_loc_sp
 )
 {
-    using namespace lldb_private;
+
     lldb::SBFrame sb_frame (frame_sp);
     lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
 
     bool stop_at_breakpoint = 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);

 LLDBSwigPythonWatchpointCallbackFunction
 (
     const char *python_function_name,
     const char *session_dictionary_name,
     const lldb::StackFrameSP& frame_sp,
     const lldb::WatchpointSP& wp_sp
 )
 {
-    using namespace lldb_private;
+
     lldb::SBFrame sb_frame (frame_sp);
     lldb::SBWatchpoint sb_wp(wp_sp);
 
     bool stop_at_watchpoint = true;
 
     PyErr_Cleaner py_err_cleaner(true);
 
     auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
(
     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
 )
 {
-    using namespace lldb_private;
+
     lldb::SBValue sb_value (valobj_sp);
     lldb::SBTypeSummaryOptions sb_options(options_sp.get());
 
     retval.clear();
 
     if (!python_function_name || !session_dictionary)
         return false;
 

 SWIGEXPORT void*
 LLDBSwigPythonCreateSyntheticProvider
 (
     const char *python_class_name,
     const char *session_dictionary_name,
     const lldb::ValueObjectSP& valobj_sp
 )
 {
-    using namespace lldb_private;
+
 
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     PyErr_Cleaner py_err_cleaner(true);
 
     auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name,dict);
 

 SWIGEXPORT void*
 LLDBSwigPythonCreateCommandObject
 (
     const char *python_class_name,
     const char *session_dictionary_name,
     const lldb::DebuggerSP debugger_sp
 )
 {
-    using namespace lldb_private;
+
 
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     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())

 (
     const char *python_class_name,
     const char *session_dictionary_name,
     lldb_private::StructuredDataImpl *args_impl,
     std::string &error_string,
     const lldb::ThreadPlanSP& thread_plan_sp
 )
 {
-    using namespace lldb_private;
+
 
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     // I do not want the SBThreadPlan to be deallocated when going out of scope because python
     // has ownership of it and will manage memory for this object by itself
     lldb::SBThreadPlan *tp_value = new lldb::SBThreadPlan(thread_plan_sp);
 

 LLDBSWIGPythonCallThreadPlan
 (
     void *implementor,
     const char *method_name,
     lldb_private::Event *event,
     bool &got_error
 )
 {
-    using namespace lldb_private;
+
 
     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())

 LLDBSwigPythonCreateScriptedBreakpointResolver
 (
     const char *python_class_name,
     const char *session_dictionary_name,
     lldb_private::StructuredDataImpl *args_impl,
     lldb::BreakpointSP &breakpoint_sp
 )
 {
-    using namespace lldb_private;
+
 
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     PyErr_Cleaner py_err_cleaner(true);
 
     auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);

 SWIGEXPORT unsigned int
 LLDBSwigPythonCallBreakpointResolver
 (
     void *implementor,
     const char *method_name,
     lldb_private::SymbolContext *sym_ctx
 )
 {
-    using namespace lldb_private;
+
 
     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;
 

 LLDBSwigPython_CallOptionalMember
 (
     PyObject* implementor,
     char* callee_name,
     PyObject* ret_if_not_found = Py_None,
     bool* was_found = NULL
 )
 {
-    using namespace lldb_private;
+
 
     PyErr_Cleaner py_err_cleaner(false);
 
     PythonObject self(PyRefType::Borrowed, static_cast<PyObject*>(implementor));
     auto pfunc = self.ResolveName<PythonCallable>(callee_name);
 
     if (!pfunc.IsAllocated())
     {

 
 SWIGEXPORT size_t
 LLDBSwigPython_CalculateNumChildren
 (
     PyObject *implementor,
     uint32_t max
 )
 {
-    using namespace lldb_private;
+
 
     PythonObject self(PyRefType::Borrowed, implementor);
     auto pfunc = self.ResolveName<PythonCallable>("num_children");
 
     if (!pfunc.IsAllocated())
         return 0;
 
     PythonObject result;

 
 SWIGEXPORT PyObject*
 LLDBSwigPython_GetChildAtIndex
 (
     PyObject *implementor,
     uint32_t idx
 )
 {
-    using namespace lldb_private;
+
     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;
 

 
 SWIGEXPORT int
 LLDBSwigPython_GetIndexOfChildWithName
 (
     PyObject *implementor,
     const char* child_name
 )
 {
-    using namespace lldb_private;
+
     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;
 
(
     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
 )
 {
-    using namespace lldb_private;
+
     lldb::SBCommandReturnObject cmd_retobj_sb(cmd_retobj);
     lldb::SBDebugger debugger_sb(debugger);
     lldb::SBExecutionContext exe_ctx_sb(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);
 

 (
     PyObject *implementor,
     lldb::DebuggerSP& debugger,
     const char* args,
     lldb_private::CommandReturnObject& cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp
 )
 {
-    using namespace lldb_private;
+
     lldb::SBCommandReturnObject cmd_retobj_sb(cmd_retobj);
     lldb::SBDebugger debugger_sb(debugger);
     lldb::SBExecutionContext exe_ctx_sb(exe_ctx_ref_sp);
 
     PyErr_Cleaner py_err_cleaner(true);
 
     PythonObject self(PyRefType::Borrowed, implementor);
     auto pfunc = self.ResolveName<PythonCallable>("__call__");

 SWIGEXPORT void*
 LLDBSWIGPythonCreateOSPlugin
 (
     const char *python_class_name,
     const char *session_dictionary_name,
     const lldb::ProcessSP& process_sp
 )
 {
-    using namespace lldb_private;
+
 
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     PyErr_Cleaner py_err_cleaner(true);
 
     auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);

 
 SWIGEXPORT void*
 LLDBSWIGPython_CreateFrameRecognizer
 (
     const char *python_class_name,
     const char *session_dictionary_name
 )
 {
-    using namespace lldb_private;
+
 
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     PyErr_Cleaner py_err_cleaner(true);
 
     auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);

 
 SWIGEXPORT PyObject*
 LLDBSwigPython_GetRecognizedArguments
 (
     PyObject *implementor,
     const lldb::StackFrameSP& frame_sp
 )
 {
-    using namespace lldb_private;
+
 
     static char callee_name[] = "get_recognized_arguments";
 
     lldb::SBFrame frame_sb(frame_sp);
     PyObject *arg = SBTypeToSWIGWrapper(frame_sb);
 
     PythonString str(callee_name);
     PyObject* result = PyObject_CallMethodObjArgs(implementor, str.get(), arg,
                                                   NULL);
     return result;
 }
 
 SWIGEXPORT void*
 LLDBSWIGPython_GetDynamicSetting (void* module, const char* setting, const lldb::TargetSP& target_sp)
 {
-    using namespace lldb_private;
+
 
     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");
 

 SWIGEXPORT bool
 LLDBSWIGPythonRunScriptKeywordProcess
 (const char* python_function_name,
 const char* session_dictionary_name,
 lldb::ProcessSP& process,
 std::string& output)
 
 {
-    using namespace lldb_private;
+
 
     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);

 SWIGEXPORT bool
 LLDBSWIGPythonRunScriptKeywordThread
 (const char* python_function_name,
 const char* session_dictionary_name,
 lldb::ThreadSP& thread,
 std::string& output)
 
 {
-    using namespace lldb_private;
+
 
     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);

 SWIGEXPORT bool
 LLDBSWIGPythonRunScriptKeywordTarget
 (const char* python_function_name,
 const char* session_dictionary_name,
 lldb::TargetSP& target,
 std::string& output)
 
 {
-    using namespace lldb_private;
+
 
     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);

 SWIGEXPORT bool
 LLDBSWIGPythonRunScriptKeywordFrame
 (const char* python_function_name,
 const char* session_dictionary_name,
 lldb::StackFrameSP& frame,
 std::string& output)
 
 {
-    using namespace lldb_private;
+
 
     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);

 SWIGEXPORT bool
 LLDBSWIGPythonRunScriptKeywordValue
 (const char* python_function_name,
 const char* session_dictionary_name,
 lldb::ValueObjectSP& value,
 std::string& output)
 
 {
-    using namespace lldb_private;
+
 
     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);

 SWIGEXPORT bool
 LLDBSwigPythonCallModuleInit
 (
     const char *python_module_name,
     const char *session_dictionary_name,
     lldb::DebuggerSP& debugger
 )
 {
-    using namespace lldb_private;
+
 
     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);

lldb/scripts/lldb.swig

 #include "lldb/API/SBValueList.h"
 #include "lldb/API/SBVariablesOptions.h"
 #include "lldb/API/SBWatchpoint.h"
 #include "lldb/API/SBUnixSignals.h"
 
 #include "../source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
 
 #include "../scripts/Python/python-swigsafecast.swig"
+
+using namespace lldb_private;
+using namespace lldb_private::python;
+using namespace lldb;
+
 %}
 
 /* Various liblldb typedefs that SWIG needs to know about.  */
 #define __extension__ /* Undefine GCC keyword to make Swig happy when processing glibc's stdint.h. */
 /* The ISO C99 standard specifies that in C++ implementations limit macros such
    as INT32_MAX should only be defined if __STDC_LIMIT_MACROS is. */
 #define __STDC_LIMIT_MACROS
 %include "stdint.i"

lldb/source/Plugins/ScriptInterpreter/Python/CMakeLists.txt

 if(NOT LLDB_PYTHON_RELATIVE_PATH)
   message(FATAL_ERROR "LLDB_PYTHON_RELATIVE_PATH is not set.")
 endif()
 add_definitions(-DLLDB_PYTHON_RELATIVE_LIBDIR="${LLDB_PYTHON_RELATIVE_PATH}")
 
 add_lldb_library(lldbPluginScriptInterpreterPython PLUGIN
   PythonDataObjects.cpp
-  PythonExceptionState.cpp
   ScriptInterpreterPython.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbInterpreter
     lldbTarget
     ${PYTHON_LIBRARY}
 
   LINK_COMPONENTS
     Support
   )

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

 #include "lldb-python.h"
 
 #include "lldb/Host/File.h"
 #include "lldb/Utility/StructuredData.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace lldb_private {
+namespace python {
 
 class PythonObject;
 class PythonBytes;
 class PythonString;
 class PythonList;
 class PythonDictionary;
 class PythonInteger;
 class PythonException;

 
 enum class PyRefType {
   Borrowed, // We are not given ownership of the incoming PyObject.
             // We cannot safely hold it without calling Py_INCREF.
   Owned     // We have ownership of the incoming PyObject.  We should
             // not call Py_INCREF.
 };
 
-namespace python {
 
 // Take a reference that you already own, and turn it into
 // a PythonObject.
 //
 // Most python API methods will return a +1 reference
 // if they succeed or NULL if and only if
 // they set an exception.   Use this to collect such return
 // values, after checking for NULL.

 public:
   NullTerminated(const llvm::Twine &twine) {
     llvm::StringRef ref = twine.toNullTerminatedStringRef(storage);
     str = ref.begin();
   }
   operator const char *() { return str; }
 };
 
-} // namespace python
+inline llvm::Error nullDeref() {
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "A NULL PyObject* was dereferenced");
+}
+
+inline llvm::Error exception(const char *s = nullptr) {
+  return llvm::make_error<PythonException>(s);
+}
+
+inline llvm::Error keyError() {
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "key not in dict");
+}
+
 
 enum class PyInitialValue { Invalid, Empty };
 
 template <typename T, typename Enable = void> struct PythonFormat;
 
 template <> struct PythonFormat<unsigned long long> {
   static constexpr char format = 'K';
   static auto get(unsigned long long value) { return value; }
 };
 
 template <> struct PythonFormat<long long> {
   static constexpr char format = 'L';
   static auto get(long long value) { return value; }
 };
 
+template <> struct PythonFormat<PyObject *> {
+  static constexpr char format = 'O';
+  static auto get(PyObject *value) { return value; }
+};
+
 template <typename T>
 struct PythonFormat<
     T, typename std::enable_if<std::is_base_of<PythonObject, T>::value>::type> {
   static constexpr char format = 'O';
   static auto get(const T &value) { return value.get(); }
 };
 
 class PythonObject {
 public:
   PythonObject() : m_py_obj(nullptr) {}
 
-  PythonObject(PyRefType type, PyObject *py_obj) : m_py_obj(nullptr) {
-    Reset(type, py_obj);
+  PythonObject(PyRefType type, PyObject *py_obj) {
+    m_py_obj = py_obj;
+    // If this is a borrowed reference, we need to convert it to
+    // an owned reference by incrementing it.  If it is an owned
+    // reference (for example the caller allocated it with PyDict_New()
+    // then we must *not* increment it.
+    if (m_py_obj && Py_IsInitialized() && type == PyRefType::Borrowed)
+      Py_XINCREF(m_py_obj);
   }
 
   PythonObject(const PythonObject &rhs)
       : PythonObject(PyRefType::Borrowed, rhs.m_py_obj) {}
 
   PythonObject(PythonObject &&rhs) {
     m_py_obj = rhs.m_py_obj;
     rhs.m_py_obj = nullptr;
   }
 
   ~PythonObject() { Reset(); }
 
   void Reset() {
     if (m_py_obj && Py_IsInitialized())
       Py_DECREF(m_py_obj);
     m_py_obj = nullptr;
   }
 
-  void Reset(PyRefType type, PyObject *py_obj) {
-    if (py_obj == m_py_obj)
-      return;
-
-    if (Py_IsInitialized())
-      Py_XDECREF(m_py_obj);
-
-    m_py_obj = py_obj;
-
-    // If this is a borrowed reference, we need to convert it to
-    // an owned reference by incrementing it.  If it is an owned
-    // reference (for example the caller allocated it with PyDict_New()
-    // then we must *not* increment it.
-    if (m_py_obj && Py_IsInitialized() && type == PyRefType::Borrowed)
-      Py_XINCREF(m_py_obj);
-  }
-
   void Dump() const {
     if (m_py_obj)
       _PyObject_Dump(m_py_obj);
     else
       puts("NULL");
   }
 
   void Dump(Stream &strm) const;
template <typename T> T AsType() const {
     if (!T::Check(m_py_obj))
       return T();
     return T(PyRefType::Borrowed, m_py_obj);
   }
 
   StructuredData::ObjectSP CreateStructuredObject() const;
 
 protected:
-  static llvm::Error nullDeref() {
-    return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                   "A NULL PyObject* was dereferenced");
-  }
-  static llvm::Error exception(const char *s = nullptr) {
-    return llvm::make_error<PythonException>(s);
-  }
-  static llvm::Error keyError() {
-    return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                   "key not in dict");
-  }
 
 #if PY_MAJOR_VERSION < 3
   // The python 2 API declares some arguments as char* that should
   // be const char *, but it doesn't actually modify them.
   static char *py2_const_cast(const char *s) { return const_cast<char *>(s); }
 #else
   static const char *py2_const_cast(const char *s) { return s; }
 #endif
 
 public:
   template <typename... T>
   llvm::Expected<PythonObject> CallMethod(const char *name,
                                           const T &... t) const {
     const char format[] = {'(', PythonFormat<T>::format..., ')', 0};
     PyObject *obj =
         PyObject_CallMethod(m_py_obj, py2_const_cast(name),
                             py2_const_cast(format), PythonFormat<T>::get(t)...);
     if (!obj)
       return exception();
     return python::Take<PythonObject>(obj);
   }
 
   template <typename... T>
   llvm::Expected<PythonObject> Call(const T &... t) const {
     const char format[] = {'(', PythonFormat<T>::format..., ')', 0};
     PyObject *obj = PyObject_CallFunction(m_py_obj, py2_const_cast(format),
                                           PythonFormat<T>::get(t)...);
     if (!obj)
       return exception();
     return python::Take<PythonObject>(obj);
   }
 
   llvm::Expected<PythonObject> GetAttribute(const llvm::Twine &name) const {
-    using namespace python;
     if (!m_py_obj)
       return nullDeref();
     PyObject *obj = PyObject_GetAttrString(m_py_obj, NullTerminated(name));
     if (!obj)
       return exception();
     return python::Take<PythonObject>(obj);
   }
 
if (r < 0)
       return exception();
     return !!r;
   }
 
 protected:
   PyObject *m_py_obj;
 };
 
-namespace python {
 
 // This is why C++ needs monads.
 template <typename T> llvm::Expected<T> As(llvm::Expected<PythonObject> &&obj) {
   if (!obj)
     return obj.takeError();
   if (!T::Check(obj.get().get()))
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "type error");
   return T(PyRefType::Borrowed, std::move(obj.get().get()));
 }
 
 template <> llvm::Expected<bool> As<bool>(llvm::Expected<PythonObject> &&obj);
 
 template <>
 llvm::Expected<long long> As<long long>(llvm::Expected<PythonObject> &&obj);
 
 template <>
 llvm::Expected<std::string> As<std::string>(llvm::Expected<PythonObject> &&obj);
 
-} // namespace python
 
 template <class T> class TypedPythonObject : public PythonObject {
 public:
   // override to perform implicit type conversions on Reset
   // This can be eliminated once we drop python 2 support.
   static void Convert(PyRefType &type, PyObject *&py_obj) {}
 
-  void Reset() { PythonObject::Reset(); }
-
-  void Reset(PyRefType type, PyObject *py_obj) = delete;
-
   TypedPythonObject(PyRefType type, PyObject *py_obj) {
     if (!py_obj)
       return;
     T::Convert(type, py_obj);
     if (T::Check(py_obj))
-      PythonObject::Reset(type, py_obj);
+      PythonObject::operator=(PythonObject(type, py_obj));
     else if (type == PyRefType::Owned)
       Py_DECREF(py_obj);
   }
 
   TypedPythonObject() {}
 };
 
 class PythonBytes : public TypedPythonObject<PythonBytes> {

 public:
   static char ID;
   const char *toCString() const;
   PythonException(const char *caller = nullptr);
   void Restore();
   ~PythonException();
   void log(llvm::raw_ostream &OS) const override;
   std::error_code convertToErrorCode() const override;
+  bool Matches(PyObject *exc) const;
+  std::string ReadBacktrace(bool recursing = false) const;
 };
 
 // This extracts the underlying T out of an Expected<T> and returns it.
 // If the Expected is an Error instead of a T, that error will be converted
 // into a python exception, and this will return a default-constructed T.
 //
 // This is appropriate for use right at the boundary of python calling into
 // C++, such as in a SWIG typemap.   In such a context you should simply
template <typename T> T unwrapOrSetPythonException(llvm::Expected<T> expected) {
   llvm::handleAllErrors(
       expected.takeError(), [](PythonException &E) { E.Restore(); },
       [](const llvm::ErrorInfoBase &E) {
         PyErr_SetString(PyExc_Exception, E.message().c_str());
       });
   return T();
 }
 
-namespace python {
 // This is only here to help incrementally migrate old, exception-unsafe
 // code.
 template <typename T> T unwrapIgnoringErrors(llvm::Expected<T> expected) {
   if (expected)
     return std::move(expected.get());
   llvm::consumeError(expected.takeError());
   return T();
 }
-} // namespace python
 
+llvm::Expected<PythonObject> runStringOneLine(const llvm::Twine &string,
+                                              const PythonDictionary &globals,
+                                              const PythonDictionary &locals);
+
+llvm::Expected<PythonObject> runStringMultiLine(const llvm::Twine &string,
+                                                const PythonDictionary &globals,
+                                                const PythonDictionary &locals);
+
+// Sometimes the best way to interact with a python interpreter is
+// to run some python code.   You construct a PythonScript with
+// script string and a function name, and you get a C++ callable
+// object that calls the python function.
+//
+// Example:
+//
+// const char script[] = R"(
+// def foo(x, y):
+//    ....
+// )";
+//
+// Expected<PythonObject> cpp_foo_wrapper(PythonObject x, PythonObject y) {
+//   // no need to synchronize access to this global, we already have the GIL
+//   static PythonScript foo(script, "foo")
+//   return  foo(x, y);
+// }
+class PythonScript {
+  const char *script;
+  PythonCallable function;
+
+  llvm::Error Init();
+
+public:
+  PythonScript(const char *script) : script(script), function() {}
+
+  template <typename... Args>
+  llvm::Expected<PythonObject> operator()(Args &&... args) {
+    llvm::Error e = Init();
+    if (e)
+      return std::move(e);
+    return function.Call(std::forward<Args>(args)...);
+  }
+};
+
+} // namespace python
 } // namespace lldb_private
 
 #endif
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H

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

 }
 
 size_t PythonBytes::GetSize() const {
   if (!IsValid())
     return 0;
   return PyBytes_Size(m_py_obj);
 }
 
 void PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes) {
   const char *data = reinterpret_cast<const char *>(bytes.data());
-  PyObject *py_bytes = PyBytes_FromStringAndSize(data, bytes.size());
-  PythonObject::Reset(PyRefType::Owned, py_bytes);
+  *this = Take<PythonBytes>(PyBytes_FromStringAndSize(data, bytes.size()));
 }
 
 StructuredData::StringSP PythonBytes::CreateStructuredString() const {
   StructuredData::StringSP result(new StructuredData::String);
   Py_ssize_t size;
   char *c;
   PyBytes_AsStringAndSize(m_py_obj, &c, &size);
   result->SetValue(std::string(c, size));
   return result;
if (overflow != 0) {
       result = static_cast<int64_t>(uval);
     }
     return result;
   }
   return UINT64_MAX;
 }
 
 void PythonInteger::SetInteger(int64_t value) {
-  PythonObject::Reset(PyRefType::Owned, PyLong_FromLongLong(value));
+  *this = Take<PythonInteger>(PyLong_FromLongLong(value));
 }
 
 StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
   StructuredData::IntegerSP result(new StructuredData::Integer);
   result->SetValue(GetInteger());
   return result;
 }
 
 // PythonBoolean
 
 PythonBoolean::PythonBoolean(bool value) {
   SetValue(value);
 }
 
 bool PythonBoolean::Check(PyObject *py_obj) {
   return py_obj ? PyBool_Check(py_obj) : false;
 }
 
 bool PythonBoolean::GetValue() const {
   return m_py_obj ? PyObject_IsTrue(m_py_obj) : false;
 }
 
 void PythonBoolean::SetValue(bool value) {
-  PythonObject::Reset(PyRefType::Owned, PyBool_FromLong(value));
+  *this = Take<PythonBoolean>(PyBool_FromLong(value));
 }
 
 StructuredData::BooleanSP PythonBoolean::CreateStructuredBoolean() const {
   StructuredData::BooleanSP result(new StructuredData::Boolean);
   result->SetValue(GetValue());
   return result;
 }
 
for parameter in signature(f).parameters.values():
         elif kind == Parameter.VAR_POSITIONAL:
             varargs = True
         elif kind in (Parameter.KEYWORD_ONLY,
                       Parameter.VAR_KEYWORD):
             pass
         else:
             raise Exception(f'unknown parameter kind: {kind}')
     return ArgInfo(count, varargs, ismethod(f))
+_function_ = get_arg_info
 )";
 #endif
 
 Expected<PythonCallable::ArgInfo> PythonCallable::GetArgInfo() const {
   ArgInfo result = {};
   if (!IsValid())
     return nullDeref();
 
 #if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
 
-  // this global is protected by the GIL
-  static PythonCallable get_arg_info;
-
-  if (!get_arg_info.IsValid()) {
-    PythonDictionary globals(PyInitialValue::Empty);
-
-    auto builtins = PythonModule::BuiltinsModule();
-    Error error = globals.SetItem("__builtins__", builtins);
-    if (error)
-      return std::move(error);
-    PyObject *o = PyRun_String(get_arg_info_script, Py_file_input,
-                               globals.get(), globals.get());
-    if (!o)
-      return exception();
-    Take<PythonObject>(o);
-    auto function = As<PythonCallable>(globals.GetItem("get_arg_info"));
-    if (!function)
-      return function.takeError();
-    get_arg_info = std::move(function.get());
-  }
-
-  Expected<PythonObject> pyarginfo = get_arg_info.Call(*this);
+  // no need to synchronize access to this global, we already have the GIL
+  static PythonScript get_arg_info(get_arg_info_script);
+  Expected<PythonObject> pyarginfo = get_arg_info(*this);
   if (!pyarginfo)
     return pyarginfo.takeError();
   result.count = cantFail(As<long long>(pyarginfo.get().GetAttribute("count")));
   result.has_varargs =
       cantFail(As<bool>(pyarginfo.get().GetAttribute("has_varargs")));
   bool is_method =
       cantFail(As<bool>(pyarginfo.get().GetAttribute("is_bound_method")));
   result.max_positional_args =

 }
 
 void PythonException::log(llvm::raw_ostream &OS) const { OS << toCString(); }
 
 std::error_code PythonException::convertToErrorCode() const {
   return llvm::inconvertibleErrorCode();
 }
 
+bool PythonException::Matches(PyObject *exc) const {
+  return PyErr_GivenExceptionMatches(m_exception_type, exc);
+}
+
+const char read_exception_script[] = R"(
+import sys
+from traceback import print_exception
+if sys.version_info.major < 3:
+  from StringIO import StringIO
+else:
+  from io import StringIO
+def read_exception(exc_type, exc_value, tb):
+  f = StringIO()
+  print_exception(exc_type, exc_value, tb, file=f)
+  return f.getvalue()
+_function_ = read_exception  
+)";
+
+std::string PythonException::ReadBacktrace(bool recursing) const {
+
+  if (!m_traceback)
+    return toCString();
+
+  // no need to synchronize access to this global, we already have the GIL
+  static PythonScript read_exception(read_exception_script);
+
+  Expected<std::string> backtrace = As<std::string>(
+      read_exception(m_exception_type, m_exception, m_traceback));
+
+  if (!backtrace) {
+    Twine message =
+        Twine(toCString()) + "\n" +
+        "Traceback unavailble, an error occurred while reading it:\n";
+    if (recursing)
+      return (message + llvm::toString(backtrace.takeError())).str();
+
+    std::string backtrace2;
+    Error error =
+        llvm::handleErrors(backtrace.takeError(), [&](PythonException &E) {
+          backtrace2 = E.ReadBacktrace(true);
+        });
+    if (error)
+      backtrace2 = llvm::toString(std::move(error));
+    return (message + backtrace2).str();
+  }
+
+  return std::move(backtrace.get());
+}
+
 char PythonException::ID = 0;
 
 llvm::Expected<File::OpenOptions>
 GetOptionsForPyObject(const PythonObject &obj) {
 #if PY_MAJOR_VERSION >= 3
   auto options = File::OpenOptions(0);
   auto readable = As<bool>(obj.CallMethod("readable"));
   if (!readable)

 #endif
 
   if (!file_obj)
     return exception();
 
   return Take<PythonFile>(file_obj);
 }
 
+Error PythonScript::Init() {
+  if (function.IsValid())
+    return Error::success();
+
+  PythonDictionary globals(PyInitialValue::Empty);
+  auto builtins = PythonModule::BuiltinsModule();
+  Error error = globals.SetItem("__builtins__", builtins);
+  if (error)
+    return error;
+  PyObject *o =
+      PyRun_String(script, Py_file_input, globals.get(), globals.get());
+  if (!o)
+    return exception();
+  Take<PythonObject>(o);
+  auto f = As<PythonCallable>(globals.GetItem("_function_"));
+  if (!f)
+    return f.takeError();
+  function = std::move(f.get());
+
+  return Error::success();
+}
+
+llvm::Expected<PythonObject>
+python::runStringOneLine(const llvm::Twine &string,
+                         const PythonDictionary &globals,
+                         const PythonDictionary &locals) {
+  if (!globals.IsValid() || !locals.IsValid())
+    return nullDeref();
+
+  PyObject *code =
+      Py_CompileString(NullTerminated(string), "<string>", Py_eval_input);
+  if (!code) {
+    PyErr_Clear();
+    code =
+        Py_CompileString(NullTerminated(string), "<string>", Py_single_input);
+  }
+  if (!code)
+    return exception();
+  auto code_ref = Take<PythonObject>(code);
+
+#if PY_MAJOR_VERSION < 3
+  PyObject *result =
+      PyEval_EvalCode((PyCodeObject *)code, globals.get(), locals.get());
+#else
+  PyObject *result = PyEval_EvalCode(code, globals.get(), locals.get());
+#endif
+
+  if (!result)
+    return exception();
+
+  return Take<PythonObject>(result);
+}
+
+llvm::Expected<PythonObject>
+python::runStringMultiLine(const llvm::Twine &string,
+                           const PythonDictionary &globals,
+                           const PythonDictionary &locals) {
+  if (!globals.IsValid() || !locals.IsValid())
+    return nullDeref();
+  PyObject *result = PyRun_String(NullTerminated(string), Py_file_input,
+                                  globals.get(), locals.get());
+  if (!result)
+    return exception();
+  return Take<PythonObject>(result);
+}
+
 #endif

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

-//===-- PythonExceptionState.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_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONEXCEPTIONSTATE_H
-#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONEXCEPTIONSTATE_H
-
-#ifndef LLDB_DISABLE_PYTHON
-
-#include "PythonDataObjects.h"
-
-namespace lldb_private {
-
-class PythonExceptionState {
-public:
-  explicit PythonExceptionState(bool restore_on_exit);
-  ~PythonExceptionState();
-
-  void Acquire(bool restore_on_exit);
-
-  void Restore();
-
-  void Discard();
-
-  void Reset();
-
-  static bool HasErrorOccurred();
-
-  bool IsError() const;
-
-  PythonObject GetType() const;
-
-  PythonObject GetValue() const;
-
-  PythonObject GetTraceback() const;
-
-  std::string Format() const;
-
-private:
-  std::string ReadBacktrace() const;
-
-  bool m_restore_on_exit;
-
-  PythonObject m_type;
-  PythonObject m_value;
-  PythonObject m_traceback;
-};
-}
-
-#endif
-
-#endif

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

-//===-- PythonExceptionState.cpp --------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLDB_DISABLE_PYTHON
-
-// LLDB Python header must be included first
-#include "lldb-python.h"
-
-#include "PythonExceptionState.h"
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace lldb_private;
-
-PythonExceptionState::PythonExceptionState(bool restore_on_exit)
-    : m_restore_on_exit(restore_on_exit) {
-  Acquire(restore_on_exit);
-}
-
-PythonExceptionState::~PythonExceptionState() {
-  if (m_restore_on_exit)
-    Restore();
-}
-
-void PythonExceptionState::Acquire(bool restore_on_exit) {
-  // If a state is already acquired, the user needs to decide whether they want
-  // to discard or restore it.  Don't allow the potential silent loss of a
-  // valid state.
-  assert(!IsError());
-
-  if (!HasErrorOccurred())
-    return;
-
-  PyObject *py_type = nullptr;
-  PyObject *py_value = nullptr;
-  PyObject *py_traceback = nullptr;
-  PyErr_Fetch(&py_type, &py_value, &py_traceback);
-  // PyErr_Fetch clears the error flag.
-  assert(!HasErrorOccurred());
-
-  // Ownership of the objects returned by `PyErr_Fetch` is transferred to us.
-  m_type.Reset(PyRefType::Owned, py_type);
-  m_value.Reset(PyRefType::Owned, py_value);
-  m_traceback.Reset(PyRefType::Owned, py_traceback);
-  m_restore_on_exit = restore_on_exit;
-}
-
-void PythonExceptionState::Restore() {
-  if (m_type.IsValid()) {
-    // The documentation for PyErr_Restore says "Do not pass a null type and
-    // non-null value or traceback.  So only restore if type was non-null to
-    // begin with.  In this case we're passing ownership back to Python so
-    // release them all.
-    PyErr_Restore(m_type.release(), m_value.release(), m_traceback.release());
-  }
-
-  // After we restore, we should not hold onto the exception state.  Demand
-  // that it be re-acquired.
-  Discard();
-}
-
-void PythonExceptionState::Discard() {
-  m_type.Reset();
-  m_value.Reset();
-  m_traceback.Reset();
-}
-
-void PythonExceptionState::Reset() {
-  if (m_restore_on_exit)
-    Restore();
-  else
-    Discard();
-}
-
-bool PythonExceptionState::HasErrorOccurred() { return PyErr_Occurred(); }
-
-bool PythonExceptionState::IsError() const {
-  return m_type.IsValid() || m_value.IsValid() || m_traceback.IsValid();
-}
-
-PythonObject PythonExceptionState::GetType() const { return m_type; }
-
-PythonObject PythonExceptionState::GetValue() const { return m_value; }
-
-PythonObject PythonExceptionState::GetTraceback() const { return m_traceback; }
-
-std::string PythonExceptionState::Format() const {
-  // Don't allow this function to modify the error state.
-  PythonExceptionState state(true);
-
-  std::string backtrace = ReadBacktrace();
-  if (!IsError())
-    return std::string();
-
-  // It's possible that ReadPythonBacktrace generated another exception. If
-  // this happens we have to clear the exception, because otherwise
-  // PyObject_Str() will assert below.  That's why we needed to do the save /
-  // restore at the beginning of this function.
-  PythonExceptionState bt_error_state(false);
-
-  std::string error_string;
-  llvm::raw_string_ostream error_stream(error_string);
-  error_stream << m_value.Str().GetString() << "\n";
-
-  if (!bt_error_state.IsError()) {
-    // If we were able to read the backtrace, just append it.
-    error_stream << backtrace << "\n";
-  } else {
-    // Otherwise, append some information about why we were unable to obtain
-    // the backtrace.
-    PythonString bt_error = bt_error_state.GetValue().Str();
-    error_stream << "An error occurred while retrieving the backtrace: "
-                 << bt_error.GetString() << "\n";
-  }
-  return error_stream.str();
-}
-
-std::string PythonExceptionState::ReadBacktrace() const {
-  std::string retval("backtrace unavailable");
-
-  auto traceback_module = PythonModule::ImportModule("traceback");
-#if PY_MAJOR_VERSION >= 3
-  auto stringIO_module = PythonModule::ImportModule("io");
-#else
-  auto stringIO_module = PythonModule::ImportModule("StringIO");
-#endif
-  if (!m_traceback.IsAllocated())
-    return retval;
-
-  if (!traceback_module.IsAllocated() || !stringIO_module.IsAllocated())
-    return retval;
-
-  auto stringIO_builder =
-      stringIO_module.ResolveName<PythonCallable>("StringIO");
-  if (!stringIO_builder.IsAllocated())
-    return retval;
-
-  auto stringIO_buffer = stringIO_builder();
-  if (!stringIO_buffer.IsAllocated())
-    return retval;
-
-  auto printTB = traceback_module.ResolveName<PythonCallable>("print_tb");
-  if (!printTB.IsAllocated())
-    return retval;
-
-  auto printTB_result =
-      printTB(m_traceback.get(), Py_None, stringIO_buffer.get());
-  auto stringIO_getvalue =
-      stringIO_buffer.ResolveName<PythonCallable>("getvalue");
-  if (!stringIO_getvalue.IsAllocated())
-    return retval;
-
-  auto printTB_string = stringIO_getvalue().AsType<PythonString>();
-  if (!printTB_string.IsAllocated())
-    return retval;
-
-  llvm::StringRef string_data(printTB_string.GetString());
-  retval.assign(string_data.data(), string_data.size());
-
-  return retval;
-}
-
-#endif

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

 // Python is disabled in this build
 
 #else
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
-#include "PythonExceptionState.h"
 #include "ScriptInterpreterPythonImpl.h"
 
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/WatchpointOptions.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Debugger.h"

 #include <mutex>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::python;
+using llvm::Expected;
 
 // Defined in the SWIG source file
 #if PY_MAJOR_VERSION >= 3
 extern "C" PyObject *PyInit__lldb(void);
 
 #define LLDBSwigPyInit PyInit__lldb
 
 #else
bool ScriptInterpreterPythonImpl::EnterSession(uint16_t on_entry_flags,
   }
 
   if (PyErr_Occurred())
     PyErr_Clear();
 
   return true;
 }
 
-PythonObject &ScriptInterpreterPythonImpl::GetMainModule() {
+PythonModule &ScriptInterpreterPythonImpl::GetMainModule() {
   if (!m_main_module.IsValid())
-    m_main_module.Reset(PyRefType::Borrowed, PyImport_AddModule("__main__"));
+    m_main_module = unwrapIgnoringErrors(PythonModule::Import("__main__"));
   return m_main_module;
 }
 
 PythonDictionary &ScriptInterpreterPythonImpl::GetSessionDictionary() {
   if (m_session_dict.IsValid())
     return m_session_dict;
 
   PythonObject &main_module = GetMainModule();
if (state) {
       return true;
     }
   }
   LLDB_LOGF(log,
             "ScriptInterpreterPythonImpl::Interrupt() python code not running, "
             "can't interrupt");
   return false;
 }
+
 bool ScriptInterpreterPythonImpl::ExecuteOneLineWithReturn(
     llvm::StringRef in_string, ScriptInterpreter::ScriptReturnType return_type,
     void *ret_value, const ExecuteScriptOptions &options) {
 
   Locker locker(this,
                 Locker::AcquireLock | Locker::InitSession |
                     (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
                     Locker::NoSTDIN,
                 Locker::FreeAcquiredLock | Locker::TearDownSession);
 
-  PythonObject py_return;
-  PythonObject &main_module = GetMainModule();
-  PythonDictionary globals(PyRefType::Borrowed,
-                           PyModule_GetDict(main_module.get()));
-  PythonObject py_error;
-  bool ret_success = false;
-  int success;
+  PythonModule &main_module = GetMainModule();
+  PythonDictionary globals = main_module.GetDictionary();
 
   PythonDictionary locals = GetSessionDictionary();
-
-  if (!locals.IsValid()) {
+  if (!locals.IsValid())
     locals = unwrapIgnoringErrors(
         As<PythonDictionary>(globals.GetAttribute(m_dictionary_name)));
-  }
-
   if (!locals.IsValid())
     locals = globals;
 
-  py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-  if (py_error.IsValid())
-    PyErr_Clear();
+  Expected<PythonObject> maybe_py_return =
+      runStringOneLine(in_string, globals, locals);
 
-  std::string as_string = in_string.str();
-  { // scope for PythonInputReaderManager
-    // PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
-    py_return.Reset(PyRefType::Owned,
-                    PyRun_String(as_string.c_str(), Py_eval_input,
-                                 globals.get(), locals.get()));
-    if (!py_return.IsValid()) {
-      py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-      if (py_error.IsValid())
+  if (!maybe_py_return) {
+    llvm::handleAllErrors(
+        maybe_py_return.takeError(),
+        [&](PythonException &E) {
+          E.Restore();
+          if (options.GetMaskoutErrors()) {
+            if (E.Matches(PyExc_SyntaxError)) {
+              PyErr_Print();
+            }
             PyErr_Clear();
-
-      py_return.Reset(PyRefType::Owned,
-                      PyRun_String(as_string.c_str(), Py_single_input,
-                                   globals.get(), locals.get()));
           }
+        },
+        [](const llvm::ErrorInfoBase &E) {});
+    return false;
   }
 
-  if (py_return.IsValid()) {
-    switch (return_type) {
-    case eScriptReturnTypeCharPtr: // "char *"
-    {
-      const char format[3] = "s#";
-      success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
-      break;
-    }
-    case eScriptReturnTypeCharStrOrNone: // char* or NULL if py_return ==
-                                         // Py_None
-    {
-      const char format[3] = "z";
-      success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
-      break;
-    }
-    case eScriptReturnTypeBool: {
-      const char format[2] = "b";
-      success = PyArg_Parse(py_return.get(), format, (bool *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeShortInt: {
-      const char format[2] = "h";
-      success = PyArg_Parse(py_return.get(), format, (short *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeShortIntUnsigned: {
-      const char format[2] = "H";
-      success =
-          PyArg_Parse(py_return.get(), format, (unsigned short *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeInt: {
-      const char format[2] = "i";
-      success = PyArg_Parse(py_return.get(), format, (int *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeIntUnsigned: {
-      const char format[2] = "I";
-      success = PyArg_Parse(py_return.get(), format, (unsigned int *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeLongInt: {
-      const char format[2] = "l";
-      success = PyArg_Parse(py_return.get(), format, (long *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeLongIntUnsigned: {
-      const char format[2] = "k";
-      success =
-          PyArg_Parse(py_return.get(), format, (unsigned long *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeLongLong: {
-      const char format[2] = "L";
-      success = PyArg_Parse(py_return.get(), format, (long long *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeLongLongUnsigned: {
-      const char format[2] = "K";
-      success =
-          PyArg_Parse(py_return.get(), format, (unsigned long long *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeFloat: {
-      const char format[2] = "f";
-      success = PyArg_Parse(py_return.get(), format, (float *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeDouble: {
-      const char format[2] = "d";
-      success = PyArg_Parse(py_return.get(), format, (double *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeChar: {
-      const char format[2] = "c";
-      success = PyArg_Parse(py_return.get(), format, (char *)ret_value);
-      break;
-    }
-    case eScriptReturnTypeOpaqueObject: {
-      success = true;
-      PyObject *saved_value = py_return.get();
-      Py_XINCREF(saved_value);
-      *((PyObject **)ret_value) = saved_value;
-      break;
-    }
-    }
-
-    ret_success = success;
-  }
-
-  py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-  if (py_error.IsValid()) {
-    ret_success = false;
-    if (options.GetMaskoutErrors()) {
-      if (PyErr_GivenExceptionMatches(py_error.get(), PyExc_SyntaxError))
-        PyErr_Print();
-      PyErr_Clear();
-    }
+  PythonObject py_return = std::move(maybe_py_return.get());
+  assert(py_return.IsValid());
+
+    return PyArg_Parse(py_return.get(), format, (char **)ret_value);
+    return PyArg_Parse(py_return.get(), format, (char **)ret_value);
+    return PyArg_Parse(py_return.get(), format, (bool *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (short *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (unsigned short *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (int *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (unsigned int *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (long *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (unsigned long *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (long long *)ret_value);
+    return PyArg_Parse(py_return.get(), format,
+                       (unsigned long long *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (float *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (double *)ret_value);
+    return PyArg_Parse(py_return.get(), format, (char *)ret_value);
+    *((PyObject **)ret_value) = py_return.release();
+    return true;
   }
-
-  return ret_success;
 }
 
 Status ScriptInterpreterPythonImpl::ExecuteMultipleLines(
     const char *in_string, const ExecuteScriptOptions &options) {
-  Status error;
+
+  if (in_string == nullptr)
+    return Status();
 
   Locker locker(this,
                 Locker::AcquireLock | Locker::InitSession |
                     (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
                     Locker::NoSTDIN,
                 Locker::FreeAcquiredLock | Locker::TearDownSession);
 
-  PythonObject return_value;
-  PythonObject &main_module = GetMainModule();
-  PythonDictionary globals(PyRefType::Borrowed,
-                           PyModule_GetDict(main_module.get()));
-  PythonObject py_error;
+  PythonModule &main_module = GetMainModule();
+  PythonDictionary globals = main_module.GetDictionary();
 
   PythonDictionary locals = GetSessionDictionary();
-
   if (!locals.IsValid())
     locals = unwrapIgnoringErrors(
         As<PythonDictionary>(globals.GetAttribute(m_dictionary_name)));
-
   if (!locals.IsValid())
     locals = globals;
 
-  py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-  if (py_error.IsValid())
-    PyErr_Clear();
+  Expected<PythonObject> return_value =
+      runStringMultiLine(in_string, globals, locals);
 
-  if (in_string != nullptr) {
-    PythonObject code_object;
-    code_object.Reset(PyRefType::Owned,
-                      Py_CompileString(in_string, "temp.py", Py_file_input));
-
-    if (code_object.IsValid()) {
-// In Python 2.x, PyEval_EvalCode takes a PyCodeObject, but in Python 3.x, it
-// takes a PyObject.  They are convertible (hence the function
-// PyCode_Check(PyObject*), so we have to do the cast for Python 2.x
-#if PY_MAJOR_VERSION >= 3
-      PyObject *py_code_obj = code_object.get();
-#else
-      PyCodeObject *py_code_obj =
-          reinterpret_cast<PyCodeObject *>(code_object.get());
-#endif
-      return_value.Reset(
-          PyRefType::Owned,
-          PyEval_EvalCode(py_code_obj, globals.get(), locals.get()));
-    }
+  if (!return_value) {
+    llvm::Error error =
+        llvm::handleErrors(return_value.takeError(), [&](PythonException &E) {
+          llvm::Error error = llvm::createStringError(
+              llvm::inconvertibleErrorCode(), E.ReadBacktrace());
+          if (!options.GetMaskoutErrors())
+            E.Restore();
+          return error;
+        });
+    return Status(std::move(error));
   }
 
-  PythonExceptionState exception_state(!options.GetMaskoutErrors());
-  if (exception_state.IsError())
-    error.SetErrorString(exception_state.Format().c_str());
-
-  return error;
+  return Status();
 }
 
 void ScriptInterpreterPythonImpl::CollectDataForBreakpointCommandCallback(
     std::vector<BreakpointOptions *> &bp_options_vec,
     CommandReturnObject &result) {
   m_active_io_handler = eIOHandlerBreakpoint;
   m_debugger.GetCommandInterpreter().GetPythonCommandsFromIOHandler(
       "    ", *this, true, &bp_options_vec);
 }
 
StructuredData::DictionarySP ScriptInterpreterPythonImpl::GetDynamicSettings(
     StructuredData::ObjectSP plugin_module_sp, Target *target,
     const char *setting_name, lldb_private::Status &error) {
   if (!plugin_module_sp || !target || !setting_name || !setting_name[0])
     return StructuredData::DictionarySP();
   StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
   if (!generic)
     return StructuredData::DictionarySP();
 
-  PythonObject reply_pyobj;
   Locker py_lock(this,
                  Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
   TargetSP target_sp(target->shared_from_this());
-  reply_pyobj.Reset(PyRefType::Owned,
-                    (PyObject *)LLDBSWIGPython_GetDynamicSetting(
-                        generic->GetValue(), setting_name, target_sp));
 
-  PythonDictionary py_dict(PyRefType::Borrowed, reply_pyobj.get());
+  auto setting = (PyObject *)LLDBSWIGPython_GetDynamicSetting(
+      generic->GetValue(), setting_name, target_sp);
+
+  if (!setting)
+    return StructuredData::DictionarySP();
+
+  PythonDictionary py_dict =
+      unwrapIgnoringErrors(As<PythonDictionary>(Take<PythonObject>(setting)));
+
+  if (!py_dict)
+    return StructuredData::DictionarySP();
+
   return py_dict.CreateStructuredDictionary();
 }
 
 StructuredData::ObjectSP
 ScriptInterpreterPythonImpl::CreateSyntheticScriptedProvider(
     const char *class_name, lldb::ValueObjectSP valobj) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::ObjectSP();

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

 #include "ScriptInterpreterPython.h"
 
 #include "lldb/Host/Terminal.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 
+using namespace lldb_private::python;
+
 namespace lldb_private {
 class IOHandlerPythonInterpreter;
 class ScriptInterpreterPythonImpl : public ScriptInterpreterPython {
 public:
   friend class IOHandlerPythonInterpreter;
 
   ScriptInterpreterPythonImpl(Debugger &debugger);
 
public:
   }
 
   enum ActiveIOHandler {
     eIOHandlerNone,
     eIOHandlerBreakpoint,
     eIOHandlerWatchpoint
   };
 
-  PythonObject &GetMainModule();
+  PythonModule &GetMainModule();
 
   PythonDictionary &GetSessionDictionary();
 
   PythonDictionary &GetSysModuleDictionary();
 
   bool GetEmbeddedInterpreterModuleObjects();
 
   bool SetStdHandle(lldb::FileSP file, const char *py_name,
                     PythonObject &save_file, const char *mode);
 
   PythonObject m_saved_stdin;
   PythonObject m_saved_stdout;
   PythonObject m_saved_stderr;
-  PythonObject m_main_module;
+  PythonModule m_main_module;
   PythonDictionary m_session_dict;
   PythonDictionary m_sys_module_dict;
   PythonObject m_run_one_line_function;
   PythonObject m_run_one_line_str_global;
   std::string m_dictionary_name;
   ActiveIOHandler m_active_io_handler;
   bool m_session_is_active;
   bool m_pty_slave_is_open;

lldb/unittests/ScriptInterpreter/Python/CMakeLists.txt

 add_lldb_unittest(ScriptInterpreterPythonTests
   PythonDataObjectsTests.cpp
-  PythonExceptionStateTests.cpp
   PythonTestSuite.cpp
 
   LINK_LIBS
     lldbHost
     lldbPluginScriptInterpreterPython
     LLVMTestingSupport
   LINK_COMPONENTS
     Support
   )
 No newline at end of file

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

 #include "lldb/Host/HostInfo.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/Testing/Support/Error.h"
 
 #include "PythonTestSuite.h"
 
 using namespace lldb_private;
 using namespace lldb_private::python;
+using llvm::Error;
+using llvm::Expected;
 
 class PythonDataObjectsTest : public PythonTestSuite {
 public:
   void SetUp() override {
     PythonTestSuite::SetUp();
 
     m_sys_module = unwrapIgnoringErrors(PythonModule::Import("sys"));
     m_main_module = PythonModule::MainModule();
// the old implementation of GetArgInfo just doesn't work on builtins.
     auto arginfo = hex.get().GetArgInfo();
     ASSERT_THAT_EXPECTED(arginfo, llvm::Succeeded());
     EXPECT_EQ(arginfo.get().count, 1);
     EXPECT_EQ(arginfo.get().max_positional_args, 1u);
     EXPECT_EQ(arginfo.get().has_varargs, false);
   }
 
 #endif
+}
+
+TEST_F(PythonDataObjectsTest, TestScript) {
+
+  static const char script[] = R"(
+def factorial(n):
+  if n > 1:
+    return n * factorial(n-1)
+  else:
+    return 1;
+_function_ = factorial
+)";
+
+  PythonScript factorial(script);
+  Expected<long long> r = As<long long>(factorial(5ll));
+  bool ok = (bool)r;
+  ASSERT_TRUE(ok);
+  EXPECT_EQ(r.get(), 120);
+}
+
+TEST_F(PythonDataObjectsTest, TestExceptions) {
+
+  static const char script[] = R"(
+def foo():
+  return bar()
+def bar():
+  return baz()
+def baz():
+  return 1 / 0
+_function_ = foo
+)";
+
+  PythonScript foo(script);
+  Expected<PythonObject> r = foo();
+
+  bool failed = !r;
+  ASSERT_TRUE(failed);
+
+  std::string backtrace;
+  llvm::handleAllErrors(r.takeError(), [&](const PythonException &E) {
+    backtrace = E.ReadBacktrace();
+  });
+
+  EXPECT_NE(backtrace.find("line 3, in foo"), std::string::npos);
+  EXPECT_NE(backtrace.find("line 5, in bar"), std::string::npos);
+  EXPECT_NE(backtrace.find("line 7, in baz"), std::string::npos);
+  EXPECT_NE(backtrace.find("ZeroDivisionError"), std::string::npos);
+}
+
+TEST_F(PythonDataObjectsTest, TestRun) {
+
+  PythonDictionary globals(PyInitialValue::Empty);
+
+  auto x = As<long long>(runStringOneLine("40 + 2", globals, globals));
+  ASSERT_THAT_EXPECTED(x, llvm::Succeeded());
+  EXPECT_EQ(x.get(), 42l);
+
+  Expected<PythonObject> r = runStringOneLine("n = 42", globals, globals);
+  ASSERT_THAT_EXPECTED(r, llvm::Succeeded());
+  auto y = As<long long>(globals.GetItem("n"));
+  ASSERT_THAT_EXPECTED(y, llvm::Succeeded());
+  EXPECT_EQ(y.get(), 42l);
+
+  const char script[] = R"(
+def foobar():
+  return "foo" + "bar" + "baz"
+g = foobar()
+)";
+
+  r = runStringMultiLine(script, globals, globals);
+  ASSERT_THAT_EXPECTED(r, llvm::Succeeded());
+  auto g = As<std::string>(globals.GetItem("g"));
+  ASSERT_THAT_EXPECTED(g, llvm::Succeeded());
+  EXPECT_EQ(g.get(), "foobarbaz");
 }
 No newline at end of file

lldb/unittests/ScriptInterpreter/Python/PythonExceptionStateTests.cpp

-//===-- PythonExceptionStateTest.cpp ------------------------------*- C++
-//-*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "gtest/gtest.h"
-
-#include "Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
-#include "Plugins/ScriptInterpreter/Python/PythonExceptionState.h"
-#include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
-#include "Plugins/ScriptInterpreter/Python/lldb-python.h"
-
-#include "PythonTestSuite.h"
-
-using namespace lldb_private;
-
-class PythonExceptionStateTest : public PythonTestSuite {
-public:
-protected:
-  void RaiseException() {
-    PyErr_SetString(PyExc_RuntimeError, "PythonExceptionStateTest test error");
-  }
-};
-
-TEST_F(PythonExceptionStateTest, TestExceptionStateChecking) {
-  PyErr_Clear();
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  RaiseException();
-  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-}
-
-TEST_F(PythonExceptionStateTest, TestAcquisitionSemantics) {
-  PyErr_Clear();
-  PythonExceptionState no_error(false);
-  EXPECT_FALSE(no_error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-  RaiseException();
-  PythonExceptionState error(false);
-  EXPECT_TRUE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-  error.Discard();
-
-  PyErr_Clear();
-  RaiseException();
-  error.Acquire(false);
-  EXPECT_TRUE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-}
-
-TEST_F(PythonExceptionStateTest, TestDiscardSemantics) {
-  PyErr_Clear();
-
-  // Test that discarding an exception does not restore the exception
-  // state even when auto-restore==true is set
-  RaiseException();
-  PythonExceptionState error(true);
-  EXPECT_TRUE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  error.Discard();
-  EXPECT_FALSE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-}
-
-TEST_F(PythonExceptionStateTest, TestResetSemantics) {
-  PyErr_Clear();
-
-  // Resetting when auto-restore is true should restore.
-  RaiseException();
-  PythonExceptionState error(true);
-  EXPECT_TRUE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-  error.Reset();
-  EXPECT_FALSE(error.IsError());
-  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-
-  // Resetting when auto-restore is false should discard.
-  RaiseException();
-  PythonExceptionState error2(false);
-  EXPECT_TRUE(error2.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-  error2.Reset();
-  EXPECT_FALSE(error2.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-}
-
-TEST_F(PythonExceptionStateTest, TestManualRestoreSemantics) {
-  PyErr_Clear();
-  RaiseException();
-  PythonExceptionState error(false);
-  EXPECT_TRUE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  error.Restore();
-  EXPECT_FALSE(error.IsError());
-  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-}
-
-TEST_F(PythonExceptionStateTest, TestAutoRestoreSemantics) {
-  PyErr_Clear();
-  // Test that using the auto-restore flag correctly restores the exception
-  // state on destruction, and not using the auto-restore flag correctly
-  // does NOT restore the state on destruction.
-  {
-    RaiseException();
-    PythonExceptionState error(false);
-    EXPECT_TRUE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-  }
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-  {
-    RaiseException();
-    PythonExceptionState error(true);
-    EXPECT_TRUE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-  }
-  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-}
-
-TEST_F(PythonExceptionStateTest, TestAutoRestoreChanged) {
-  // Test that if we re-acquire with different auto-restore semantics,
-  // that the new semantics are respected.
-  PyErr_Clear();
-
-  RaiseException();
-  PythonExceptionState error(false);
-  EXPECT_TRUE(error.IsError());
-
-  error.Reset();
-  EXPECT_FALSE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  RaiseException();
-  error.Acquire(true);
-  EXPECT_TRUE(error.IsError());
-  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-  error.Reset();
-  EXPECT_FALSE(error.IsError());
-  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
-
-  PyErr_Clear();
-}