Update signatures for the new revision.

Author: ZeroIntensity

Include/cpython/pystate.h

@@ -286,41 +286,42 @@ PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc(
 
 typedef uintptr_t PyInterpreterLock;
 
-PyAPI_FUNC(int) PyInterpreterLock_FromCurrent(PyInterpreterLock *ref);
-PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_Copy(PyInterpreterLock ref);
-PyAPI_FUNC(int) PyUnstable_InterpreterView_FromDefault(PyInterpreterLock *ref);
-PyAPI_FUNC(void) PyInterpreterLock_Release(PyInterpreterLock ref);
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterLock_GetInterpreter(PyInterpreterLock ref);
-
-#define PyInterpreterLock_Release(ref) do {    \
-    PyInterpreterLock_Release(ref);            \
-    ref = 0;                                \
+PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_FromCurrent(void);
+PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_Copy(PyInterpreterLock lock);
+PyAPI_FUNC(void) PyInterpreterLock_Release(PyInterpreterLock lock);
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterLock_GetInterpreter(PyInterpreterLock lock);
+PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_FromView(PyInterpreterView view);
+
+#define PyInterpreterLock_Release(lock) do {    \
+    PyInterpreterLock_Release(lock);            \
+    ref = 0;                                    \
 } while (0)
 
-/* Weak interpreter references */
+/* Interpreter views */
 
 typedef struct _PyInterpreterView {
     int64_t id;
     Py_ssize_t refcount;
 } _PyInterpreterView;
 
-typedef _PyInterpreterView *PyInterpreterView;
+typedef uintptr_t PyInterpreterView;
 
-PyAPI_FUNC(int) PyInterpreterView_FromCurrent(PyInterpreterView *ptr);
-PyAPI_FUNC(PyInterpreterView) PyInterpreterView_Copy(PyInterpreterView wref);
-PyAPI_FUNC(int) PyInterpreterLock_FromView(PyInterpreterView wref, PyInterpreterLock *strong_ptr);
-PyAPI_FUNC(void) PyInterpreterView_Close(PyInterpreterView wref);
+PyAPI_FUNC(PyInterpreterView) PyInterpreterView_FromCurrent(void);
+PyAPI_FUNC(PyInterpreterView) PyInterpreterView_Copy(PyInterpreterView view);
+PyAPI_FUNC(void) PyInterpreterView_Close(PyInterpreterView view);
+PyAPI_FUNC(PyInterpreterView) PyUnstable_InterpreterView_FromDefault(void);
 
-#define PyInterpreterView_Close(ref) do {    \
-    PyInterpreterView_Close(ref);            \
-    ref = 0;                                    \
+
+#define PyInterpreterView_Close(view) do {    \
+    PyInterpreterView_Close(view);            \
+    ref = 0;                                  \
 } while (0)
 
 
-/* Thread references */
+/* Thread views */
 
 typedef uintptr_t PyThreadView;
 
-PyAPI_FUNC(int) PyThreadState_Ensure(PyInterpreterLock interp_ref, PyThreadView *thread_ref);
+PyAPI_FUNC(PyThreadView) PyThreadState_Ensure(PyInterpreterLock lock);
 
 PyAPI_FUNC(void) PyThreadState_Release(PyThreadView thread_ref);

Include/internal/pycore_interp_structs.h

@@ -973,8 +973,8 @@ struct _is {
 
     struct {
         _PyRWMutex lock;
-        Py_ssize_t refcount;
-    } references;
+        Py_ssize_t countdown;
+    } finalization_locks;
 
     /* the initial PyInterpreterState.threads.head */
     _PyThreadStateImpl _initial_thread;

Include/internal/pycore_pystate.h

@@ -330,7 +330,7 @@ _Py_RecursionLimit_GetMargin(PyThreadState *tstate)
 }
 
 // Exports for '_testinternalcapi' shared extension
-PyAPI_FUNC(Py_ssize_t) _PyInterpreterState_Refcount(PyInterpreterState *interp);
+PyAPI_FUNC(Py_ssize_t) _PyInterpreterState_LockCountdown(PyInterpreterState *interp);
 
 #ifdef __cplusplus
 }

Modules/_testinternalcapi.c

@@ -2424,18 +2424,18 @@ static PyObject *
 test_interp_refcount(PyObject *self, PyObject *unused)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
-    assert(_PyInterpreterState_Refcount(interp) == 0);
+    assert(_PyInterpreterState_LockCountdown(interp) == 0);
     PyInterpreterLock refs[NUM_REFS];
     for (int i = 0; i < NUM_REFS; ++i) {
         int res = PyInterpreterLock_FromCurrent(&refs[i]);
         (void)res;
         assert(res == 0);
-        assert(_PyInterpreterState_Refcount(interp) == i + 1);
+        assert(_PyInterpreterState_LockCountdown(interp) == i + 1);
     }
 
     for (int i = 0; i < NUM_REFS; ++i) {
         PyInterpreterLock_Release(refs[i]);
-        assert(_PyInterpreterState_Refcount(interp) == (NUM_REFS - i - 1));
+        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_REFS - i - 1));
     }
 
     Py_RETURN_NONE;
@@ -2449,7 +2449,7 @@ test_interp_weakref_incref(PyObject *self, PyObject *unused)
     if (PyInterpreterView_FromCurrent(&wref) < 0) {
         return NULL;
     }
-    assert(_PyInterpreterState_Refcount(interp) == 0);
+    assert(_PyInterpreterState_LockCountdown(interp) == 0);
 
     PyInterpreterLock refs[NUM_REFS];
 
@@ -2458,12 +2458,12 @@ test_interp_weakref_incref(PyObject *self, PyObject *unused)
         (void)res;
         assert(res == 0);
         assert(PyInterpreterLock_GetInterpreter(refs[i]) == interp);
-        assert(_PyInterpreterState_Refcount(interp) == i + 1);
+        assert(_PyInterpreterState_LockCountdown(interp) == i + 1);
     }
 
     for (int i = 0; i < NUM_REFS; ++i) {
         PyInterpreterLock_Release(refs[i]);
-        assert(_PyInterpreterState_Refcount(interp) == (NUM_REFS - i - 1));
+        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_REFS - i - 1));
     }
 
     PyInterpreterView_Close(wref);