Hmm

from_cpython/Include/Python.h

@@ -123,6 +123,11 @@ PyAPI_FUNC(int) PyObject_DelHcAttrString(PyObject*, const char*) PYSTON_NOEXCEPT
 // Workaround: call this instead of setting tp_dict.
 PyAPI_FUNC(void) PyType_SetDict(PyTypeObject*, PyObject*) PYSTON_NOEXCEPT;
 
+// Pyston addition: register an object as a "static constant".  Current purpose is that this will
+// get decref'd when the interpreter shuts down.
+// PyType_Ready calls this automatically.
+PyAPI_FUNC(void) PyGC_RegisterStaticConstant(PyObject*) PYSTON_NOEXCEPT;
+
 #include "codecs.h"
 #include "pyerrors.h"
 

from_cpython/Modules/threadmodule.c

@@ -945,6 +945,7 @@ initthread(void)
     str_dict = PyString_InternFromString("__dict__");
     if (str_dict == NULL)
         return;
+    PyGC_RegisterStaticConstant(str_dict);
 
     /* Initialize the C thread library */
     //PyThread_init_thread(); // pyston change

src/runtime/builtin_modules/thread.cpp

@@ -206,7 +206,7 @@ void setupThread() {
     initthread();
     RELEASE_ASSERT(!PyErr_Occurred(), "");
 
-    Box* thread_module = getSysModulesDict()->getOrNull(boxString("thread"));
+    Box* thread_module = getSysModulesDict()->getOrNull(autoDecref(boxString("thread")));
     assert(thread_module);
 
     thread_module->giveAttr(
@@ -231,17 +231,17 @@ void setupThread() {
     thread_lock_cls->giveAttr("__module__", boxString("thread"));
     thread_lock_cls->giveAttr("acquire", new BoxedFunction(FunctionMetadata::create((void*)BoxedThreadLock::acquire,
                                                                                     BOXED_BOOL, 2, false, false),
-                                                           { boxInt(1) }));
+                                                           { autoDecref(boxInt(1)) }));
     thread_lock_cls->giveAttr("release",
                               new BoxedFunction(FunctionMetadata::create((void*)BoxedThreadLock::release, NONE, 1)));
-    thread_lock_cls->giveAttr("acquire_lock", thread_lock_cls->getattr(internStringMortal("acquire")));
-    thread_lock_cls->giveAttr("release_lock", thread_lock_cls->getattr(internStringMortal("release")));
-    thread_lock_cls->giveAttr("__enter__", thread_lock_cls->getattr(internStringMortal("acquire")));
+    thread_lock_cls->giveAttrBorrowed("acquire_lock", thread_lock_cls->getattr(getStaticString("acquire")));
+    thread_lock_cls->giveAttrBorrowed("release_lock", thread_lock_cls->getattr(getStaticString("release")));
+    thread_lock_cls->giveAttrBorrowed("__enter__", thread_lock_cls->getattr(getStaticString("acquire")));
     thread_lock_cls->giveAttr("__exit__",
                               new BoxedFunction(FunctionMetadata::create((void*)BoxedThreadLock::exit, NONE, 4)));
     thread_lock_cls->giveAttr(
         "locked", new BoxedFunction(FunctionMetadata::create((void*)BoxedThreadLock::locked, BOXED_BOOL, 1)));
-    thread_lock_cls->giveAttr("locked_lock", thread_lock_cls->getattr(internStringMortal("locked")));
+    thread_lock_cls->giveAttrBorrowed("locked_lock", thread_lock_cls->getattr(getStaticString("locked")));
     thread_lock_cls->freeze();
 
     ThreadError = BoxedClass::create(type_cls, Exception, Exception->attrs_offset, Exception->tp_weaklistoffset,
@@ -249,6 +249,6 @@ void setupThread() {
     ThreadError->giveAttr("__module__", boxString("thread"));
     ThreadError->freeze();
 
-    thread_module->giveAttr("error", ThreadError);
+    thread_module->giveAttrBorrowed("error", ThreadError);
 }
 }

src/runtime/types.cpp

@@ -3431,6 +3431,9 @@ void BoxedClass::dealloc(Box* b) noexcept {
 #endif
 
 std::vector<Box*> constants;
+extern "C" void PyGC_RegisterStaticConstant(Box* b) {
+    constants.push_back(b);
+}
 
 extern "C" void _PyUnicode_Fini(void);
 
@@ -3922,7 +3925,7 @@ void setupRuntime() {
     attrwrapperiter_cls->tp_iternext = AttrWrapperIter::next_capi;
 
     setupBuiltins();
-    //_PyExc_Init();
+    _PyExc_Init();
     //setupThread();
     //initgc();
     //setupImport();

src/runtime/types.h

@@ -796,7 +796,7 @@ public:
 
     DEFAULT_CLASS_SIMPLE(dict_cls, true);
 
-    Box* getOrNull(Box* k) {
+    BORROWED(Box*) getOrNull(Box* k) {
         const auto& p = d.find(BoxAndHash(k));
         if (p != d.end())
             return p->second;