Fix ref-counting of Python objects

[zturner]

Summary

PythonObjects were being incorrectly ref-counted. This problem was pervasive throughout the codebase, leading to an unknown number of memory leaks and potentially use-after-free.

The issue stems from the fact that Python native methods can either return "borrowed" references or "owned" references. For the former category, you *must* incref it prior to decrefing it. And for the latter category, you should not incref it before decrefing it. This is mostly an issue when a Python C API method returns a PyObject to you, but it can also happen with a method accepts a PyObject. Notably, this happens in PyList_SetItem, which is documented to "steal" the reference that you give it. So if you pass something to PyList_SetItem, you cannot hold onto it unless you incref it first. But since this is one of only two exceptions in the entire API, it's confusing and difficult to remember.

Our PythonObject class was indiscriminantely increfing every object it received, which means that if you passed it an owned reference, you now have a dangling reference since owned references should not be increfed. We were doing this in quite a few places.

There was also a fair amount of manual increfing and decrefing prevalent throughout the codebase, which is easy to get wrong.

This patch solves the problem by first changing the name of PythonObject to PyRef (so that it is clear from the name what this actually is), and then making any construction of a PyRef from a PyObject take a flag which indicates whether it is an owned reference or a borrowed reference. There is no way to construct a PyRef without this flag, and it does not offer a default value, forcing the user to make an explicit decision every time.

All manual uses of PyObject have been cleaned up throughout the codebase and replaced with PyRef.

[zturner]

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

337

Just to provide one example, here is an instance of a fixed memory leak. PyLong_FromLongLong returns a new reference, not a borrowed one, but PythonObject::Reset would indiscriminately call Py_INCREF.

[clayborg]

See inlined comments.

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

73–79

It seems like we don't need an enum for this, this can just be a bool named "dont_incref" or some other name?

73–85

Might be nicer to move into the PyRef class and just name these "Type" and "InitialValue"?

87

Why did we need to rename PythonObject to PyRef? It can be done, but seems different from the the rest of the classes here. Everything else is spelled out, I would prefer this stay as PythonObject.

90–91

indent is wrong here

192

I really don't like these implicit conversions as they make for bad things that can happen. We already see issues with Reset as you mention above. I would rather just have a "PyObject *get() const;" method that we use to explicitly do this. It gets event worse when you already have an implicit bool operator...

206–211

indent is wrong here

234–238

indent is wrong here

258–261

indent is wrong here

284–287

indent is wrong here

304

We should use "const PyRef &object" here instead of "PyObject *value". I know the old code used PyObject, but it is probably better to switch over.

306

We should use "const PyRef &object" here instead of "PyObject *value". I know the old code used PyObject, but it is probably better to switch over.

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

183–201

please move : to previous line and commas to the end.

[zturner]

Let me know what you think about my responses. Anything I didn't specifically call out I'll fix in the next version of the patch.

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

73–79

In theory. I used an enum because if you read the Python documentation, they explicitly use the terminology of Borrowed and New references. I don't want people to have to think about how to translate the Python documentation into a boolean value. This way the code speaks the same language as the documentation, and it's hard to make a mistake.

73–85

Possible, but it only really applies for Dictionary and List, or at least the way we use it it does.

87

Less to type for one thing, and I thought it made it clearer that it's a very thin wrapper that can be trivially copied without any overhead.

192

Fair enough, I can fix that. Do you want me to remove the implicit bool conversion operator too? The bool conversion operator is weird, because it only checks for null, and not Py_None, so it's different than calling IsNULLOrNone. In practice I think it would be fine to call IsNULLOrNone, and at one point while this CL is in progress I had changed the client code to do that, but it ended up being really ugly so I put the bool conversion back.

In any case, should I just leave the bool operator and remove the PyObject operator?

[clayborg]

I would like to see PythonObject used in place of PyRef, feel free to remove the operator bool and PyObject, and then the rest of the mostly indent and style cleanups.

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

73–79

Ok, no problem then.

192

Yeah, feel free to pull the operator bool as well. It can do bad things as well. IsValid() is what we use elsewhere, thought we may want more python specific things. We might want IsNULL(), IsNone() or IsNULLOrNone() depending on who calls it. Feel free to clean this up.

[granata.enrico]

I am not an Apple employee working on LLDB anymore

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

 class PythonString;
 class PythonList;
 class PythonDictionary;
-class PythonObject;
 class PythonInteger;
 
 class StructuredPythonObject : public StructuredData::Generic

     String
 };
 
-    class PythonObject
+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.
+};
+
+enum class PyInitialValue
+{
+    Invalid,
+    Empty
+};
+
+class PyRef
     {
     public:
-        PythonObject () :
-            m_py_obj(NULL)
+      PyRef()
+          : m_py_obj(nullptr)
         {
         }
-        
-        explicit PythonObject (PyObject* py_obj) :
-            m_py_obj(NULL)
+        PyRef(PyRefType type, PyObject *py_obj)
+            : m_py_obj(nullptr)
         {
-            Reset (py_obj);
+            Reset(type, py_obj);
         }
-        
-        PythonObject (const PythonObject &rhs) :
-            m_py_obj(NULL)
+        PyRef(const PyRef &rhs)
+            : m_py_obj(nullptr)
         {
-            Reset (rhs.m_py_obj);
+            Reset(rhs);
         }
 
-        virtual
-        ~PythonObject ()
+        virtual ~PyRef() { Reset(); }
+
+        void
+        Reset()
         {
-            Reset (NULL);
+            // Avoid calling the virtual method since it's not necessary
+            // to actually validate the type of the PyObject if we're
+            // just setting to null.
+            if (Py_IsInitialized())
+                Py_XDECREF(m_py_obj);
+            m_py_obj = nullptr;
         }
 
-        bool
-        Reset (const PythonObject &object)
+        void
+        Reset(const PyRef &rhs)
         {
-            return Reset(object.get());
+            // Avoid calling the virtual method if it's not necessary
+            // to actually validate the type of the PyObject.
+            if (!rhs.get())
+                Reset();
+            else
+                Reset(PyRefType::Borrowed, rhs.m_py_obj);
         }
 
-        virtual bool
-        Reset (PyObject* py_obj = NULL)
+        // PyRef is implicitly convertible to PyObject *, which will call the
+        // wrong overload.  We want to explicitly disallow this, since a PyObject
+        // *always* owns its reference.  Therefore the overload which takes a
+        // PyRefType doesn't make sense, and the copy constructor should be used.
+        void
+        Reset(PyRefType type, const PyRef &ref) = delete;
+
+        virtual void
+        Reset(PyRefType type, PyObject *py_obj)
         {
-            if (py_obj != m_py_obj)
-            {
-                if (Py_IsInitialized())
-                    Py_XDECREF(m_py_obj);
-                m_py_obj = py_obj;
-                if (Py_IsInitialized())
-                    Py_XINCREF(m_py_obj);
-            }
-            return true;
+            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 (Py_IsInitialized() && type == PyRefType::Borrowed)
+                Py_XINCREF(m_py_obj);
         }
         
         void

         
         PythonString
         Str ();
-        
-        explicit operator bool () const
+        PyRef &
+        operator=(const PyRef &other)
         {
-            return m_py_obj != NULL;
+            Reset(PyRefType::Borrowed, other.get());
+            return *this;
         }
-        
+        operator bool() const { return m_py_obj != NULL; }
+
+        operator PyObject *() const { return m_py_obj; }
+
         bool
         IsNULLOrNone () const;
 

         PyObject* m_py_obj;
     };
 
-    class PythonString: public PythonObject
+    class PythonString : public PyRef
     {
     public:
-        PythonString ();
-        PythonString (PyObject *o);
-        PythonString (const PythonObject &object);
-        PythonString (llvm::StringRef string);
-        PythonString (const char *string);
-        virtual ~PythonString ();
+      PythonString();
+      PythonString(PyRefType type, PyObject *o);
+      PythonString(const PythonString &object);
+      explicit PythonString(llvm::StringRef string);
+      explicit PythonString(const char *string);
+      ~PythonString() override;
 
         static bool Check(PyObject *py_obj);
 
-        virtual bool
-        Reset (PyObject* py_obj = NULL);
+        // Bring in the no-argument base class version
+        using PyRef::Reset;
+
+        void Reset(PyRefType type, PyObject *py_obj) override;
 
         llvm::StringRef
         GetString() const;

         StructuredData::StringSP CreateStructuredString() const;
     };
 
-    class PythonInteger: public PythonObject
+    class PythonInteger : public PyRef
     {
     public:
-        
-        PythonInteger ();
-        PythonInteger (PyObject* py_obj);
-        PythonInteger (const PythonObject &object);
-        PythonInteger (int64_t value);
-        virtual ~PythonInteger ();
+      PythonInteger();
+      PythonInteger(PyRefType type, PyObject *o);
+      PythonInteger(const PythonInteger &object);
+      explicit PythonInteger(int64_t value);
+      ~PythonInteger() override;
 
         static bool Check(PyObject *py_obj);
 
-        virtual bool
-        Reset (PyObject* py_obj = NULL);
+        // Bring in the no-argument base class version
+        using PyRef::Reset;
+
+        void Reset(PyRefType type, PyObject *py_obj) override;
 
         int64_t GetInteger() const;
 

 
         StructuredData::IntegerSP CreateStructuredInteger() const;
     };
-    
-    class PythonList: public PythonObject
+    class PythonList : public PyRef
     {
     public:
-      PythonList();
-        PythonList (PyObject* py_obj);
-        PythonList (const PythonObject &object);
-        virtual ~PythonList ();
+      PythonList(PyInitialValue value);
+      PythonList(PyRefType type, PyObject *o);
+      PythonList(const PythonList &list);
+      ~PythonList() override;
 
         static bool Check(PyObject *py_obj);
 
-        virtual bool
-        Reset (PyObject* py_obj = NULL);
+        // Bring in the no-argument base class version
+        using PyRef::Reset;
+
+        void Reset(PyRefType type, PyObject *py_obj) override;
 
         uint32_t GetSize() const;
 
-        PythonObject GetItemAtIndex(uint32_t index) const;
+        PyRef GetItemAtIndex(uint32_t index) const;
 
-        void
-        SetItemAtIndex (uint32_t index, const PythonObject &object);
-        
-        void
-        AppendItem (const PythonObject &object);
+        void SetItemAtIndex(uint32_t index, const PyRef &object);
+
+        void AppendItem(const PyRef &object);
 
         StructuredData::ArraySP CreateStructuredArray() const;
     };
-    
-    class PythonDictionary: public PythonObject
+    class PythonDictionary : public PyRef
     {
     public:
-        PythonDictionary();
-        PythonDictionary (PyObject* object);
-        PythonDictionary (const PythonObject &object);
-        virtual ~PythonDictionary ();
+      PythonDictionary(PyInitialValue value);
+      PythonDictionary(PyRefType type, PyObject *o);
+      PythonDictionary(const PythonDictionary &dict);
+      ~PythonDictionary() override;
 
         static bool Check(PyObject *py_obj);
 
-        virtual bool
-        Reset (PyObject* object = NULL);
+        // Bring in the no-argument base class version
+        using PyRef::Reset;
+
+        void Reset(PyRefType type, PyObject *py_obj) override;
 
         uint32_t GetSize() const;
 
-        PythonObject
-        GetItemForKey (const PythonString &key) const;
-        
-        const char *
-        GetItemForKeyAsString (const PythonString &key, const char *fail_value = NULL) const;
+        PyRef GetItemForKey(const PythonString &key) const;
 
-        int64_t
-        GetItemForKeyAsInteger (const PythonString &key, int64_t fail_value = 0) const;
+        PyRef GetItemForKey(const char *key) const;
 
-        PythonObject
-        GetItemForKey (const char *key) const;
+        PythonList GetKeys() const;
 
-        typedef bool (*DictionaryIteratorCallback)(PythonString* key, PythonDictionary* dict);
-        
-        PythonList
-        GetKeys () const;
-        
-        PythonString
-        GetKeyAtPosition (uint32_t pos) const;
-        
-        PythonObject
-        GetValueAtPosition (uint32_t pos) const;
-        
-        void
-        SetItemForKey (const PythonString &key, PyObject *value);
+        void SetItemForKey(const PythonString &key, PyObject *value);
 
-        void
-        SetItemForKey (const PythonString &key, const PythonObject& value);
+        void SetItemForKey(const char *key, PyObject *value);
 
         StructuredData::DictionarySP CreateStructuredDictionary() const;
     };

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

 }
 
 //----------------------------------------------------------------------
-// PythonObject
+// PyRef
 //----------------------------------------------------------------------
 
 void
-PythonObject::Dump (Stream &strm) const
+PyRef::Dump(Stream &strm) const
 {
     if (m_py_obj)
     {

 }
 
 PyObjectType
-PythonObject::GetObjectType() const
+PyRef::GetObjectType() const
 {
     if (IsNULLOrNone())
         return PyObjectType::None;

 }
 
 PythonString
-PythonObject::Repr ()
+PyRef::Repr()
 {
     if (!m_py_obj)
-        return PythonString ();
+        return PythonString();
     PyObject *repr = PyObject_Repr(m_py_obj);
     if (!repr)
-        return PythonString ();
-    return PythonString(repr);
+        return PythonString();
+    return PythonString(PyRefType::Owned, repr);
 }
 
 PythonString
-PythonObject::Str ()
+PyRef::Str()
 {
     if (!m_py_obj)
-        return PythonString ();
+        return PythonString();
     PyObject *str = PyObject_Str(m_py_obj);
     if (!str)
-        return PythonString ();
-    return PythonString(str);
+        return PythonString();
+    return PythonString(PyRefType::Owned, str);
 }
 
 bool
-PythonObject::IsNULLOrNone () const
+PyRef::IsNULLOrNone() const
 {
     return ((m_py_obj == nullptr) || (m_py_obj == Py_None));
 }
 
 StructuredData::ObjectSP
-PythonObject::CreateStructuredObject() const
+PyRef::CreateStructuredObject() const
 {
     switch (GetObjectType())
     {
         case PyObjectType::Dictionary:
-            return PythonDictionary(m_py_obj).CreateStructuredDictionary();
+            return PythonDictionary(PyRefType::Borrowed, m_py_obj).CreateStructuredDictionary();
         case PyObjectType::Integer:
-            return PythonInteger(m_py_obj).CreateStructuredInteger();
+            return PythonInteger(PyRefType::Borrowed, m_py_obj).CreateStructuredInteger();
         case PyObjectType::List:
-            return PythonList(m_py_obj).CreateStructuredArray();
+            return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
         case PyObjectType::String:
-            return PythonString(m_py_obj).CreateStructuredString();
+            return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
         case PyObjectType::None:
             return StructuredData::ObjectSP();
         default:

 // PythonString
 //----------------------------------------------------------------------
 
-PythonString::PythonString (PyObject *py_obj) :
-    PythonObject()
+PythonString::PythonString(PyRefType type, PyObject *py_obj)
+    : PyRef()
 {
-    Reset(py_obj); // Use "Reset()" to ensure that py_obj is a string
+    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
 }
 
-PythonString::PythonString (const PythonObject &object) :
-    PythonObject()
+PythonString::PythonString(const PythonString &object)
+    : PyRef(object)
 {
-    Reset(object.get()); // Use "Reset()" to ensure that py_obj is a string
 }
 
 PythonString::PythonString(llvm::StringRef string)
-    : PythonObject()
+    : PyRef()
 {
     SetString(string);
 }
 
 PythonString::PythonString(const char *string)
-    : PythonObject()
+    : PyRef()
 {
     SetString(llvm::StringRef(string));
 }
 
-PythonString::PythonString () :
-    PythonObject()
+PythonString::PythonString()
+    : PyRef()
 {
 }
 

 #endif
 }
 
-bool
-PythonString::Reset(PyObject *py_obj)
+void
+PythonString::Reset(PyRefType type, PyObject *py_obj)
 {
+    // Grab the desired reference type so that if we end up rejecting
+    // `py_obj` it still gets decremented if necessary.
+    PyRef result(type, py_obj);
+
     if (!PythonString::Check(py_obj))
     {
-        PythonObject::Reset(nullptr);
-        return false;
+        PyRef::Reset();
+        return;
     }
 
     // Convert this to a PyBytes object, and only store the PyBytes.  Note that in
     // Python 2.x, PyString and PyUnicode are interchangeable, and PyBytes is an alias
     // of PyString.  So on 2.x, if we get into this branch, we already have a PyBytes.
-    //#if PY_MAJOR_VERSION >= 3
     if (PyUnicode_Check(py_obj))
     {
-        PyObject *unicode = py_obj;
-        py_obj = PyUnicode_AsUTF8String(py_obj);
-        Py_XDECREF(unicode);
+        // Since we're converting this to a different object, we assume ownership of the
+        // new object regardless of the value of `type`.
+        result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(py_obj));
     }
-    //#endif
 
-    assert(PyBytes_Check(py_obj) && "PythonString::Reset received a non-string");
-    return PythonObject::Reset(py_obj);
+    assert(PyBytes_Check(result) && "PythonString::Reset received a non-string");
+
+    // Calling PyRef::Reset(const PyRef&) will lead to stack overflow since it calls
+    // back into the virtual implementation.
+    PyRef::Reset(PyRefType::Borrowed, result.get());
 }
 
 llvm::StringRef

 #if PY_MAJOR_VERSION >= 3
     PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
     PyObject *bytes = PyUnicode_AsUTF8String(unicode);
-    PythonObject::Reset(bytes);
-    Py_XDECREF(unicode);
+    PyRef::Reset(PyRefType::Owned, bytes);
+    Py_DECREF(unicode);
 #else
-    PythonObject::Reset(PyString_FromStringAndSize(string.data(), string.size()));
+    PyRef::Reset(PyRefType::Owned, PyString_FromStringAndSize(string.data(), string.size()));
 #endif
 }
 

 // PythonInteger
 //----------------------------------------------------------------------
 
-PythonInteger::PythonInteger (PyObject *py_obj) :
-    PythonObject()
+PythonInteger::PythonInteger(PyRefType type, PyObject *py_obj)
+    : PyRef()
 {
-    Reset(py_obj); // Use "Reset()" to ensure that py_obj is a integer type
+    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a integer type
 }
 
-PythonInteger::PythonInteger (const PythonObject &object) :
-    PythonObject()
+PythonInteger::PythonInteger(const PythonInteger &object)
+    : PyRef(object)
 {
-    Reset(object.get()); // Use "Reset()" to ensure that py_obj is a integer type
 }
 
-PythonInteger::PythonInteger (int64_t value) :
-    PythonObject()
+PythonInteger::PythonInteger(int64_t value)
+    : PyRef()
 {
-    SetInteger (value);
+    SetInteger(value);
 }
 
 

 #endif
 }
 
-bool
-PythonInteger::Reset(PyObject *py_obj)
+void
+PythonInteger::Reset(PyRefType type, PyObject *py_obj)
 {
+    // Grab the desired reference type so that if we end up rejecting
+    // `py_obj` it still gets decremented if necessary.
+    PyRef result(type, py_obj);
+
     if (!PythonInteger::Check(py_obj))
     {
-        PythonObject::Reset(nullptr);
-        return false;
+        PyRef::Reset();
+        return;
     }
 
 #if PY_MAJOR_VERSION < 3

     // since 3.x doesn't even have a PyInt.
     if (PyInt_Check(py_obj))
     {
-        PyObject *py_long = PyLong_FromLongLong(PyInt_AsLong(py_obj));
-        Py_XDECREF(py_obj);
-        py_obj = py_long;
+        // Since we converted the original object to a different type, the new
+        // object is an owned object regardless of the ownership semantics requested
+        // by the user.
+        result.Reset(PyRefType::Owned, PyLong_FromLongLong(PyInt_AsLong(py_obj)));
     }
 #endif
 
-    assert(PyLong_Check(py_obj) && "Couldn't get a PyLong from this PyObject");
+    assert(PyLong_Check(result) && "Couldn't get a PyLong from this PyObject");
 
-    return PythonObject::Reset(py_obj);
+    // Calling PyRef::Reset(const PyRef&) will lead to stack overflow since it calls
+    // back into the virtual implementation.
+    PyRef::Reset(PyRefType::Borrowed, result.get());
 }
 
 int64_t

 }
 
 void
-PythonInteger::SetInteger (int64_t value)
+PythonInteger::SetInteger(int64_t value)
 {
-    PythonObject::Reset(PyLong_FromLongLong(value));
+    PyRef::Reset(PyRefType::Owned, PyLong_FromLongLong(value));
 }
 
 StructuredData::IntegerSP

 // PythonList
 //----------------------------------------------------------------------
 
-PythonList::PythonList()
-    : PythonObject(PyList_New(0))
+PythonList::PythonList(PyInitialValue value)
+    : PyRef()
 {
+    if (value == PyInitialValue::Empty)
+        Reset(PyRefType::Owned, PyList_New(0));
 }
 
-PythonList::PythonList (PyObject *py_obj) :
-    PythonObject()
+PythonList::PythonList(PyRefType type, PyObject *py_obj)
+    : PyRef()
 {
-    Reset(py_obj); // Use "Reset()" to ensure that py_obj is a list
+    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a list
 }
 
-
-PythonList::PythonList (const PythonObject &object) :
-    PythonObject()
+PythonList::PythonList(const PythonList &list)
+    : PyRef(list)
 {
-    Reset(object.get()); // Use "Reset()" to ensure that py_obj is a list
 }
 
 PythonList::~PythonList ()

     return PyList_Check(py_obj);
 }
 
-bool
-PythonList::Reset(PyObject *py_obj)
+void
+PythonList::Reset(PyRefType type, PyObject *py_obj)
 {
+    // Grab the desired reference type so that if we end up rejecting
+    // `py_obj` it still gets decremented if necessary.
+    PyRef result(type, py_obj);
+
     if (!PythonList::Check(py_obj))
     {
-        PythonObject::Reset(nullptr);
-        return false;
+        PyRef::Reset();
+        return;
     }
 
-    return PythonObject::Reset(py_obj);
+    // Calling PyRef::Reset(const PyRef&) will lead to stack overflow since it calls
+    // back into the virtual implementation.
+    PyRef::Reset(PyRefType::Borrowed, result.get());
 }
 
 uint32_t

     return 0;
 }
 
-PythonObject
+PyRef
 PythonList::GetItemAtIndex(uint32_t index) const
 {
     if (m_py_obj)
-        return PythonObject(PyList_GetItem(m_py_obj, index));
-    return PythonObject();
+        return PyRef(PyRefType::Borrowed, PyList_GetItem(m_py_obj, index));
+    return PyRef();
 }
 
 void
-PythonList::SetItemAtIndex (uint32_t index, const PythonObject & object)
+PythonList::SetItemAtIndex(uint32_t index, const PyRef &object)
 {
     if (m_py_obj && object)
+    {
+        // PyList_SetItem is documented to "steal" a reference, so we need to
+        // convert it to an owned reference by incrementing it.
+        Py_INCREF(object.get());
         PyList_SetItem(m_py_obj, index, object.get());
+    }
 }
 
 void
-PythonList::AppendItem (const PythonObject &object)
+PythonList::AppendItem(const PyRef &object)
 {
     if (m_py_obj && object)
         PyList_Append(m_py_obj, object.get());

     uint32_t count = GetSize();
     for (uint32_t i = 0; i < count; ++i)
     {
-        PythonObject obj = GetItemAtIndex(i);
+        PyRef obj = GetItemAtIndex(i);
         result->AddItem(obj.CreateStructuredObject());
     }
     return result;

 // PythonDictionary
 //----------------------------------------------------------------------
 
-PythonDictionary::PythonDictionary()
-    : PythonObject(PyDict_New())
+PythonDictionary::PythonDictionary(PyInitialValue value)
+    : PyRef()
 {
+    if (value == PyInitialValue::Empty)
+        Reset(PyRefType::Owned, PyDict_New());
 }
 
-PythonDictionary::PythonDictionary (PyObject *py_obj) :
-    PythonObject(py_obj)
+PythonDictionary::PythonDictionary(PyRefType type, PyObject *py_obj)
+    : PyRef()
 {
-    Reset(py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
+    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
 }
 
-
-PythonDictionary::PythonDictionary (const PythonObject &object) :
-    PythonObject()
+PythonDictionary::PythonDictionary(const PythonDictionary &object)
+    : PyRef(object)
 {
-    Reset(object.get()); // Use "Reset()" to ensure that py_obj is a dictionary
 }
 
 PythonDictionary::~PythonDictionary ()

     return PyDict_Check(py_obj);
 }
 
-bool
-PythonDictionary::Reset(PyObject *py_obj)
+void
+PythonDictionary::Reset(PyRefType type, PyObject *py_obj)
 {
+    // Grab the desired reference type so that if we end up rejecting
+    // `py_obj` it still gets decremented if necessary.
+    PyRef result(type, py_obj);
+
     if (!PythonDictionary::Check(py_obj))
     {
-        PythonObject::Reset(nullptr);
-        return false;
+        PyRef::Reset();
+        return;
     }
 
-    return PythonObject::Reset(py_obj);
+    // Calling PyRef::Reset(const PyRef&) will lead to stack overflow since it calls
+    // back into the virtual implementation.
+    PyRef::Reset(PyRefType::Borrowed, result.get());
 }
 
 uint32_t

     return 0;
 }
 
-PythonObject
-PythonDictionary::GetItemForKey (const char *key) const
+PyRef
+PythonDictionary::GetItemForKey(const char *key) const
 {
     if (key && key[0])
     {
         PythonString python_key(key);
         return GetItemForKey(python_key);
     }
-    return PythonObject();
+    return PyRef();
 }
 
-
-PythonObject
-PythonDictionary::GetItemForKey (const PythonString &key) const
+PyRef
+PythonDictionary::GetItemForKey(const PythonString &key) const
 {
     if (m_py_obj && key)
-        return PythonObject(PyDict_GetItem(m_py_obj, key.get()));
-    return PythonObject();
-}
-
-
-const char *
-PythonDictionary::GetItemForKeyAsString (const PythonString &key, const char *fail_value) const
-{
-    if (m_py_obj && key)
-    {
-        PyObject *py_obj = PyDict_GetItem(m_py_obj, key.get());
-        if (py_obj && PythonString::Check(py_obj))
-        {
-            PythonString str(py_obj);
-            return str.GetString().data();
-        }
-    }
-    return fail_value;
-}
-
-int64_t
-PythonDictionary::GetItemForKeyAsInteger (const PythonString &key, int64_t fail_value) const
-{
-    if (m_py_obj && key)
-    {
-        PyObject *py_obj = PyDict_GetItem(m_py_obj, key.get());
-        if (PythonInteger::Check(py_obj))
-        {
-            PythonInteger int_obj(py_obj);
-            return int_obj.GetInteger();
-        }
-    }
-    return fail_value;
+        return PyRef(PyRefType::Borrowed, PyDict_GetItem(m_py_obj, key.get()));
+    return PyRef();
 }
 
 PythonList
 PythonDictionary::GetKeys () const
 {
     if (m_py_obj)
-        return PythonList(PyDict_Keys(m_py_obj));
-    return PythonList();
-}
-
-PythonString
-PythonDictionary::GetKeyAtPosition (uint32_t pos) const
-{
-    PyObject *key, *value;
-    Py_ssize_t pos_iter = 0;
-    
-    if (m_py_obj)
-    {
-        while (PyDict_Next(m_py_obj, &pos_iter, &key, &value))
-        {
-            if (pos-- == 0)
-                return PythonString(key);
-        }
-    }
-    return PythonString();
-}
-
-PythonObject
-PythonDictionary::GetValueAtPosition (uint32_t pos) const
-{
-    PyObject *key, *value;
-    Py_ssize_t pos_iter = 0;
-    
-    if (!m_py_obj)
-        return PythonObject();
-    
-    while (PyDict_Next(m_py_obj, &pos_iter, &key, &value)) {
-        if (pos-- == 0)
-            return PythonObject(value);
-    }
-    return PythonObject();
+        return PythonList(PyRefType::Owned, PyDict_Keys(m_py_obj));
+    return PythonList(PyInitialValue::Invalid);
 }
 
 void
-PythonDictionary::SetItemForKey (const PythonString &key, PyObject *value)
+PythonDictionary::SetItemForKey(const PythonString &key, PyObject *value)
 {
     if (m_py_obj && key && value)
-        PyDict_SetItem(m_py_obj, key.get(), value);
+        PyDict_SetItem(m_py_obj, key, value);
 }
 
 void
-PythonDictionary::SetItemForKey (const PythonString &key, const PythonObject &value)
+PythonDictionary::SetItemForKey(const char *key, PyObject *value)
 {
-    if (m_py_obj && key && value)
-        PyDict_SetItem(m_py_obj, key.get(), value.get());
+    SetItemForKey(PythonString(key), value);
 }
 
 StructuredData::DictionarySP

     uint32_t num_keys = keys.GetSize();
     for (uint32_t i = 0; i < num_keys; ++i)
     {
-        PythonObject key = keys.GetItemAtIndex(i);
+        PyRef key = keys.GetItemAtIndex(i);
         PythonString key_str = key.Str();
-        PythonObject value = GetItemForKey(key);
+        PyRef value = GetItemForKey(key_str);
         StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
         result->AddItem(key_str.GetString(), structured_value);
     }

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

         eIOHandlerBreakpoint,
         eIOHandlerWatchpoint
     };
-    PythonObject &
-    GetMainModule ();
-    
+
+    PyRef &GetMainModule();
     PythonDictionary &
     GetSessionDictionary ();
     

 
     bool
     GetEmbeddedInterpreterModuleObjects ();
-    
-    PythonObject m_saved_stdin;
-    PythonObject m_saved_stdout;
-    PythonObject m_saved_stderr;
-    PythonObject m_main_module;
-    PythonObject m_lldb_module;
+    PyRef m_saved_stdin;
+    PyRef m_saved_stdout;
+    PyRef m_saved_stderr;
+    PyRef m_main_module;
+    PyRef m_lldb_module;
     PythonDictionary m_session_dict;
     PythonDictionary m_sys_module_dict;
-    PythonObject m_run_one_line_function;
-    PythonObject m_run_one_line_str_global;
+    PyRef m_run_one_line_function;
+    PyRef m_run_one_line_str_global;
     std::string m_dictionary_name;
     TerminalState m_terminal_state;
     ActiveIOHandler m_active_io_handler;

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 #endif
 }
 
-static std::string
-ReadPythonBacktrace (PyObject* py_backtrace);
+static std::string ReadPythonBacktrace(PyRef py_backtrace);
 
 ScriptInterpreterPython::Locker::Locker (ScriptInterpreterPython *py_interpreter,
                                          uint16_t on_entry,

     DoFreeLock();
 }
 
-
-ScriptInterpreterPython::ScriptInterpreterPython (CommandInterpreter &interpreter) :
-    ScriptInterpreter (interpreter, eScriptLanguagePython),
-    IOHandlerDelegateMultiline("DONE"),
-    m_saved_stdin (),
-    m_saved_stdout (),
-    m_saved_stderr (),
-    m_main_module (),
-    m_lldb_module (),
-    m_session_dict(nullptr),
-    m_sys_module_dict(nullptr),
-    m_run_one_line_function (),
-    m_run_one_line_str_global (),
-    m_dictionary_name (interpreter.GetDebugger().GetInstanceName().AsCString()),
-    m_terminal_state (),
-    m_active_io_handler (eIOHandlerNone),
-    m_session_is_active (false),
-    m_pty_slave_is_open (false),
-    m_valid_session (true),
-    m_lock_count (0),
-    m_command_thread_state (nullptr)
+ScriptInterpreterPython::ScriptInterpreterPython(CommandInterpreter &interpreter)
+    : ScriptInterpreter(interpreter, eScriptLanguagePython)
+    , IOHandlerDelegateMultiline("DONE")
+    , m_saved_stdin()
+    , m_saved_stdout()
+    , m_saved_stderr()
+    , m_main_module()
+    , m_lldb_module()
+    , m_session_dict(PyInitialValue::Invalid)
+    , m_sys_module_dict(PyInitialValue::Invalid)
+    , m_run_one_line_function()
+    , m_run_one_line_str_global()
+    , m_dictionary_name(interpreter.GetDebugger().GetInstanceName().AsCString())
+    , m_terminal_state()
+    , m_active_io_handler(eIOHandlerNone)
+    , m_session_is_active(false)
+    , m_pty_slave_is_open(false)
+    , m_valid_session(true)
+    , m_lock_count(0)
+    , m_command_thread_state(nullptr)
 {
     assert(g_initialized && "ScriptInterpreterPython created but InitializePrivate has not been called!");
 

     m_session_is_active = false;
 }
 
-static PyObject *
+static PyRef
 PyFile_FromFile_Const(FILE *fp, const char *name, const char *mode, int (*close)(FILE *))
 {
     // Read through the Python source, doesn't seem to modify these strings
-    return PyFile_FromFile(fp, const_cast<char*>(name), const_cast<char*>(mode), close);
+    return PyRef(PyRefType::Owned, 
+        PyFile_FromFile(fp, const_cast<char*>(name), const_cast<char*>(mode), close));
 }
 
 bool

                 in = in_sp->GetFile().GetStream();
             if (in)
             {
-                m_saved_stdin.Reset(sys_module_dict.GetItemForKey("stdin"));
+                m_saved_stdin = sys_module_dict.GetItemForKey("stdin");
                 // This call can deadlock your process if the file is locked
-                PyObject *new_file = PyFile_FromFile_Const (in, "", "r", nullptr);
+                PyRef new_file = PyFile_FromFile_Const(in, "", "r", nullptr);
                 sys_module_dict.SetItemForKey ("stdin", new_file);
-                Py_DECREF (new_file);
             }
         }
 

             out = out_sp->GetFile().GetStream();
         if (out)
         {
-            m_saved_stdout.Reset(sys_module_dict.GetItemForKey("stdout"));
+            m_saved_stdout = sys_module_dict.GetItemForKey("stdout");
 
-            PyObject *new_file = PyFile_FromFile_Const (out, "", "w", nullptr);
+            PyRef new_file = PyFile_FromFile_Const(out, "", "w", nullptr);
             sys_module_dict.SetItemForKey ("stdout", new_file);
-            Py_DECREF (new_file);
         }
         else
             m_saved_stdout.Reset();

             err = err_sp->GetFile().GetStream();
         if (err)
         {
-            m_saved_stderr.Reset(sys_module_dict.GetItemForKey("stderr"));
+            m_saved_stderr = sys_module_dict.GetItemForKey("stderr");
 
-            PyObject *new_file = PyFile_FromFile_Const (err, "", "w", nullptr);
+            PyRef new_file = PyFile_FromFile_Const(err, "", "w", nullptr);
             sys_module_dict.SetItemForKey ("stderr", new_file);
-            Py_DECREF (new_file);
         }
         else
             m_saved_stderr.Reset();

     return true;
 }
 
-PythonObject &
-ScriptInterpreterPython::GetMainModule ()
+PyRef &
+ScriptInterpreterPython::GetMainModule()
 {
     if (!m_main_module)
-        m_main_module.Reset(PyImport_AddModule ("__main__"));
+        m_main_module.Reset(PyRefType::Borrowed, PyImport_AddModule("__main__"));
     return m_main_module;
 }
 

 {
     if (!m_session_dict)
     {
-        PythonObject &main_module = GetMainModule ();
+        PyRef &main_module = GetMainModule();
         if (main_module)
         {
-            PythonDictionary main_dict(PyModule_GetDict (main_module.get()));
+            PythonDictionary main_dict(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
             if (main_dict)
             {
-                m_session_dict = main_dict.GetItemForKey(m_dictionary_name.c_str());
+                PyRef item = main_dict.GetItemForKey(m_dictionary_name.c_str());
+                m_session_dict.Reset(PyRefType::Borrowed, item.get());
             }
         }
     }

 {
     if (!m_sys_module_dict)
     {
-        PyObject *sys_module = PyImport_AddModule ("sys");
+        PyRef sys_module(PyRefType::Borrowed, PyImport_AddModule("sys"));
         if (sys_module)
-            m_sys_module_dict.Reset(PyModule_GetDict (sys_module));
+            m_sys_module_dict.Reset(PyRefType::Borrowed, PyModule_GetDict(sys_module));
     }
     return m_sys_module_dict;
 }

 bool
 ScriptInterpreterPython::GetEmbeddedInterpreterModuleObjects ()
 {
-    if (!m_run_one_line_function)
-    {
-        PyObject *module = PyImport_AddModule ("lldb.embedded_interpreter");
-        if (module != nullptr)
-        {
-            PythonDictionary module_dict (PyModule_GetDict (module));
-            if (module_dict)
-            {
-                m_run_one_line_function = module_dict.GetItemForKey("run_one_line");
-                m_run_one_line_str_global = module_dict.GetItemForKey("g_run_one_line_str");
-            }
-        }
-    }
-    return (bool)m_run_one_line_function;
+    if (m_run_one_line_function)
+        return true;
+
+    PyRef module(PyRefType::Borrowed, PyImport_AddModule ("lldb.embedded_interpreter"));
+    if (!module)
+        return false;
+
+    PythonDictionary module_dict(PyRefType::Borrowed, PyModule_GetDict(module));
+    if (!module_dict)
+        return false;
+
+    m_run_one_line_function = module_dict.GetItemForKey("run_one_line");
+    m_run_one_line_str_global = module_dict.GetItemForKey("g_run_one_line_str");
+    return m_run_one_line_function;
 }
 
 static void

         {
             if (GetEmbeddedInterpreterModuleObjects ())
             {
-                PyObject *pfunc = m_run_one_line_function.get();
-                
-                if (pfunc && PyCallable_Check (pfunc))
+                if (PyCallable_Check(m_run_one_line_function))
                 {
-                    PythonObject pargs (Py_BuildValue("(Os)", session_dict.get(), command));
+                    PyRef pargs(PyRefType::Owned, Py_BuildValue("(Os)", session_dict.get(), command));
                     if (pargs)
                     {
-                        PythonObject return_value(PyObject_CallObject (pfunc, pargs.get()));
+                        PyRef return_value(PyRefType::Owned,
+                            PyObject_CallObject(m_run_one_line_function, pargs));
                         if (return_value)
                             success = true;
                         else if (options.GetMaskoutErrors() && PyErr_Occurred ())

                   ScriptInterpreterPython::Locker::AcquireLock | ScriptInterpreterPython::Locker::InitSession | (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) | Locker::NoSTDIN,
                   ScriptInterpreterPython::Locker::FreeAcquiredLock | ScriptInterpreterPython::Locker::TearDownSession);
 
-    PyObject *py_return = nullptr;
-    PythonObject &main_module = GetMainModule ();
-    PythonDictionary globals (PyModule_GetDict(main_module.get()));
-    PyObject *py_error = nullptr;
+    PyRef py_return;
+    PyRef &main_module = GetMainModule();
+    PythonDictionary globals(PyRefType::Borrowed, PyModule_GetDict(main_module));
+    PyRef py_error;
     bool ret_success = false;
     int success;
     

     
     if (!locals)
     {
-        locals = PyObject_GetAttrString (globals.get(), m_dictionary_name.c_str());
+        locals.Reset(PyRefType::Owned, PyObject_GetAttrString(globals, m_dictionary_name.c_str()));
     }
         
     if (!locals)
         locals = globals;
 
-    py_error = PyErr_Occurred();
-    if (py_error != nullptr)
+    py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+    if (!py_error)
         PyErr_Clear();
     
     if (in_string != nullptr)
     {
         { // scope for PythonInputReaderManager
             //PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
-            py_return = PyRun_String (in_string, Py_eval_input, globals.get(), locals.get());
-            if (py_return == nullptr)
-            { 
-                py_error = PyErr_Occurred ();
-                if (py_error != nullptr)
-                    PyErr_Clear ();
-
-                py_return = PyRun_String (in_string, Py_single_input, globals.get(), locals.get());
+            py_return.Reset(PyRefType::Owned, PyRun_String(in_string, Py_eval_input, globals, locals));
+            if (!py_return)
+            {
+                py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+                if (!py_error)
+                    PyErr_Clear();
+
+                py_return.Reset(PyRefType::Owned, PyRun_String(in_string, Py_single_input, globals, locals));
             }
         }
 
-        if (py_return != nullptr)
+        if (py_return)
         {
             switch (return_type)
             {

                 case eScriptReturnTypeOpaqueObject:
                 {
                     success = true;
-                    Py_XINCREF(py_return);
-                    *((PyObject**)ret_value) = py_return;
+                    PyObject *saved_value = py_return;
+                    Py_XINCREF(saved_value);
+                    *((PyObject **)ret_value) = saved_value;
                     break;
                 }
             }
-            Py_XDECREF (py_return);
+
             if (success)
                 ret_success = true;
             else

         }
     }
 
-    py_error = PyErr_Occurred();
-    if (py_error != nullptr)
+    py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+    if (py_error)
     {
         ret_success = false;
         if (options.GetMaskoutErrors())

                   ScriptInterpreterPython::Locker::AcquireLock      | ScriptInterpreterPython::Locker::InitSession | (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) | Locker::NoSTDIN,
                   ScriptInterpreterPython::Locker::FreeAcquiredLock | ScriptInterpreterPython::Locker::TearDownSession);
 
-    PythonObject return_value;
-    PythonObject &main_module = GetMainModule ();
-    PythonDictionary globals (PyModule_GetDict(main_module.get()));
-    PyObject *py_error = nullptr;
+    PyRef return_value;
+    PyRef &main_module = GetMainModule();
+    PythonDictionary globals(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
+    PyRef py_error;
+
+    PythonDictionary locals = GetSessionDictionary();
 
-    PythonDictionary locals = GetSessionDictionary ();
-    
     if (!locals)
     {
-        locals = PyObject_GetAttrString (globals.get(), m_dictionary_name.c_str());
+        locals.Reset(PyRefType::Owned, PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
     }
 
     if (!locals)
-    {
         locals = globals;
-    }
 
-    py_error = PyErr_Occurred();
-    if (py_error != nullptr)
+    py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+    if (py_error)
         PyErr_Clear();
     
     if (in_string != nullptr)
     {
+        PyRef code_object;
+        code_object.Reset(PyRefType::Owned, Py_CompileString(in_string, "temp.py", Py_file_input));
+
+        if (code_object)
+        {
+            // 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 *code_object = Py_CompileString(in_string, "temp.py", Py_file_input);
+            PyObject *py_code_obj = code_object;
 #else
-        PyCodeObject *code_object = nullptr;
-        struct _node *compiled_node = PyParser_SimpleParseString(in_string, Py_file_input);
-        if (compiled_node)
-            code_object = PyNode_Compile(compiled_node, "temp.py");
+            PyCodeObject *py_code_obj = reinterpret_cast<PyCodeObject *>(code_object.get());
 #endif
-        if (code_object)
-            return_value.Reset(PyEval_EvalCode(code_object, globals.get(), locals.get()));
+            return_value.Reset(PyRefType::Owned, PyEval_EvalCode(py_code_obj, globals, locals));
+        }
     }
 
-    py_error = PyErr_Occurred ();
-    if (py_error != nullptr)
+    py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+    if (py_error)
     {
-//        puts(in_string);
-//        _PyObject_Dump (py_error);
-//        PyErr_Print();
-//        success = false;
-        
-        PyObject *type = nullptr;
-        PyObject *value = nullptr;
-        PyObject *traceback = nullptr;
-        PyErr_Fetch (&type,&value,&traceback);
-        
+        // puts(in_string);
+        // _PyObject_Dump (py_error);
+        // PyErr_Print();
+        // success = false;
+        PyObject *py_type = nullptr;
+        PyObject *py_value = nullptr;
+        PyObject *py_traceback = nullptr;
+        PyErr_Fetch(&py_type, &py_value, &py_traceback);
+        PyRef type(PyRefType::Owned, py_type);
+        PyRef value(PyRefType::Owned, py_value);
+        PyRef traceback(PyRefType::Owned, py_traceback);
+
         // get the backtrace
         std::string bt = ReadPythonBacktrace(traceback);
-        
-        if (value && value != Py_None)
+        if (!value.IsNULLOrNone())
         {
-            PythonString str(value);
+            PythonString str = value.Str();
             llvm::StringRef value_str(str.GetString());
             error.SetErrorStringWithFormat("%s\n%s", value_str.str().c_str(), bt.c_str());
         }
         else
             error.SetErrorStringWithFormat("%s",bt.c_str());
-        Py_XDECREF(type);
-        Py_XDECREF(value);
-        Py_XDECREF(traceback);
         if (options.GetMaskoutErrors())
-        {
             PyErr_Clear();
-        }
     }
 
     return error;

     if (!generic)
         return nullptr;
 
-    PyObject *implementor = (PyObject *)generic->GetValue();
+    PyRef implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
 
-    if (implementor == nullptr || implementor == Py_None)
+    if (implementor.IsNULLOrNone())
         return StructuredData::DictionarySP();
 
-    PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
-    
+    PyRef pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor, callee_name));
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    if (pmeth == nullptr || pmeth == Py_None)
-    {
-        Py_XDECREF(pmeth);
+
+    if (pmeth.IsNULLOrNone())
         return StructuredData::DictionarySP();
-    }
     
     if (PyCallable_Check(pmeth) == 0)
     {
         if (PyErr_Occurred())
-        {
             PyErr_Clear();
-        }
         
-        Py_XDECREF(pmeth);
         return StructuredData::DictionarySP();
     }
     
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    Py_XDECREF(pmeth);
     
     // right now we know this function exists and is callable..
-    PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
-    
+    PyRef py_return(PyRefType::Owned, PyObject_CallMethod(implementor, callee_name, nullptr));
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {
         PyErr_Print();
         PyErr_Clear();
     }
+    assert(PythonDictionary::Check(py_return) && "get_register_info returned unknown object type!");
 
-    PythonDictionary result_dict(py_return);
+    PythonDictionary result_dict(PyRefType::Borrowed, py_return);
     return result_dict.CreateStructuredDictionary();
 }
 

     StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
     if (!generic)
         return nullptr;
-    PyObject *implementor = (PyObject *)generic->GetValue();
 
-    if (implementor == nullptr || implementor == Py_None)
+    PyRef implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
+
+    if (implementor.IsNULLOrNone())
         return StructuredData::ArraySP();
 
-    PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
-    
+    PyRef pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor, callee_name));
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    if (pmeth == nullptr || pmeth == Py_None)
-    {
-        Py_XDECREF(pmeth);
+
+    if (pmeth.IsNULLOrNone())
         return StructuredData::ArraySP();
-    }
     
     if (PyCallable_Check(pmeth) == 0)
     {
         if (PyErr_Occurred())
-        {
             PyErr_Clear();
-        }
         
-        Py_XDECREF(pmeth);
         return StructuredData::ArraySP();
     }
     
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    Py_XDECREF(pmeth);
     
     // right now we know this function exists and is callable..
-    PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
-    
+    PyRef py_return(PyRefType::Owned, PyObject_CallMethod(implementor, callee_name, nullptr));
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {

         PyErr_Clear();
     }
 
-    PythonList ResultList(py_return);
-    return ResultList.CreateStructuredArray();
+    assert(PythonList::Check(py_return) && "get_thread_info returned unknown object type!");
+
+    PythonList result_list(PyRefType::Borrowed, py_return);
+    return result_list.CreateStructuredArray();
 }
 
 // GetPythonValueFormatString provides a system independent type safe way to

     StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
     if (!generic)
         return nullptr;
-    PyObject *implementor = (PyObject *)generic->GetValue();
+    PyRef implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
 
-    if (implementor == nullptr || implementor == Py_None)
+    if (implementor.IsNULLOrNone())
         return StructuredData::StringSP();
 
-    PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
-    
+    PyRef pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor, callee_name));
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    if (pmeth == nullptr || pmeth == Py_None)
-    {
-        Py_XDECREF(pmeth);
+
+    if (pmeth.IsNULLOrNone())
         return StructuredData::StringSP();
-    }
     
     if (PyCallable_Check(pmeth) == 0)
     {
         if (PyErr_Occurred())
-        {
             PyErr_Clear();
-        }
-        
-        Py_XDECREF(pmeth);
         return StructuredData::StringSP();
     }
     
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    Py_XDECREF(pmeth);
     
     // right now we know this function exists and is callable..
-    PyObject* py_return = PyObject_CallMethod(implementor, callee_name, param_format, tid);
+    PyRef py_return(PyRefType::Owned, PyObject_CallMethod(implementor, callee_name, param_format, tid));
 
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())

         PyErr_Print();
         PyErr_Clear();
     }
-    PythonString result_string(py_return);
+
+    assert(PythonString::Check(py_return) && "get_register_data returned unknown object type!");
+
+    PythonString result_string(PyRefType::Borrowed, py_return);
     return result_string.CreateStructuredString();
 }
 

     StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
     if (!generic)
         return nullptr;
-    PyObject *implementor = (PyObject *)generic->GetValue();
 
-    if (implementor == nullptr || implementor == Py_None)
+    PyRef implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
+
+    if (implementor.IsNULLOrNone())
         return StructuredData::DictionarySP();
 
-    PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
-    
+    PyRef pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor, callee_name));
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    if (pmeth == nullptr || pmeth == Py_None)
-    {
-        Py_XDECREF(pmeth);
+
+    if (pmeth.IsNULLOrNone())
         return StructuredData::DictionarySP();
-    }
     
     if (PyCallable_Check(pmeth) == 0)
     {
         if (PyErr_Occurred())
-        {
             PyErr_Clear();
-        }
-        
-        Py_XDECREF(pmeth);
         return StructuredData::DictionarySP();
     }
     
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    Py_XDECREF(pmeth);
     
     // right now we know this function exists and is callable..
-    PyObject* py_return = PyObject_CallMethod(implementor, callee_name, &param_format[0], tid, context);
-    
+    PyRef py_return(PyRefType::Owned, PyObject_CallMethod(implementor, callee_name, &param_format[0], tid, context));
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {

         PyErr_Clear();
     }
 
-    PythonDictionary result_dict(py_return);
+    assert(PythonDictionary::Check(py_return) && "create_thread returned unknown object type!");
+
+    PythonDictionary result_dict(PyRefType::Borrowed, py_return);
     return result_dict.CreateStructuredDictionary();
 }
 

     if (!generic)
         return StructuredData::DictionarySP();
 
-    PyObject *reply_pyobj = nullptr;
-    
+    PyRef reply_pyobj;
     {
         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
         TargetSP target_sp(target->shared_from_this());
-        reply_pyobj = (PyObject *)g_swig_plugin_get(generic->GetValue(), setting_name, target_sp);
+        reply_pyobj.Reset(PyRefType::Owned,
+                          (PyObject *)g_swig_plugin_get(generic->GetValue(), setting_name, target_sp));
     }
 
-    PythonDictionary py_dict(reply_pyobj);
-
+    PythonDictionary py_dict(PyRefType::Borrowed, reply_pyobj);
     return py_dict.CreateStructuredDictionary();
 }
 

 }
 
 static std::string
-ReadPythonBacktrace (PyObject* py_backtrace)
-{
-    PyObject* traceback_module = nullptr,
-    *stringIO_module = nullptr,
-    *stringIO_builder = nullptr,
-    *stringIO_buffer = nullptr,
-    *printTB = nullptr,
-    *printTB_args = nullptr,
-    *printTB_result = nullptr,
-    *stringIO_getvalue = nullptr,
-    *printTB_string = nullptr;
+ReadPythonBacktrace(PyRef py_backtrace)
+{
+    PyRef traceback_module;
+    PyRef stringIO_module;
+    PyRef stringIO_builder;
+    PyRef stringIO_buffer;
+    PyRef printTB;
+    PyRef printTB_args;
+    PyRef printTB_result;
+    PyRef stringIO_getvalue;
+    PyRef printTB_string;
 
     std::string retval("backtrace unavailable");
-    
-    if (py_backtrace && py_backtrace != Py_None)
-    {
-        traceback_module = PyImport_ImportModule("traceback");
-        stringIO_module = PyImport_ImportModule("StringIO");
-        
-        if (traceback_module && traceback_module != Py_None && stringIO_module && stringIO_module != Py_None)
-        {
-            stringIO_builder = PyObject_GetAttrString(stringIO_module, "StringIO");
-            if (stringIO_builder && stringIO_builder != Py_None)
-            {
-                stringIO_buffer = PyObject_CallObject(stringIO_builder, nullptr);
-                if (stringIO_buffer && stringIO_buffer != Py_None)
-                {
-                    printTB = PyObject_GetAttrString(traceback_module, "print_tb");
-                    if (printTB && printTB != Py_None)
-                    {
-                        printTB_args = Py_BuildValue("OOO",py_backtrace,Py_None,stringIO_buffer);
-                        printTB_result = PyObject_CallObject(printTB, printTB_args);
-                        stringIO_getvalue = PyObject_GetAttrString(stringIO_buffer, "getvalue");
-                        if (stringIO_getvalue && stringIO_getvalue != Py_None)
-                        {
-                            printTB_string = PyObject_CallObject (stringIO_getvalue,nullptr);
-                            if (printTB_string && PythonString::Check(printTB_string))
-                            {
-                                PythonString str(printTB_string);
-                                llvm::StringRef string_data(str.GetString());
-                                retval.assign(string_data.data(), string_data.size());
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    Py_XDECREF(traceback_module);
-    Py_XDECREF(stringIO_module);
-    Py_XDECREF(stringIO_builder);
-    Py_XDECREF(stringIO_buffer);
-    Py_XDECREF(printTB);
-    Py_XDECREF(printTB_args);
-    Py_XDECREF(printTB_result);
-    Py_XDECREF(stringIO_getvalue);
-    Py_XDECREF(printTB_string);
+    if (py_backtrace.IsNULLOrNone())
+        return retval;
+
+    traceback_module.Reset(PyRefType::Owned, PyImport_ImportModule("traceback"));
+    stringIO_module.Reset(PyRefType::Owned, PyImport_ImportModule("StringIO"));
+    if (traceback_module.IsNULLOrNone() || stringIO_module.IsNULLOrNone())
+        return retval;
+
+    stringIO_builder.Reset(PyRefType::Owned, PyObject_GetAttrString(stringIO_module, "StringIO"));
+    if (stringIO_builder.IsNULLOrNone())
+        return retval;
+
+    stringIO_buffer.Reset(PyRefType::Owned, PyObject_CallObject(stringIO_builder, nullptr));
+    if (stringIO_buffer.IsNULLOrNone())
+        return retval;
+
+    printTB.Reset(PyRefType::Owned, PyObject_GetAttrString(traceback_module, "print_tb"));
+    if (printTB.IsNULLOrNone())
+        return retval;
+
+    printTB_args.Reset(PyRefType::Owned, Py_BuildValue("OOO", py_backtrace.get(), Py_None, stringIO_buffer.get()));
+    printTB_result.Reset(PyRefType::Owned, PyObject_CallObject(printTB, printTB_args));
+    stringIO_getvalue.Reset(PyRefType::Owned, PyObject_GetAttrString(stringIO_buffer, "getvalue"));
+    if (stringIO_getvalue.IsNULLOrNone())
+        return retval;
+
+    printTB_string.Reset(PyRefType::Owned, PyObject_CallObject(stringIO_getvalue, nullptr));
+    if (printTB_string.IsNULLOrNone())
+        return retval;
+
+    PythonString str(PyRefType::Borrowed, printTB_string);
+    llvm::StringRef string_data(str.GetString());
+    retval.assign(string_data.data(), string_data.size());
+
     return retval;
 }
 

     
     if (!cmd_obj_sp)
         return false;
-    
-    PyObject* implementor = (PyObject*)cmd_obj_sp->GetValue();
-    
-    if (implementor == nullptr || implementor == Py_None)
+    PyRef implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
+    if (implementor.IsNULLOrNone())
         return false;
-    
-    PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
-    
+    PyRef pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor, callee_name));
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    if (pmeth == nullptr || pmeth == Py_None)
-    {
-        Py_XDECREF(pmeth);
+
+    if (pmeth.IsNULLOrNone())
         return false;
-    }
     
     if (PyCallable_Check(pmeth) == 0)
     {
         if (PyErr_Occurred())
-        {
             PyErr_Clear();
-        }
-        
-        Py_XDECREF(pmeth);
         return false;
     }
     
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    Py_XDECREF(pmeth);
     
     // right now we know this function exists and is callable..
-    PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
-    
+    PyRef py_return(PyRefType::Owned, PyObject_CallMethod(implementor, callee_name, nullptr));
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {

         PyErr_Clear();
     }
 
-    if (py_return != Py_None && PythonString::Check(py_return))
+    if (!py_return.IsNULLOrNone() && PythonString::Check(py_return))
     {
-        PythonString py_string(py_return);
+        PythonString py_string(PyRefType::Borrowed, py_return);
         llvm::StringRef return_data(py_string.GetString());
         dest.assign(return_data.data(), return_data.size());
         got_string = true;
     }
-    Py_XDECREF(py_return);
-    
     return got_string;
 }
 

     
     if (!cmd_obj_sp)
         return result;
-    
-    PyObject* implementor = (PyObject*)cmd_obj_sp->GetValue();
-    
-    if (implementor == nullptr || implementor == Py_None)
+    PyRef implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
+    if (implementor.IsNULLOrNone())
         return result;
-    
-    PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
-    
+    PyRef pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor, callee_name));
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    if (pmeth == nullptr || pmeth == Py_None)
-    {
-        Py_XDECREF(pmeth);
+
+    if (pmeth.IsNULLOrNone())
         return result;
-    }
     
     if (PyCallable_Check(pmeth) == 0)
     {
         if (PyErr_Occurred())
-        {
             PyErr_Clear();
-        }
-        
-        Py_XDECREF(pmeth);
         return result;
     }
     
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    Py_XDECREF(pmeth);
     
     // right now we know this function exists and is callable..
-    PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
-    
+    PyRef py_return(PyRefType::Owned, PyObject_CallMethod(implementor, callee_name, nullptr));
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {

         PyErr_Clear();
     }
 
-    if (py_return != Py_None && PythonInteger::Check(py_return))
+    if (!py_return.IsNULLOrNone() && PythonInteger::Check(py_return))
     {
-        PythonInteger int_value(py_return);
+        PythonInteger int_value(PyRefType::Borrowed, py_return);
         result = int_value.GetInteger();
     }
-    Py_XDECREF(py_return);
     
     return result;
 }

     
     if (!cmd_obj_sp)
         return false;
-    
-    PyObject* implementor = (PyObject*)cmd_obj_sp->GetValue();
-    
-    if (implementor == nullptr || implementor == Py_None)
+    PyRef implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
+    if (implementor.IsNULLOrNone())
         return false;
-    
-    PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
-    
+    PyRef pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor, callee_name));
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    if (pmeth == nullptr || pmeth == Py_None)
-    {
-        Py_XDECREF(pmeth);
+
+    if (pmeth.IsNULLOrNone())
         return false;
-    }
     
     if (PyCallable_Check(pmeth) == 0)
     {
         if (PyErr_Occurred())
-        {
             PyErr_Clear();
-        }
         
-        Py_XDECREF(pmeth);
         return false;
     }
     
     if (PyErr_Occurred())
-    {
         PyErr_Clear();
-    }
-    
-    Py_XDECREF(pmeth);
     
     // right now we know this function exists and is callable..
-    PyObject* py_return = PyObject_CallMethod(implementor, callee_name, nullptr);
-    
+    PyRef py_return(PyRefType::Owned, PyObject_CallMethod(implementor, callee_name, nullptr));
     // if it fails, print the error but otherwise go on
     if (PyErr_Occurred())
     {

         PyErr_Clear();
     }
 
-    if (py_return != Py_None && PythonString::Check(py_return))
+    if (!py_return.IsNULLOrNone() && PythonString::Check(py_return))
     {
-        PythonString str(py_return);
+        PythonString str(PyRefType::Borrowed, py_return);
         llvm::StringRef str_data(str.GetString());
         dest.assign(str_data.data(), str_data.size());
         got_string = true;
     }
-    Py_XDECREF(py_return);
     
     return got_string;
 }

unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

     SetUp() override
     {
         HostInfoBase::Initialize();
-        // ScriptInterpreterPython::Initialize() depends on things like HostInfo being initialized
-        // so it can compute the python directory etc, so we need to do this after
-        // SystemInitializerCommon::Initialize().
+        // ScriptInterpreterPython::Initialize() depends on HostInfo being
+        // initializedso it can compute the python directory etc.
         ScriptInterpreterPython::Initialize();
+
+        // Although we don't care about concurrency for the purposes of running
+        // this test suite, Python requires the GIL to be locked even for
+        // deallocating memory, which can happen when you call Py_DECREF or
+        // Py_INCREF.  So acquire the GIL for the entire duration of this
+        // test suite.
+        m_gil_state = PyGILState_Ensure();
     }
 
     void
     TearDown() override
     {
+        PyGILState_Release(m_gil_state);
+
         ScriptInterpreterPython::Terminate();
     }
+
+  private:
+    PyGILState_STATE m_gil_state;
 };
 
+TEST_F(PythonDataObjectsTest, TestOwnedReferences)
+{
+    // After creating a new object, the refcount should be 1
+    PyObject *obj = PyLong_FromLong(3);
+    EXPECT_EQ(1, obj->ob_refcnt);
+
+    // If we take an owned reference, the refcount should still be 1
+    PyRef owned_long(PyRefType::Owned, obj);
+    EXPECT_EQ(1, owned_long.get()->ob_refcnt);
+
+    // Take another reference and verify that the refcount increases
+    PyRef strong_ref(owned_long);
+    EXPECT_EQ(2, strong_ref.get()->ob_refcnt);
+
+    // If we reset the first one, the refcount should be 1 again.
+    owned_long.Reset();
+    EXPECT_EQ(1, strong_ref.get()->ob_refcnt);
+}
+
+TEST_F(PythonDataObjectsTest, TestResetting)
+{
+    PythonDictionary dict(PyInitialValue::Empty);
+
+    PyObject *new_dict = PyDict_New();
+    dict.Reset(PyRefType::Owned, new_dict);
+    EXPECT_EQ(new_dict, dict.get());
+
+    dict.Reset(PyRefType::Owned, nullptr);
+    EXPECT_EQ(nullptr, dict.get());
+
+    dict.Reset(PyRefType::Owned, PyDict_New());
+    EXPECT_NE(nullptr, dict.get());
+    dict.Reset();
+    EXPECT_EQ(nullptr, dict.get());
+}
+
+TEST_F(PythonDataObjectsTest, TestBorrowedReferences)
+{
+    PythonInteger long_value(PyRefType::Owned, PyLong_FromLong(3));
+    EXPECT_EQ(1, long_value.get()->ob_refcnt);
+
+    PythonInteger borrowed_long(PyRefType::Borrowed, long_value.get());
+    EXPECT_EQ(2, borrowed_long.get()->ob_refcnt);
+}
+
 TEST_F(PythonDataObjectsTest, TestPythonInteger)
 {
 // Test that integers behave correctly when wrapped by a PythonInteger.

     // Note that PyInt doesn't exist in Python 3.x, so this is only for 2.x
     PyObject *py_int = PyInt_FromLong(12);
     EXPECT_TRUE(PythonInteger::Check(py_int));
-    PythonInteger python_int(py_int);
+    PythonInteger python_int(PyRefType::Owned, py_int);
 
     EXPECT_EQ(PyObjectType::Integer, python_int.GetObjectType());
     EXPECT_EQ(12, python_int.GetInteger());

     // Verify that `PythonInt` works correctly when given a PyLong object.
     PyObject *py_long = PyLong_FromLong(12);
     EXPECT_TRUE(PythonInteger::Check(py_long));
-    PythonInteger python_long(py_long);
+    PythonInteger python_long(PyRefType::Owned, py_long);
     EXPECT_EQ(PyObjectType::Integer, python_long.GetObjectType());
 
     // Verify that you can reset the value and that it is reflected properly.

     // Note that PyString doesn't exist in Python 3.x, so this is only for 2.x
     PyObject *py_string = PyString_FromString(test_string);
     EXPECT_TRUE(PythonString::Check(py_string));
-    PythonString python_string(py_string);
+    PythonString python_string(PyRefType::Owned, py_string);
 
     EXPECT_EQ(PyObjectType::String, python_string.GetObjectType());
     EXPECT_STREQ(test_string, python_string.GetString().data());

     // Verify that `PythonString` works correctly when given a PyUnicode object.
     PyObject *py_unicode = PyUnicode_FromString(test_string);
     EXPECT_TRUE(PythonString::Check(py_unicode));
-    PythonString python_unicode(py_unicode);
+    PythonString python_unicode(PyRefType::Owned, py_unicode);
 
     EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType());
     EXPECT_STREQ(test_string, python_unicode.GetString().data());

     static const long long_idx0 = 5;
     static const char *const string_idx1 = "String Index 1";
 
-    PyObject *list_items[list_size];
-
     PyObject *py_list = PyList_New(2);
-    list_items[0] = PyLong_FromLong(long_idx0);
-    list_items[1] = PyString_FromString(string_idx1);
+    EXPECT_TRUE(PythonList::Check(py_list));
+    PythonList list(PyRefType::Owned, py_list);
 
-    for (int i = 0; i < list_size; ++i)
-        PyList_SetItem(py_list, i, list_items[i]);
+    PyRef list_items[list_size];
+    list_items[0].Reset(PyRefType::Owned, PyLong_FromLong(long_idx0));
+    list_items[1].Reset(PyRefType::Owned, PyString_FromString(string_idx1));
 
-    EXPECT_TRUE(PythonList::Check(py_list));
+    for (int i = 0; i < list_size; ++i)
+        list.SetItemAtIndex(i, list_items[i]);
 
-    PythonList list(py_list);
     EXPECT_EQ(list_size, list.GetSize());
     EXPECT_EQ(PyObjectType::List, list.GetObjectType());
 

     // Python API behaves correctly when wrapped by a PythonDictionary.
     static const int dict_entries = 2;
 
-    PyObject *keys[dict_entries];
-    PyObject *values[dict_entries];
+    PyRef keys[dict_entries];
+    PyRef values[dict_entries];
 
-    keys[0] = PyString_FromString("Key 0");
-    keys[1] = PyLong_FromLong(1);
-    values[0] = PyLong_FromLong(0);
-    values[1] = PyString_FromString("Value 1");
+    keys[0].Reset(PyRefType::Owned, PyString_FromString("Key 0"));
+    keys[1].Reset(PyRefType::Owned, PyLong_FromLong(1));
+    values[0].Reset(PyRefType::Owned, PyLong_FromLong(0));
+    values[1].Reset(PyRefType::Owned, PyString_FromString("Value 1"));
 
     PyObject *py_dict = PyDict_New();
-    for (int i = 0; i < dict_entries; ++i)
-        PyDict_SetItem(py_dict, keys[i], values[i]);
-
     EXPECT_TRUE(PythonDictionary::Check(py_dict));
+    PythonDictionary dict(PyRefType::Owned, py_dict);
 
-    PythonDictionary dict(py_dict);
+    for (int i = 0; i < dict_entries; ++i)
+        PyDict_SetItem(py_dict, keys[i], values[i]);
     EXPECT_EQ(dict.GetSize(), dict_entries);
     EXPECT_EQ(PyObjectType::Dictionary, dict.GetObjectType());
 

     static const long long_idx0 = 5;
     static const char *const string_idx1 = "String Index 1";
 
-    PyObject *py_list = PyList_New(0);
-    PythonList list(py_list);
+    PythonList list(PyInitialValue::Empty);
     PythonInteger integer(long_idx0);
     PythonString string(string_idx1);
 

     // by a PythonDictionary.
     static const int dict_entries = 2;
 
-    PyObject *keys[dict_entries];
-    PyObject *values[dict_entries];
-
-    keys[0] = PyString_FromString("Key 0");
-    keys[1] = PyString_FromString("Key 1");
-    values[0] = PyLong_FromLong(1);
-    values[1] = PyString_FromString("Value 1");
+    PythonString keys[dict_entries];
+    PyRef values[dict_entries];
 
-    PyObject *py_dict = PyDict_New();
+    keys[0].Reset(PyRefType::Owned, PyString_FromString("Key 0"));
+    keys[1].Reset(PyRefType::Owned, PyString_FromString("Key 1"));
+    values[0].Reset(PyRefType::Owned, PyLong_FromLong(1));
+    values[1].Reset(PyRefType::Owned, PyString_FromString("Value 1"));
 
-    PythonDictionary dict(py_dict);
+    PythonDictionary dict(PyInitialValue::Empty);
     for (int i = 0; i < 2; ++i)
-        dict.SetItemForKey(PythonString(keys[i]), values[i]);
+        dict.SetItemForKey(keys[i], values[i]);
 
     EXPECT_EQ(dict_entries, dict.GetSize());
 

     static const char *const nested_dict_key1 = "Nested Key 1";
     static const long nested_dict_value1 = 2;
 
-    PythonList list;
-    PythonList nested_list;
-    PythonDictionary nested_dict;
+    PythonList list(PyInitialValue::Empty);
+    PythonList nested_list(PyInitialValue::Empty);
+    PythonDictionary nested_dict(PyInitialValue::Empty);
 
     nested_list.AppendItem(PythonInteger(nested_list_long_idx0));
     nested_list.AppendItem(PythonString(nested_list_str_idx1));

     static const char *const nested_dict_value0 = "Nested Dict Value 0";
     static const long nested_dict_value1 = 7;
 
-    PythonDictionary dict;
-    PythonDictionary nested_dict;
-    PythonList nested_list;
+    PythonDictionary dict(PyInitialValue::Empty);
+    PythonDictionary nested_dict(PyInitialValue::Empty);
+    PythonList nested_list(PyInitialValue::Empty);
 
     nested_dict.SetItemForKey(PythonString(nested_dict_keys[0]), PythonString(nested_dict_value0));
     nested_dict.SetItemForKey(PythonString(nested_dict_keys[1]), PythonInteger(nested_dict_value1));