Use the new names for the API.

ZeroIntensity · ZeroIntensity · commit cbd72541bbe1 · 2025-10-04T10:40:31.000-04:00
diff --git a/Include/cpython/pystate.h b/Include/cpython/pystate.h
@@ -284,43 +284,43 @@ PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc(
 
 /* Strong interpreter references */
 
-typedef uintptr_t PyInterpreterRef;
+typedef uintptr_t PyInterpreterLock;
 
-PyAPI_FUNC(int) PyInterpreterRef_FromCurrent(PyInterpreterRef *ref);
-PyAPI_FUNC(PyInterpreterRef) PyInterpreterRef_Dup(PyInterpreterRef ref);
-PyAPI_FUNC(int) PyUnstable_GetDefaultInterpreterRef(PyInterpreterRef *ref);
-PyAPI_FUNC(void) PyInterpreterRef_Close(PyInterpreterRef ref);
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterRef_GetInterpreter(PyInterpreterRef ref);
+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 PyInterpreterRef_Close(ref) do {    \
-    PyInterpreterRef_Close(ref);            \
+#define PyInterpreterLock_Release(ref) do {    \
+    PyInterpreterLock_Release(ref);            \
     ref = 0;                                \
 } while (0)
 
 /* Weak interpreter references */
 
-typedef struct _PyInterpreterWeakRef {
+typedef struct _PyInterpreterView {
     int64_t id;
     Py_ssize_t refcount;
-} _PyInterpreterWeakRef;
+} _PyInterpreterView;
 
-typedef _PyInterpreterWeakRef *PyInterpreterWeakRef;
+typedef _PyInterpreterView *PyInterpreterView;
 
-PyAPI_FUNC(int) PyInterpreterWeakRef_FromCurrent(PyInterpreterWeakRef *ptr);
-PyAPI_FUNC(PyInterpreterWeakRef) PyInterpreterWeakRef_Dup(PyInterpreterWeakRef wref);
-PyAPI_FUNC(int) PyInterpreterWeakRef_Promote(PyInterpreterWeakRef wref, PyInterpreterRef *strong_ptr);
-PyAPI_FUNC(void) PyInterpreterWeakRef_Close(PyInterpreterWeakRef wref);
+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);
 
-#define PyInterpreterWeakRef_Close(ref) do {    \
-    PyInterpreterWeakRef_Close(ref);            \
+#define PyInterpreterView_Close(ref) do {    \
+    PyInterpreterView_Close(ref);            \
     ref = 0;                                    \
 } while (0)
 
 
 /* Thread references */
 
-typedef uintptr_t PyThreadRef;
+typedef uintptr_t PyThreadView;
 
-PyAPI_FUNC(int) PyThreadState_Ensure(PyInterpreterRef interp_ref, PyThreadRef *thread_ref);
+PyAPI_FUNC(int) PyThreadState_Ensure(PyInterpreterLock interp_ref, PyThreadView *thread_ref);
 
-PyAPI_FUNC(void) PyThreadState_Release(PyThreadRef thread_ref);
+PyAPI_FUNC(void) PyThreadState_Release(PyThreadView thread_ref);
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
@@ -2562,11 +2562,11 @@ toggle_reftrace_printer(PyObject *ob, PyObject *arg)
     Py_RETURN_NONE;
 }
 
-static PyInterpreterRef
+static PyInterpreterLock
 get_strong_ref(void)
 {
-    PyInterpreterRef ref;
-    if (PyInterpreterRef_FromCurrent(&ref) < 0) {
+    PyInterpreterLock ref;
+    if (PyInterpreterLock_FromCurrent(&ref) < 0) {
         Py_FatalError("strong reference should not have failed");
     }
     return ref;
@@ -2576,15 +2576,15 @@ static void
 test_interp_ref_common(void)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
-    PyInterpreterRef ref = get_strong_ref();
-    assert(PyInterpreterRef_GetInterpreter(ref) == interp);
+    PyInterpreterLock ref = get_strong_ref();
+    assert(PyInterpreterLock_GetInterpreter(ref) == interp);
 
-    PyInterpreterRef ref_2 = PyInterpreterRef_Dup(ref);
-    assert(PyInterpreterRef_GetInterpreter(ref_2) == interp);
+    PyInterpreterLock ref_2 = PyInterpreterLock_Copy(ref);
+    assert(PyInterpreterLock_GetInterpreter(ref_2) == interp);
 
     // We can close the references in any order
-    PyInterpreterRef_Close(ref);
-    PyInterpreterRef_Close(ref_2);
+    PyInterpreterLock_Release(ref);
+    PyInterpreterLock_Release(ref_2);
 }
 
 static PyObject *
@@ -2621,15 +2621,15 @@ test_interpreter_refs(PyObject *self, PyObject *unused)
 static PyObject *
 test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
 {
-    PyInterpreterRef ref = get_strong_ref();
+    PyInterpreterLock ref = get_strong_ref();
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     assert(PyGILState_GetThisThreadState() == save_tstate);
-    PyThreadRef refs[10];
+    PyThreadView refs[10];
 
     for (int i = 0; i < 10; ++i) {
         // Test reactivation of the detached tstate.
         if (PyThreadState_Ensure(ref, &refs[i]) < 0) {
-            PyInterpreterRef_Close(ref);
+            PyInterpreterLock_Release(ref);
             return PyErr_NoMemory();
         }
 
@@ -2647,7 +2647,7 @@ test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
         if (PyThreadState_Ensure(ref, &refs[i]) < 0) {
             // This will technically leak other thread states, but it doesn't
             // matter because this is a test.
-            PyInterpreterRef_Close(ref);
+            PyInterpreterLock_Release(ref);
             return PyErr_NoMemory();
         }
 
@@ -2660,19 +2660,19 @@ test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
     }
 
     assert(PyThreadState_GetUnchecked() == NULL);
-    PyInterpreterRef_Close(ref);
+    PyInterpreterLock_Release(ref);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
 }
 
 static PyObject *
 test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
 {
-    PyInterpreterRef ref = get_strong_ref();
+    PyInterpreterLock ref = get_strong_ref();
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     PyThreadState *interp_tstate = Py_NewInterpreter();
     if (interp_tstate == NULL) {
-        PyInterpreterRef_Close(ref);
+        PyInterpreterLock_Release(ref);
         return PyErr_NoMemory();
     }
 
@@ -2689,21 +2689,21 @@ test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
        interp = interpreters.create()
        interp.exec(some_func)
        */
-    PyThreadRef thread_ref;
-    PyThreadRef other_thread_ref;
+    PyThreadView thread_ref;
+    PyThreadView other_thread_ref;
     if (PyThreadState_Ensure(ref, &thread_ref) < 0) {
-        PyInterpreterRef_Close(ref);
+        PyInterpreterLock_Release(ref);
         return PyErr_NoMemory();
     }
 
     PyThreadState *ensured_tstate = PyThreadState_Get();
     assert(ensured_tstate != save_tstate);
-    assert(PyInterpreterState_Get() == PyInterpreterRef_GetInterpreter(ref));
+    assert(PyInterpreterState_Get() == PyInterpreterLock_GetInterpreter(ref));
     assert(PyGILState_GetThisThreadState() == ensured_tstate);
 
     // Now though, we should reactivate the thread state
     if (PyThreadState_Ensure(ref, &other_thread_ref) < 0) {
-        PyInterpreterRef_Close(ref);
+        PyInterpreterLock_Release(ref);
         return PyErr_NoMemory();
     }
 
@@ -2718,7 +2718,7 @@ test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
     PyThreadState_Swap(interp_tstate);
     Py_EndInterpreter(interp_tstate);
 
-    PyInterpreterRef_Close(ref);
+    PyInterpreterLock_Release(ref);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
 }
@@ -2727,26 +2727,26 @@ static PyObject *
 test_weak_interpreter_ref_after_shutdown(PyObject *self, PyObject *unused)
 {
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
-    PyInterpreterWeakRef wref;
+    PyInterpreterView wref;
     PyThreadState *interp_tstate = Py_NewInterpreter();
     if (interp_tstate == NULL) {
         return PyErr_NoMemory();
     }
 
-    int res = PyInterpreterWeakRef_FromCurrent(&wref);
+    int res = PyInterpreterView_FromCurrent(&wref);
     (void)res;
     assert(res == 0);
 
     // As a sanity check, ensure that the weakref actually works
-    PyInterpreterRef ref;
-    res = PyInterpreterWeakRef_Promote(wref, &ref);
+    PyInterpreterLock ref;
+    res = PyInterpreterLock_FromView(wref, &ref);
     assert(res == 0);
-    PyInterpreterRef_Close(ref);
+    PyInterpreterLock_Release(ref);
 
     // Now, destroy the interpreter and try to acquire a weak reference.
     // It should fail.
     Py_EndInterpreter(interp_tstate);
-    res = PyInterpreterWeakRef_Promote(wref, &ref);
+    res = PyInterpreterLock_FromView(wref, &ref);
     assert(res == -1);
 
     PyThreadState_Swap(save_tstate);
@@ -2756,9 +2756,9 @@ test_weak_interpreter_ref_after_shutdown(PyObject *self, PyObject *unused)
 static PyObject *
 foo(PyObject *self, PyObject *foo)
 {
-    PyInterpreterRef ref;
-    PyInterpreterRef_FromCurrent(&ref);
-    PyInterpreterRef_Close(ref);
+    PyInterpreterLock ref;
+    PyInterpreterLock_FromCurrent(&ref);
+    PyInterpreterLock_Release(ref);
     Py_RETURN_NONE;
 }
 
diff --git a/Modules/_testinternalcapi.c b/Modules/_testinternalcapi.c
@@ -2425,16 +2425,16 @@ test_interp_refcount(PyObject *self, PyObject *unused)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
     assert(_PyInterpreterState_Refcount(interp) == 0);
-    PyInterpreterRef refs[NUM_REFS];
+    PyInterpreterLock refs[NUM_REFS];
     for (int i = 0; i < NUM_REFS; ++i) {
-        int res = PyInterpreterRef_FromCurrent(&refs[i]);
+        int res = PyInterpreterLock_FromCurrent(&refs[i]);
         (void)res;
         assert(res == 0);
         assert(_PyInterpreterState_Refcount(interp) == i + 1);
     }
 
     for (int i = 0; i < NUM_REFS; ++i) {
-        PyInterpreterRef_Close(refs[i]);
+        PyInterpreterLock_Release(refs[i]);
         assert(_PyInterpreterState_Refcount(interp) == (NUM_REFS - i - 1));
     }
 
@@ -2445,28 +2445,28 @@ static PyObject *
 test_interp_weakref_incref(PyObject *self, PyObject *unused)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
-    PyInterpreterWeakRef wref;
-    if (PyInterpreterWeakRef_FromCurrent(&wref) < 0) {
+    PyInterpreterView wref;
+    if (PyInterpreterView_FromCurrent(&wref) < 0) {
         return NULL;
     }
     assert(_PyInterpreterState_Refcount(interp) == 0);
 
-    PyInterpreterRef refs[NUM_REFS];
+    PyInterpreterLock refs[NUM_REFS];
 
     for (int i = 0; i < NUM_REFS; ++i) {
-        int res = PyInterpreterWeakRef_Promote(wref, &refs[i]);
+        int res = PyInterpreterLock_FromView(wref, &refs[i]);
         (void)res;
         assert(res == 0);
-        assert(PyInterpreterRef_GetInterpreter(refs[i]) == interp);
+        assert(PyInterpreterLock_GetInterpreter(refs[i]) == interp);
         assert(_PyInterpreterState_Refcount(interp) == i + 1);
     }
 
     for (int i = 0; i < NUM_REFS; ++i) {
-        PyInterpreterRef_Close(refs[i]);
+        PyInterpreterLock_Release(refs[i]);
         assert(_PyInterpreterState_Refcount(interp) == (NUM_REFS - i - 1));
     }
 
-    PyInterpreterWeakRef_Close(wref);
+    PyInterpreterView_Close(wref);
     Py_RETURN_NONE;
 }
 
diff --git a/Programs/_testembed.c b/Programs/_testembed.c
@@ -2291,15 +2291,15 @@ const char *THREAD_CODE = \
     "fib(10)";
 
 typedef struct {
-    PyInterpreterRef ref;
+    PyInterpreterLock ref;
     int done;
 } ThreadData;
 
 static void
 do_tstate_ensure(void *arg)
 {
     ThreadData *data = (ThreadData *)arg;
-    PyThreadRef refs[4];
+    PyThreadView refs[4];
     int res = PyThreadState_Ensure(data->ref, &refs[0]);
     assert(res == 0);
     PyThreadState_Ensure(data->ref, &refs[1]);
@@ -2313,7 +2313,7 @@ do_tstate_ensure(void *arg)
     PyThreadState_Release(refs[1]);
     assert(res == 0);
     PyThreadState_Release(refs[0]);
-    PyInterpreterRef_Close(data->ref);
+    PyInterpreterLock_Release(data->ref);
     data->done = 1;
 }
 
@@ -2323,14 +2323,14 @@ test_thread_state_ensure(void)
     _testembed_initialize();
     PyThread_handle_t handle;
     PyThread_ident_t ident;
-    PyInterpreterRef ref;
-    if (PyInterpreterRef_FromCurrent(&ref) < 0) {
+    PyInterpreterLock ref;
+    if (PyInterpreterLock_FromCurrent(&ref) < 0) {
         return -1;
     };
     ThreadData data = { ref };
     if (PyThread_start_joinable_thread(do_tstate_ensure, &data,
                                        &ident, &handle) < 0) {
-        PyInterpreterRef_Close(ref);
+        PyInterpreterLock_Release(ref);
         return -1;
     }
     // We hold a strong interpreter reference, so we don't
@@ -2372,23 +2372,23 @@ static int
 test_main_interpreter_ref(void)
 {
     // It should not work before the runtime has started.
-    PyInterpreterRef ref;
-    int res = PyUnstable_GetDefaultInterpreterRef(&ref);
+    PyInterpreterLock ref;
+    int res = PyUnstable_InterpreterView_FromDefault(&ref);
     (void)res;
     assert(res == -1);
 
     _testembed_initialize();
 
     // Main interpreter is initialized and ready.
-    res = PyUnstable_GetDefaultInterpreterRef(&ref);
+    res = PyUnstable_InterpreterView_FromDefault(&ref);
     assert(res == 0);
-    assert(PyInterpreterRef_GetInterpreter(ref) == PyInterpreterState_Main());
-    PyInterpreterRef_Close(ref);
+    assert(PyInterpreterLock_GetInterpreter(ref) == PyInterpreterState_Main());
+    PyInterpreterLock_Release(ref);
 
     Py_Finalize();
 
     // Main interpreter is dead, we can no longer acquire references to it.
-    res = PyUnstable_GetDefaultInterpreterRef(&ref);
+    res = PyUnstable_InterpreterView_FromDefault(&ref);
     assert(res == -1);
     return 0;
 }
diff --git a/Python/pystate.c b/Python/pystate.c
