Fix for an obscure bug introduced by revs 46806 and 46808, with a test.
The problem of checking too eagerly for recursive calls is the
following: if a RuntimeError is caused by recursion, and if code needs
to normalize it immediately (as in the 2nd test), then
PyErr_NormalizeException() needs a call to the RuntimeError class to
instantiate it, and this hits the recursion limit again... causing
PyErr_NormalizeException() to never finish.
Moved this particular recursion check to slot_tp_call(), which is not
involved in instantiating built-in exceptions.
Backport candidate.
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index 45f5188..ec8895c 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -305,6 +305,18 @@
x = DerivedException(fancy_arg=42)
self.assertEquals(x.fancy_arg, 42)
+ def testInfiniteRecursion(self):
+ def f():
+ return f()
+ self.assertRaises(RuntimeError, f)
+
+ def g():
+ try:
+ return g()
+ except ValueError:
+ return -1
+ self.assertRaises(RuntimeError, g)
+
def test_main():
run_unittest(ExceptionTests)
diff --git a/Objects/abstract.c b/Objects/abstract.c
index d16660b..638e417 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -1796,17 +1796,7 @@
ternaryfunc call;
if ((call = func->ob_type->tp_call) != NULL) {
- PyObject *result = NULL;
- /* slot_tp_call() will be called and ends up calling
- PyObject_Call() if the object returned for __call__ has
- __call__ itself defined upon it. This can be an infinite
- recursion if you set __call__ in a class to an instance of
- it. */
- if (Py_EnterRecursiveCall(" in __call__")) {
- return NULL;
- }
- result = (*call)(func, arg, kw);
- Py_LeaveRecursiveCall();
+ PyObject *result = (*call)(func, arg, kw);
if (result == NULL && !PyErr_Occurred())
PyErr_SetString(
PyExc_SystemError,
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 439676f..760ef95 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -4590,7 +4590,16 @@
if (meth == NULL)
return NULL;
+
+ /* PyObject_Call() will end up calling slot_tp_call() again if
+ the object returned for __call__ has __call__ itself defined
+ upon it. This can be an infinite recursion if you set
+ __call__ in a class to an instance of it. */
+ if (Py_EnterRecursiveCall(" in __call__"))
+ return NULL;
res = PyObject_Call(meth, args, kwds);
+ Py_LeaveRecursiveCall();
+
Py_DECREF(meth);
return res;
}