gh-102029: Sync __new__ sigs of _CRLock and _PyRLock in threading

Author: sobolevn

Doc/whatsnew/3.12.rst

@@ -332,6 +332,12 @@ threading
   profiling functions in all running threads in addition to the calling one.
   (Contributed by Pablo Galindo in :gh:`93503`.)
 
+* Passing any arguments to :func:`threading.RLock` is now restricted.
+  Previously C version allowed any numbers of args and kwargs,
+  but they were just ignored. Python version never allowed any arguments.
+  Now, these two implementation match.
+  (Contributed by Nikita Sobolev in :gh:`102029`.)
+
 unicodedata
 -----------
 

Lib/test/lock_tests.py

@@ -293,7 +293,7 @@ def use_lock(lock):
         use_lock(lock2)
 
 
-class RLockTests(BaseLockTests):
+class RLockAPITests(BaseLockTests):
     """
     Tests for recursive locks.
     """
@@ -360,6 +360,31 @@ def f():
         self.assertFalse(lock._is_owned())
 
 
+class RLockTests(RLockAPITests):
+    def test_signature(self):  # gh-102029
+        # 0 args are fine:
+        self.locktype()
+        self.locktype(*(), **{})
+
+        # no other args are allowed:
+        arg_types = [
+            ((1,), {}),
+            ((), {'a': 1}),
+            ((1, 2), {'a': 1}),
+        ]
+        for args, kwargs in arg_types:
+            with self.subTest(args=args, kwargs=kwargs):
+                with self.assertRaises(TypeError):
+                    self.locktype(*args, **kwargs)
+
+        # Subtypes with custom `__init__` are allowed (but, not recommended):
+        class CustomRLock(self.locktype):
+            def __init__(self, a, *, b) -> None:
+                super().__init__()
+
+        CustomRLock(1, b=2)
+
+
 class EventTests(BaseTestCase):
     """
     Tests for Event objects.

Lib/test/test_threading.py

@@ -1722,7 +1722,7 @@ class CRLockTests(lock_tests.RLockTests):
 class EventTests(lock_tests.EventTests):
     eventtype = staticmethod(threading.Event)
 
-class ConditionAsRLockTests(lock_tests.RLockTests):
+class ConditionAsRLockTests(lock_tests.RLockAPITests):
     # Condition uses an RLock by default and exports its API.
     locktype = staticmethod(threading.Condition)
 

Lib/threading.py

@@ -107,7 +107,7 @@ def gettrace():
 
 Lock = _allocate_lock
 
-def RLock(*args, **kwargs):
+def RLock():
     """Factory function that returns a new reentrant lock.
 
     A reentrant lock must be released by the thread that acquired it. Once a
@@ -117,8 +117,8 @@ def RLock(*args, **kwargs):
 
     """
     if _CRLock is None:
-        return _PyRLock(*args, **kwargs)
-    return _CRLock(*args, **kwargs)
+        return _PyRLock()
+    return _CRLock()
 
 class _RLock:
     """This class implements reentrant lock objects.

Misc/NEWS.d/next/Library/2023-02-20-15-41-59.gh-issue-102029.9ZPG99.rst

@@ -0,0 +1,2 @@
+Sync ``__new__`` signatures of ``threading._CRLock`` and
+``threading._PyRLock``. Now they both require 0 arguments.

Modules/_threadmodule.c

@@ -505,6 +505,22 @@ For internal use by `threading.Condition`.");
 static PyObject *
 rlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
+    // Can later be converted to AC:
+    if (type->tp_init == PyBaseObject_Type.tp_init) {
+        int rc = 0;
+        if (args != NULL)
+            rc = PyObject_IsTrue(args);
+        if (rc == 0 && kwds != NULL)
+            rc = PyObject_IsTrue(kwds);
+        if (rc != 0) {
+            if (rc > 0) {
+                PyErr_SetString(PyExc_TypeError,
+                                "Initialization arguments are not supported");
+            }
+            return NULL;
+        }
+    }
+
     rlockobject *self = (rlockobject *) type->tp_alloc(type, 0);
     if (self == NULL) {
         return NULL;