try to initalize all builtin types with PyType_Ready to avoid problems like #5787

diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index aa5bde42ab9a63d8600e77902969ac347752d817..b5c767c6bfe794d4315be4a9c6f746747a7db12e 100644 (file)
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -1,3 +1,4 @@
+import __builtin__
 import types
 import unittest
 import warnings
@@ -3895,6 +3896,17 @@ order (MRO) for bases """
         else:
             self.fail("new-style class must have a new-style base")
 
+    def test_builtin_bases(self):
+        # Make sure all the builtin types can have their base queried without
+        # segfaulting. See issue #5787.
+        builtin_types = [tp for tp in __builtin__.__dict__.itervalues()
+                         if isinstance(tp, type)]
+        for tp in builtin_types:
+            object.__getattribute__(tp, "__bases__")
+            if tp is not object:
+                self.assertEqual(len(tp.__bases__), 1, tp)
+
+
     def test_mutable_bases_with_failing_mro(self):
         # Testing mutable bases with failing mro...
         class WorkOnce(type):

diff --git a/Misc/NEWS b/Misc/NEWS
index 58197de04901acf6dd4b7dc9c0480d06b4d0ad3e..c2a07ece766f97159c33a1037ba8c01389e113a0 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -12,6 +12,9 @@ What's New in Python 2.7 alpha 1
 Core and Builtins
 -----------------
 
+- Issue #5787: object.__getattribute__(some_type, "__bases__") segfaulted on
+  some builtin types.
+
 - Issue #1869: fix a couple of minor round() issues.  round(5e15+1)
     was giving 5e15+2; round(-0.0) was losing the sign of the zero.
 

diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index c8cf71b34c0b554efd96d5bc9f07b9825c2aebeb..4ac1ab02ddf5f9700dfe32315feaba2b5e01f326 100644 (file)
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -606,14 +606,6 @@ int _PyFrame_Init()
        builtin_object = PyString_InternFromString("__builtins__");
        if (builtin_object == NULL)
                return 0;
-       /* 
-          Traceback objects are not created the normal way (through calling the
-          type), so PyType_Ready has to be called here.
-       */
-       if (PyType_Ready(&PyTraceBack_Type)) {
-               Py_DECREF(builtin_object);
-               return 0;
-       }
        return 1;
 }
 

diff --git a/Objects/object.c b/Objects/object.c
index 7395b0c2f774e96aca7f0f3a9ac7fa33003041c1..b8f135219888f56e2bfc757368da01614dc26638 100644 (file)
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -2033,28 +2033,88 @@ void
 _Py_ReadyTypes(void)
 {
        if (PyType_Ready(&PyType_Type) < 0)
-               Py_FatalError("Can't initialize 'type'");
+               Py_FatalError("Can't initialize type type");
 
        if (PyType_Ready(&_PyWeakref_RefType) < 0)
-               Py_FatalError("Can't initialize 'weakref'");
+               Py_FatalError("Can't initialize weakref type");
 
        if (PyType_Ready(&PyBool_Type) < 0)
-               Py_FatalError("Can't initialize 'bool'");
+               Py_FatalError("Can't initialize bool type");
 
        if (PyType_Ready(&PyString_Type) < 0)
-               Py_FatalError("Can't initialize 'str'");
+               Py_FatalError("Can't initialize str type");
 
        if (PyType_Ready(&PyByteArray_Type) < 0)
-               Py_FatalError("Can't initialize 'bytes'");
+               Py_FatalError("Can't initialize bytearray");
 
        if (PyType_Ready(&PyList_Type) < 0)
-               Py_FatalError("Can't initialize 'list'");
+               Py_FatalError("Can't initialize list");
 
        if (PyType_Ready(&PyNone_Type) < 0)
-               Py_FatalError("Can't initialize type(None)");
+               Py_FatalError("Can't initialize None type");
 
        if (PyType_Ready(&PyNotImplemented_Type) < 0)
-               Py_FatalError("Can't initialize type(NotImplemented)");
+               Py_FatalError("Can't initialize NotImplemented type");
+
+       if (PyType_Ready(&PyTraceBack_Type) < 0)
+               Py_FatalError("Can't initialize traceback type");
+
+       if (PyType_Ready(&PySuper_Type) < 0)
+               Py_FatalError("Can't initialize super type");
+
+       if (PyType_Ready(&PyBaseObject_Type) < 0)
+               Py_FatalError("Can't initialize object type");
+
+       if (PyType_Ready(&PyRange_Type) < 0)
+               Py_FatalError("Can't initialize xrange type");
+
+       if (PyType_Ready(&PyDict_Type) < 0)
+               Py_FatalError("Can't initialize dict type");
+
+       if (PyType_Ready(&PySet_Type) < 0)
+               Py_FatalError("Can't initialize set type");
+
+       if (PyType_Ready(&PyUnicode_Type) < 0)
+               Py_FatalError("Can't initialize unicode type");
+
+       if (PyType_Ready(&PySlice_Type) < 0)
+               Py_FatalError("Can't initialize slice type");
+
+       if (PyType_Ready(&PyStaticMethod_Type) < 0)
+               Py_FatalError("Can't initialize static method type");
+
+       if (PyType_Ready(&PyComplex_Type) < 0)
+               Py_FatalError("Can't initalize complex type");
+
+       if (PyType_Ready(&PyFloat_Type) < 0)
+               Py_FatalError("Can't initalize float type");
+
+       if (PyType_Ready(&PyBuffer_Type) < 0)
+               Py_FatalError("Can't initialize buffer type");
+
+       if (PyType_Ready(&PyLong_Type) < 0)
+               Py_FatalError("Can't initialize long type");
+
+       if (PyType_Ready(&PyInt_Type) < 0)
+               Py_FatalError("Can't initialize int type");
+
+       if (PyType_Ready(&PyFrozenSet_Type) < 0)
+               Py_FatalError("Can't initialize frozenset type");
+
+       if (PyType_Ready(&PyProperty_Type) < 0)
+               Py_FatalError("Can't initialize property type");
+
+       if (PyType_Ready(&PyMemoryView_Type) < 0)
+               Py_FatalError("Can't initialize memoryview type");
+
+       if (PyType_Ready(&PyTuple_Type) < 0)
+               Py_FatalError("Can't initalize tuple type");
+
+       if (PyType_Ready(&PyEnum_Type) < 0)
+               Py_FatalError("Can't initalize enumerate type");
+
+       if (PyType_Ready(&PyReversed_Type) < 0)
+               Py_FatalError("Can't initalize reversed type");
 }