Remove PyThreadView.

Author: ZeroIntensity

Include/cpython/pystate.h

@@ -369,11 +369,9 @@ PyAPI_FUNC(PyInterpreterView) PyUnstable_InterpreterView_FromDefault(void);
 } while (0)
 #endif
 
-typedef uintptr_t PyThreadView;
+PyAPI_FUNC(PyThreadState *) PyThreadState_Ensure(PyInterpreterGuard guard);
 
-PyAPI_FUNC(PyThreadView) PyThreadState_Ensure(PyInterpreterGuard guard);
-
-PyAPI_FUNC(void) PyThreadState_Release(PyThreadView thread_ref);
+PyAPI_FUNC(void) PyThreadState_Release(PyThreadState *tstate);
 
 PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameAllowSpecialization(
     PyInterpreterState *interp,

Modules/_testcapimodule.c

@@ -2663,7 +2663,7 @@ test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
     }
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     assert(PyGILState_GetThisThreadState() == save_tstate);
-    PyThreadView thread_views[10];
+    PyThreadState * thread_views[10];
 
     for (int i = 0; i < 10; ++i) {
         // Test reactivation of the detached tstate.
@@ -2730,7 +2730,7 @@ test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
        interp = interpreters.create()
        interp.exec(some_func)
        */
-    PyThreadView thread_view = PyThreadState_Ensure(guard);
+    PyThreadState * thread_view = PyThreadState_Ensure(guard);
     if (thread_view == 0) {
         PyInterpreterGuard_Release(guard);
         return PyErr_NoMemory();
@@ -2742,7 +2742,7 @@ test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
     assert(PyGILState_GetThisThreadState() == ensured_tstate);
 
     // Now though, we should reactivate the thread state
-    PyThreadView other_thread_view = PyThreadState_Ensure(guard);
+    PyThreadState * other_thread_view = PyThreadState_Ensure(guard);
     if (other_thread_view == 0) {
         PyThreadState_Release(thread_view);
         PyInterpreterGuard_Release(guard);

Programs/_testembed.c

@@ -2690,7 +2690,7 @@ static void
 do_tstate_ensure(void *arg)
 {
     ThreadData *data = (ThreadData *)arg;
-    PyThreadView refs[4];
+    PyThreadState * refs[4];
     refs[0] = PyThreadState_Ensure(data->guard);
     refs[1] = PyThreadState_Ensure(data->guard);
     refs[2] = PyThreadState_Ensure(data->guard);

Python/pystate.c

@@ -3492,15 +3492,15 @@ PyUnstable_InterpreterView_FromDefault(void)
 // thread state was attached.
 static int NO_TSTATE_SENTINEL = 0;
 
-PyThreadView
+PyThreadState *
 PyThreadState_Ensure(PyInterpreterGuard guard)
 {
     PyInterpreterState *interp = guard_as_interp(guard);
     PyThreadState *attached_tstate = current_fast_get();
     if (attached_tstate != NULL && attached_tstate->interp == interp) {
         /* Yay! We already have an attached thread state that matches. */
         ++attached_tstate->ensure.counter;
-        return (PyThreadView)&NO_TSTATE_SENTINEL;
+        return (PyThreadState *)&NO_TSTATE_SENTINEL;
     }
 
     PyThreadState *detached_gilstate = gilstate_get();
@@ -3509,7 +3509,7 @@ PyThreadState_Ensure(PyInterpreterGuard guard)
         assert(attached_tstate == NULL);
         ++detached_gilstate->ensure.counter;
         _PyThreadState_Attach(detached_gilstate);
-        return (PyThreadView)&NO_TSTATE_SENTINEL;
+        return (PyThreadState *)&NO_TSTATE_SENTINEL;
     }
 
     PyThreadState *fresh_tstate = _PyThreadState_NewBound(interp,
@@ -3521,16 +3521,16 @@ PyThreadState_Ensure(PyInterpreterGuard guard)
     fresh_tstate->ensure.delete_on_release = 1;
 
     if (attached_tstate != NULL) {
-        return (PyThreadView)PyThreadState_Swap(fresh_tstate);
+        return (PyThreadState *)PyThreadState_Swap(fresh_tstate);
     } else {
         _PyThreadState_Attach(fresh_tstate);
     }
 
-    return (PyThreadView)&NO_TSTATE_SENTINEL;
+    return (PyThreadState *)&NO_TSTATE_SENTINEL;
 }
 
 void
-PyThreadState_Release(PyThreadView thread_view)
+PyThreadState_Release(PyThreadState * thread_view)
 {
     PyThreadState *tstate = current_fast_get();
     _Py_EnsureTstateNotNULL(tstate);
@@ -3540,7 +3540,7 @@ PyThreadState_Release(PyThreadView thread_view)
     }
     // The thread view might be NULL
     PyThreadState *to_restore;
-    if (thread_view == (PyThreadView)&NO_TSTATE_SENTINEL) {
+    if (thread_view == (PyThreadState *)&NO_TSTATE_SENTINEL) {
         to_restore = NULL;
     }
     else {