GH-91375: Port `_asyncio` static types to heap types and module state (#99122)

Co-authored-by: Erlend E. Aasland <erlend.aasland@protonmail.com>

2 files changed, 783 insertions, 435 deletions

diff --git a/Modules/_asynciomodule.c b/Modules/_asynciomodule.c
index 3edd8a9..cabcaec 100644
--- a/Modules/_asynciomodule.c
+++ b/Modules/_asynciomodule.c
@@ -3,11 +3,12 @@
 #endif
 
 #include "Python.h"
-#include "pycore_pyerrors.h"        // _PyErr_ClearExcState()
-#include "pycore_pystate.h"         // _PyThreadState_GET()
-#include "pycore_runtime.h"         // _PyRuntime
-#include "pycore_global_objects.h"  // _Py_ID()
-#include <stddef.h>                 // offsetof()
+#include "pycore_pyerrors.h"      // _PyErr_ClearExcState()
+#include "pycore_pystate.h"       // _PyThreadState_GET()
+#include "pycore_runtime_init.h"  // _Py_ID()
+#include "pycore_moduleobject.h"  // _PyModule_GetState()
+#include "structmember.h"         // PyMemberDef
+#include <stddef.h>               // offsetof()
 
 
 /*[clinic input]
@@ -17,35 +18,80 @@ module _asyncio
 
 
 /* State of the _asyncio module */
-static PyObject *asyncio_mod;
-static PyObject *traceback_extract_stack;
-static PyObject *asyncio_get_event_loop_policy;
-static PyObject *asyncio_future_repr_func;
-static PyObject *asyncio_iscoroutine_func;
-static PyObject *asyncio_task_get_stack_func;
-static PyObject *asyncio_task_print_stack_func;
-static PyObject *asyncio_task_repr_func;
-static PyObject *asyncio_InvalidStateError;
-static PyObject *asyncio_CancelledError;
-static PyObject *context_kwname;
-static int module_initialized;
+typedef struct {
+    PyTypeObject *FutureIterType;
+    PyTypeObject *TaskStepMethWrapper_Type;
+    PyTypeObject *FutureType;
+    PyTypeObject *TaskType;
+    PyTypeObject *PyRunningLoopHolder_Type;
+
+    PyObject *asyncio_mod;
+    PyObject *context_kwname;
+
+    /* Dictionary containing tasks that are currently active in
+       all running event loops.  {EventLoop: Task} */
+    PyObject *current_tasks;
+
+    /* WeakSet containing all alive tasks. */
+    PyObject *all_tasks;
+
+    /* An isinstance type cache for the 'is_coroutine()' function. */
+    PyObject *iscoroutine_typecache;
 
-static PyObject *cached_running_holder;
-static volatile uint64_t cached_running_holder_tsid;
+    /* Imports from asyncio.events. */
+    PyObject *asyncio_get_event_loop_policy;
 
-/* Counter for autogenerated Task names */
-static uint64_t task_name_counter = 0;
+    /* Imports from asyncio.base_futures. */
+    PyObject *asyncio_future_repr_func;
 
-/* WeakSet containing all alive tasks. */
-static PyObject *all_tasks;
+    /* Imports from asyncio.exceptions. */
+    PyObject *asyncio_CancelledError;
+    PyObject *asyncio_InvalidStateError;
 
-/* Dictionary containing tasks that are currently active in
-   all running event loops.  {EventLoop: Task} */
-static PyObject *current_tasks;
+    /* Imports from asyncio.base_tasks. */
+    PyObject *asyncio_task_get_stack_func;
+    PyObject *asyncio_task_print_stack_func;
+    PyObject *asyncio_task_repr_func;
 
-/* An isinstance type cache for the 'is_coroutine()' function. */
-static PyObject *iscoroutine_typecache;
+    /* Imports from asyncio.coroutines. */
+    PyObject *asyncio_iscoroutine_func;
 
+    /* Imports from traceback. */
+    PyObject *traceback_extract_stack;
+
+    PyObject *cached_running_holder;  // Borrowed ref.
+    volatile uint64_t cached_running_holder_tsid;
+
+    /* Counter for autogenerated Task names */
+    uint64_t task_name_counter;
+} asyncio_state;
+
+static inline asyncio_state *
+get_asyncio_state(PyObject *mod)
+{
+    asyncio_state *state = _PyModule_GetState(mod);
+    assert(state != NULL);
+    return state;
+}
+
+static inline asyncio_state *
+get_asyncio_state_by_cls(PyTypeObject *cls)
+{
+    asyncio_state *state = (asyncio_state *)PyType_GetModuleState(cls);
+    assert(state != NULL);
+    return state;
+}
+
+static struct PyModuleDef _asynciomodule;
+
+static inline asyncio_state *
+get_asyncio_state_by_def(PyObject *self)
+{
+    PyTypeObject *tp = Py_TYPE(self);
+    PyObject *mod = PyType_GetModuleByDef(tp, &_asynciomodule);
+    assert(mod != NULL);
+    return get_asyncio_state(mod);
+}
 
 typedef enum {
     STATE_PENDING,
@@ -101,16 +147,11 @@ typedef struct {
 } PyRunningLoopHolder;
 
 
-static PyTypeObject FutureType;
-static PyTypeObject TaskType;
-static PyTypeObject PyRunningLoopHolder_Type;
+#define Future_CheckExact(state, obj) Py_IS_TYPE(obj, state->FutureType)
+#define Task_CheckExact(state, obj) Py_IS_TYPE(obj, state->TaskType)
 
-
-#define Future_CheckExact(obj) Py_IS_TYPE(obj, &FutureType)
-#define Task_CheckExact(obj) Py_IS_TYPE(obj, &TaskType)
-
-#define Future_Check(obj) PyObject_TypeCheck(obj, &FutureType)
-#define Task_Check(obj) PyObject_TypeCheck(obj, &TaskType)
+#define Future_Check(state, obj) PyObject_TypeCheck(obj, state->FutureType)
+#define Task_Check(state, obj) PyObject_TypeCheck(obj, state->TaskType)
 
 #include "clinic/_asynciomodule.c.h"
 
@@ -124,11 +165,11 @@ class _asyncio.Future "FutureObj *" "&Future_Type"
 /* Get FutureIter from Future */
 static PyObject * future_new_iter(PyObject *);
 
-static PyRunningLoopHolder * new_running_loop_holder(PyObject *);
+static PyRunningLoopHolder * new_running_loop_holder(asyncio_state *, PyObject *);
 
 
 static int
-_is_coroutine(PyObject *coro)
+_is_coroutine(asyncio_state *state, PyObject *coro)
 {
     /* 'coro' is not a native coroutine, call asyncio.iscoroutine()
        to check if it's another coroutine flavour.
@@ -136,7 +177,7 @@ _is_coroutine(PyObject *coro)
        Do this check after 'future_init()'; in case we need to raise
        an error, __del__ needs a properly initialized object.
     */
-    PyObject *res = PyObject_CallOneArg(asyncio_iscoroutine_func, coro);
+    PyObject *res = PyObject_CallOneArg(state->asyncio_iscoroutine_func, coro);
     if (res == NULL) {
         return -1;
     }
@@ -147,12 +188,12 @@ _is_coroutine(PyObject *coro)
         return is_res_true;
     }
 
-    if (PySet_GET_SIZE(iscoroutine_typecache) < 100) {
+    if (PySet_GET_SIZE(state->iscoroutine_typecache) < 100) {
         /* Just in case we don't want to cache more than 100
            positive types.  That shouldn't ever happen, unless
            someone stressing the system on purpose.
         */
-        if (PySet_Add(iscoroutine_typecache, (PyObject*) Py_TYPE(coro))) {
+        if (PySet_Add(state->iscoroutine_typecache, (PyObject*) Py_TYPE(coro))) {
             return -1;
         }
     }
@@ -162,7 +203,7 @@ _is_coroutine(PyObject *coro)
 
 
 static inline int
-is_coroutine(PyObject *coro)
+is_coroutine(asyncio_state *state, PyObject *coro)
 {
     if (PyCoro_CheckExact(coro)) {
         return 1;
@@ -178,10 +219,10 @@ is_coroutine(PyObject *coro)
        a pure-Python function in 99.9% cases.
     */
     int has_it = PySet_Contains(
-        iscoroutine_typecache, (PyObject*) Py_TYPE(coro));
+        state->iscoroutine_typecache, (PyObject*) Py_TYPE(coro));
     if (has_it == 0) {
         /* type(coro) is not in iscoroutine_typecache */
-        return _is_coroutine(coro);
+        return _is_coroutine(state, coro);
     }
 
     /* either an error has occurred or
@@ -192,13 +233,13 @@ is_coroutine(PyObject *coro)
 
 
 static PyObject *
-get_future_loop(PyObject *fut)
+get_future_loop(asyncio_state *state, PyObject *fut)
 {
     /* Implementation of `asyncio.futures._get_loop` */
 
     PyObject *getloop;
 
-    if (Future_CheckExact(fut) || Task_CheckExact(fut)) {
+    if (Future_CheckExact(state, fut) || Task_CheckExact(state, fut)) {
         PyObject *loop = ((FutureObj *)fut)->fut_loop;
         return Py_NewRef(loop);
     }
@@ -217,15 +258,17 @@ get_future_loop(PyObject *fut)
 
 
 static int
-get_running_loop(PyObject **loop)
+get_running_loop(asyncio_state *state, PyObject **loop)
 {
     PyObject *rl;
 
     PyThreadState *ts = _PyThreadState_GET();
     uint64_t ts_id = PyThreadState_GetID(ts);
-    if (ts_id == cached_running_holder_tsid && cached_running_holder != NULL) {
+    if (state->cached_running_holder_tsid == ts_id &&
+        state->cached_running_holder != NULL)
+    {
         // Fast path, check the cache.
-        rl = cached_running_holder;  // borrowed
+        rl = state->cached_running_holder;  // borrowed
     }
     else {
         PyObject *ts_dict = _PyThreadState_GetDict(ts);  // borrowed
@@ -244,11 +287,11 @@ get_running_loop(PyObject **loop)
             }
         }
 
-        cached_running_holder = rl;  // borrowed
-        cached_running_holder_tsid = ts_id;
+        state->cached_running_holder = rl;  // borrowed
+        state->cached_running_holder_tsid = ts_id;
     }
 
-    assert(Py_IS_TYPE(rl, &PyRunningLoopHolder_Type));
+    assert(Py_IS_TYPE(rl, state->PyRunningLoopHolder_Type));
     PyObject *running_loop = ((PyRunningLoopHolder *)rl)->rl_loop;
 
     if (running_loop == Py_None) {
@@ -278,7 +321,7 @@ error:
 
 
 static int
-set_running_loop(PyObject *loop)
+set_running_loop(asyncio_state *state, PyObject *loop)
 {
     PyObject *ts_dict = NULL;
 
@@ -293,7 +336,7 @@ set_running_loop(PyObject *loop)
         return -1;
     }
 
-    PyRunningLoopHolder *rl = new_running_loop_holder(loop);
+    PyRunningLoopHolder *rl = new_running_loop_holder(state, loop);
     if (rl == NULL) {
         return -1;
     }
@@ -306,20 +349,20 @@ set_running_loop(PyObject *loop)
     }
     Py_DECREF(rl);
 
-    cached_running_holder = (PyObject *)rl;
-    cached_running_holder_tsid = PyThreadState_GetID(tstate);
+    state->cached_running_holder = (PyObject *)rl;
+    state->cached_running_holder_tsid = PyThreadState_GetID(tstate);
 
     return 0;
 }
 
 
 static PyObject *
-get_event_loop(int stacklevel)
+get_event_loop(asyncio_state *state, int stacklevel)
 {
     PyObject *loop;
     PyObject *policy;
 
-    if (get_running_loop(&loop)) {
+    if (get_running_loop(state, &loop)) {
         return NULL;
     }
     if (loop != NULL) {
@@ -333,7 +376,7 @@ get_event_loop(int stacklevel)
         return NULL;
     }
 
-    policy = PyObject_CallNoArgs(asyncio_get_event_loop_policy);
+    policy = PyObject_CallNoArgs(state->asyncio_get_event_loop_policy);
     if (policy == NULL) {
         return NULL;
     }
@@ -345,7 +388,8 @@ get_event_loop(int stacklevel)
 
 
 static int
-call_soon(PyObject *loop, PyObject *func, PyObject *arg, PyObject *ctx)
+call_soon(asyncio_state *state, PyObject *loop, PyObject *func, PyObject *arg,
+          PyObject *ctx)
 {
     PyObject *handle;
     PyObject *stack[3];
@@ -372,7 +416,8 @@ call_soon(PyObject *loop, PyObject *func, PyObject *arg, PyObject *ctx)
         }
         stack[nargs] = (PyObject *)ctx;
         EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, callable);
-        handle = PyObject_Vectorcall(callable, stack, nargs, context_kwname);
+        handle = PyObject_Vectorcall(callable, stack, nargs,
+                                     state->context_kwname);
         Py_DECREF(callable);
     }
 
@@ -403,17 +448,18 @@ future_ensure_alive(FutureObj *fut)
 }
 
 
-#define ENSURE_FUTURE_ALIVE(fut)                                \
-    do {                                                        \
-        assert(Future_Check(fut) || Task_Check(fut));           \
-        if (future_ensure_alive((FutureObj*)fut)) {             \
-            return NULL;                                        \
-        }                                                       \
+#define ENSURE_FUTURE_ALIVE(state, fut)                             \
+    do {                                                            \
+        assert(Future_Check(state, fut) || Task_Check(state, fut)); \
+        (void)state;                                                \
+        if (future_ensure_alive((FutureObj*)fut)) {                 \
+            return NULL;                                            \
+        }                                                           \
     } while(0);
 
 
 static int
-future_schedule_callbacks(FutureObj *fut)
+future_schedule_callbacks(asyncio_state *state, FutureObj *fut)
 {
     Py_ssize_t len;
     Py_ssize_t i;
@@ -421,7 +467,7 @@ future_schedule_callbacks(FutureObj *fut)
     if (fut->fut_callback0 != NULL) {
         /* There's a 1st callback */
 
-        int ret = call_soon(
+        int ret = call_soon(state,
             fut->fut_loop, fut->fut_callback0,
             (PyObject *)fut, fut->fut_context0);
 
@@ -455,7 +501,7 @@ future_schedule_callbacks(FutureObj *fut)
         PyObject *cb = PyTuple_GET_ITEM(cb_tup, 0);
         PyObject *ctx = PyTuple_GET_ITEM(cb_tup, 1);
 
-        if (call_soon(fut->fut_loop, cb, (PyObject *)fut, ctx)) {
+        if (call_soon(state, fut->fut_loop, cb, (PyObject *)fut, ctx)) {
             /* If an error occurs in pure-Python implementation,
                all callbacks are cleared. */
             Py_CLEAR(fut->fut_callbacks);
@@ -491,7 +537,8 @@ future_init(FutureObj *fut, PyObject *loop)
     fut->fut_blocking = 0;
 
     if (loop == Py_None) {
-        loop = get_event_loop(1);
+        asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
+        loop = get_event_loop(state, 1);
         if (loop == NULL) {
             return -1;
         }
@@ -517,7 +564,8 @@ future_init(FutureObj *fut, PyObject *loop)
            method, which is called during the interpreter shutdown and the
            traceback module is already unloaded.
         */
-        fut->fut_source_tb = PyObject_CallNoArgs(traceback_extract_stack);
+        asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
+        fut->fut_source_tb = PyObject_CallNoArgs(state->traceback_extract_stack);
         if (fut->fut_source_tb == NULL) {
             return -1;
         }
@@ -527,14 +575,14 @@ future_init(FutureObj *fut, PyObject *loop)
 }
 
 static PyObject *
-future_set_result(FutureObj *fut, PyObject *res)
+future_set_result(asyncio_state *state, FutureObj *fut, PyObject *res)
 {
     if (future_ensure_alive(fut)) {
         return NULL;
     }
 
     if (fut->fut_state != STATE_PENDING) {
-        PyErr_SetString(asyncio_InvalidStateError, "invalid state");
+        PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");
         return NULL;
     }
 
@@ -542,19 +590,19 @@ future_set_result(FutureObj *fut, PyObject *res)
     fut->fut_result = Py_NewRef(res);
     fut->fut_state = STATE_FINISHED;
 
-    if (future_schedule_callbacks(fut) == -1) {
+    if (future_schedule_callbacks(state, fut) == -1) {
         return NULL;
     }
     Py_RETURN_NONE;
 }
 
 static PyObject *
-future_set_exception(FutureObj *fut, PyObject *exc)
+future_set_exception(asyncio_state *state, FutureObj *fut, PyObject *exc)
 {
     PyObject *exc_val = NULL;
 
     if (fut->fut_state != STATE_PENDING) {
-        PyErr_SetString(asyncio_InvalidStateError, "invalid state");
+        PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");
         return NULL;
     }
 
@@ -565,7 +613,7 @@ future_set_exception(FutureObj *fut, PyObject *exc)
         }
         if (fut->fut_state != STATE_PENDING) {
             Py_DECREF(exc_val);
-            PyErr_SetString(asyncio_InvalidStateError, "invalid state");
+            PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");
             return NULL;
         }
     }
@@ -591,7 +639,7 @@ future_set_exception(FutureObj *fut, PyObject *exc)
     fut->fut_exception_tb = PyException_GetTraceback(exc_val);
     fut->fut_state = STATE_FINISHED;
 
-    if (future_schedule_callbacks(fut) == -1) {
+    if (future_schedule_callbacks(state, fut) == -1) {
         return NULL;
     }
 
@@ -600,7 +648,7 @@ future_set_exception(FutureObj *fut, PyObject *exc)
 }
 
 static PyObject *
-create_cancelled_error(FutureObj *fut)
+create_cancelled_error(asyncio_state *state, FutureObj *fut)
 {
     PyObject *exc;
     if (fut->fut_cancelled_exc != NULL) {
@@ -611,34 +659,35 @@ create_cancelled_error(FutureObj *fut)
     }
     PyObject *msg = fut->fut_cancel_msg;
     if (msg == NULL || msg == Py_None) {
-        exc = PyObject_CallNoArgs(asyncio_CancelledError);
+        exc = PyObject_CallNoArgs(state->asyncio_CancelledError);
     } else {
-        exc = PyObject_CallOneArg(asyncio_CancelledError, msg);
+        exc = PyObject_CallOneArg(state->asyncio_CancelledError, msg);
     }
     return exc;
 }
 
 static void
-future_set_cancelled_error(FutureObj *fut)
+future_set_cancelled_error(asyncio_state *state, FutureObj *fut)
 {
-    PyObject *exc = create_cancelled_error(fut);
+    PyObject *exc = create_cancelled_error(state, fut);
     if (exc == NULL) {
         return;
     }
-    PyErr_SetObject(asyncio_CancelledError, exc);
+    PyErr_SetObject(state->asyncio_CancelledError, exc);
     Py_DECREF(exc);
 }
 
 static int
-future_get_result(FutureObj *fut, PyObject **result)
+future_get_result(asyncio_state *state, FutureObj *fut, PyObject **result)
 {
     if (fut->fut_state == STATE_CANCELLED) {
-        future_set_cancelled_error(fut);
+        future_set_cancelled_error(state, fut);
         return -1;
     }
 
     if (fut->fut_state != STATE_FINISHED) {
-        PyErr_SetString(asyncio_InvalidStateError, "Result is not set.");
+        PyErr_SetString(state->asyncio_InvalidStateError,
+                        "Result is not set.");
         return -1;
     }
 
@@ -661,7 +710,8 @@ future_get_result(FutureObj *fut, PyObject **result)
 }
 
 static PyObject *
-future_add_done_callback(FutureObj *fut, PyObject *arg, PyObject *ctx)
+future_add_done_callback(asyncio_state *state, FutureObj *fut, PyObject *arg,
+                         PyObject *ctx)
 {
     if (!future_is_alive(fut)) {
         PyErr_SetString(PyExc_RuntimeError, "uninitialized Future object");
@@ -671,7 +721,7 @@ future_add_done_callback(FutureObj *fut, PyObject *arg, PyObject *ctx)
     if (fut->fut_state != STATE_PENDING) {
         /* The future is done/cancelled, so schedule the callback
            right away. */
-        if (call_soon(fut->fut_loop, arg, (PyObject*) fut, ctx)) {
+        if (call_soon(state, fut->fut_loop, arg, (PyObject*) fut, ctx)) {
             return NULL;
         }
     }
@@ -735,7 +785,7 @@ future_add_done_callback(FutureObj *fut, PyObject *arg, PyObject *ctx)
 }
 
 static PyObject *
-future_cancel(FutureObj *fut, PyObject *msg)
+future_cancel(asyncio_state *state, FutureObj *fut, PyObject *msg)
 {
     fut->fut_log_tb = 0;
 
@@ -747,7 +797,7 @@ future_cancel(FutureObj *fut, PyObject *msg)
     Py_XINCREF(msg);
     Py_XSETREF(fut->fut_cancel_msg, msg);
 
-    if (future_schedule_callbacks(fut) == -1) {
+    if (future_schedule_callbacks(state, fut) == -1) {
         return NULL;
     }
 
@@ -802,6 +852,7 @@ FutureObj_clear(FutureObj *fut)
 static int
 FutureObj_traverse(FutureObj *fut, visitproc visit, void *arg)
 {
+    Py_VISIT(Py_TYPE(fut));
     Py_VISIT(fut->fut_loop);
     Py_VISIT(fut->fut_callback0);
     Py_VISIT(fut->fut_context0);
@@ -830,15 +881,16 @@ static PyObject *
 _asyncio_Future_result_impl(FutureObj *self)
 /*[clinic end generated code: output=f35f940936a4b1e5 input=49ecf9cf5ec50dc5]*/
 {
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)self);
     PyObject *result;
 
     if (!future_is_alive(self)) {
-        PyErr_SetString(asyncio_InvalidStateError,
+        PyErr_SetString(state->asyncio_InvalidStateError,
                         "Future object is not initialized.");
         return NULL;
     }
 
-    int res = future_get_result(self, &result);
+    int res = future_get_result(state, self, &result);
 
     if (res == -1) {
         return NULL;
@@ -858,6 +910,9 @@ _asyncio_Future_result_impl(FutureObj *self)
 /*[clinic input]
 _asyncio.Future.exception
 
+    cls: defining_class
+    /
+
 Return the exception that was set on this future.
 
 The exception (or None if no exception was set) is returned only if
@@ -867,22 +922,26 @@ InvalidStateError.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Future_exception_impl(FutureObj *self)
-/*[clinic end generated code: output=88b20d4f855e0710 input=733547a70c841c68]*/
+_asyncio_Future_exception_impl(FutureObj *self, PyTypeObject *cls)
+/*[clinic end generated code: output=ce75576b187c905b input=3faf15c22acdb60d]*/
 {
     if (!future_is_alive(self)) {
-        PyErr_SetString(asyncio_InvalidStateError,
+        asyncio_state *state = get_asyncio_state_by_cls(cls);
+        PyErr_SetString(state->asyncio_InvalidStateError,
                         "Future object is not initialized.");
         return NULL;
     }
 
     if (self->fut_state == STATE_CANCELLED) {
-        future_set_cancelled_error(self);
+        asyncio_state *state = get_asyncio_state_by_cls(cls);
+        future_set_cancelled_error(state, self);
         return NULL;
     }
 
     if (self->fut_state != STATE_FINISHED) {
-        PyErr_SetString(asyncio_InvalidStateError, "Exception is not set.");
+        asyncio_state *state = get_asyncio_state_by_cls(cls);
+        PyErr_SetString(state->asyncio_InvalidStateError,
+                        "Exception is not set.");
         return NULL;
     }
 
@@ -897,6 +956,7 @@ _asyncio_Future_exception_impl(FutureObj *self)
 /*[clinic input]
 _asyncio.Future.set_result
 
+    cls: defining_class
     result: object
     /
 
@@ -907,16 +967,19 @@ InvalidStateError.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Future_set_result(FutureObj *self, PyObject *result)
-/*[clinic end generated code: output=1ec2e6bcccd6f2ce input=8b75172c2a7b05f1]*/
+_asyncio_Future_set_result_impl(FutureObj *self, PyTypeObject *cls,
+                                PyObject *result)
+/*[clinic end generated code: output=99afbbe78f99c32d input=d5a41c1e353acc2e]*/
 {
-    ENSURE_FUTURE_ALIVE(self)
-    return future_set_result(self, result);
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
+    ENSURE_FUTURE_ALIVE(state, self)
+    return future_set_result(state, self, result);
 }
 
 /*[clinic input]
 _asyncio.Future.set_exception
 
+    cls: defining_class
     exception: object
     /
 
@@ -927,16 +990,19 @@ InvalidStateError.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Future_set_exception(FutureObj *self, PyObject *exception)
-/*[clinic end generated code: output=f1c1b0cd321be360 input=e45b7d7aa71cc66d]*/
+_asyncio_Future_set_exception_impl(FutureObj *self, PyTypeObject *cls,
+                                   PyObject *exception)
+/*[clinic end generated code: output=0a5e8b5a52f058d6 input=a245cd49d3df939b]*/
 {
-    ENSURE_FUTURE_ALIVE(self)
-    return future_set_exception(self, exception);
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
+    ENSURE_FUTURE_ALIVE(state, self)
+    return future_set_exception(state, self, exception);
 }
 
 /*[clinic input]
 _asyncio.Future.add_done_callback
 
+    cls: defining_class
     fn: object
     /
     *
@@ -950,25 +1016,27 @@ scheduled with call_soon.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Future_add_done_callback_impl(FutureObj *self, PyObject *fn,
-                                       PyObject *context)
-/*[clinic end generated code: output=7ce635bbc9554c1e input=15ab0693a96e9533]*/
+_asyncio_Future_add_done_callback_impl(FutureObj *self, PyTypeObject *cls,
+                                       PyObject *fn, PyObject *context)
+/*[clinic end generated code: output=922e9a4cbd601167 input=599261c521458cc2]*/
 {
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
     if (context == NULL) {
         context = PyContext_CopyCurrent();
         if (context == NULL) {
             return NULL;
         }
-        PyObject *res = future_add_done_callback(self, fn, context);
+        PyObject *res = future_add_done_callback(state, self, fn, context);
         Py_DECREF(context);
         return res;
     }
-    return future_add_done_callback(self, fn, context);
+    return future_add_done_callback(state, self, fn, context);
 }
 
 /*[clinic input]
 _asyncio.Future.remove_done_callback
 
+    cls: defining_class
     fn: object
     /
 
@@ -978,14 +1046,16 @@ Returns the number of callbacks removed.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Future_remove_done_callback(FutureObj *self, PyObject *fn)
-/*[clinic end generated code: output=5ab1fb52b24ef31f input=0a43280a149d505b]*/
+_asyncio_Future_remove_done_callback_impl(FutureObj *self, PyTypeObject *cls,
+                                          PyObject *fn)
+/*[clinic end generated code: output=2da35ccabfe41b98 input=c7518709b86fc747]*/
 {
     PyObject *newlist;
     Py_ssize_t len, i, j=0;
     Py_ssize_t cleared_callback0 = 0;
 
-    ENSURE_FUTURE_ALIVE(self)
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
+    ENSURE_FUTURE_ALIVE(state, self)
 
     if (self->fut_callback0 != NULL) {
         int cmp = PyObject_RichCompareBool(self->fut_callback0, fn, Py_EQ);
@@ -1082,6 +1152,8 @@ fail:
 /*[clinic input]
 _asyncio.Future.cancel
 
+    cls: defining_class
+    /
     msg: object = None
 
 Cancel the future and schedule callbacks.
@@ -1092,11 +1164,13 @@ return True.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Future_cancel_impl(FutureObj *self, PyObject *msg)
-/*[clinic end generated code: output=3edebbc668e5aba3 input=925eb545251f2c5a]*/
+_asyncio_Future_cancel_impl(FutureObj *self, PyTypeObject *cls,
+                            PyObject *msg)
+/*[clinic end generated code: output=074956f35904b034 input=bba8f8b786941a94]*/
 {
-    ENSURE_FUTURE_ALIVE(self)
-    return future_cancel(self, msg);
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
+    ENSURE_FUTURE_ALIVE(state, self)
+    return future_cancel(state, self, msg);
 }
 
 /*[clinic input]
@@ -1141,14 +1215,18 @@ _asyncio_Future_done_impl(FutureObj *self)
 /*[clinic input]
 _asyncio.Future.get_loop
 
+    cls: defining_class
+    /
+
 Return the event loop the Future is bound to.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Future_get_loop_impl(FutureObj *self)
-/*[clinic end generated code: output=119b6ea0c9816c3f input=cba48c2136c79d1f]*/
+_asyncio_Future_get_loop_impl(FutureObj *self, PyTypeObject *cls)
+/*[clinic end generated code: output=f50ea6c374d9ee97 input=163c2c498b45a1f0]*/
 {
-    ENSURE_FUTURE_ALIVE(self)
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
+    ENSURE_FUTURE_ALIVE(state, self)
     return Py_NewRef(self->fut_loop);
 }
 
@@ -1185,7 +1263,8 @@ FutureObj_set_blocking(FutureObj *fut, PyObject *val, void *Py_UNUSED(ignored))
 static PyObject *
 FutureObj_get_log_traceback(FutureObj *fut, void *Py_UNUSED(ignored))
 {
-    ENSURE_FUTURE_ALIVE(fut)
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
+    ENSURE_FUTURE_ALIVE(state, fut)
     if (fut->fut_log_tb) {
         Py_RETURN_TRUE;
     }
@@ -1226,9 +1305,10 @@ FutureObj_get_loop(FutureObj *fut, void *Py_UNUSED(ignored))
 static PyObject *
 FutureObj_get_callbacks(FutureObj *fut, void *Py_UNUSED(ignored))
 {
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
     Py_ssize_t i;
 
-    ENSURE_FUTURE_ALIVE(fut)
+    ENSURE_FUTURE_ALIVE(state, fut)
 
     if (fut->fut_callback0 == NULL) {
         if (fut->fut_callbacks == NULL) {
@@ -1277,7 +1357,8 @@ FutureObj_get_callbacks(FutureObj *fut, void *Py_UNUSED(ignored))
 static PyObject *
 FutureObj_get_result(FutureObj *fut, void *Py_UNUSED(ignored))
 {
-    ENSURE_FUTURE_ALIVE(fut)
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
+    ENSURE_FUTURE_ALIVE(state, fut)
     if (fut->fut_result == NULL) {
         Py_RETURN_NONE;
     }
@@ -1287,7 +1368,8 @@ FutureObj_get_result(FutureObj *fut, void *Py_UNUSED(ignored))
 static PyObject *
 FutureObj_get_exception(FutureObj *fut, void *Py_UNUSED(ignored))
 {
-    ENSURE_FUTURE_ALIVE(fut)
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
+    ENSURE_FUTURE_ALIVE(state, fut)
     if (fut->fut_exception == NULL) {
         Py_RETURN_NONE;
     }
@@ -1328,9 +1410,10 @@ FutureObj_set_cancel_message(FutureObj *fut, PyObject *msg,
 static PyObject *
 FutureObj_get_state(FutureObj *fut, void *Py_UNUSED(ignored))
 {
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
     PyObject *ret = NULL;
 
-    ENSURE_FUTURE_ALIVE(fut)
+    ENSURE_FUTURE_ALIVE(state, fut)
 
     switch (fut->fut_state) {
     case STATE_PENDING:
@@ -1351,8 +1434,9 @@ FutureObj_get_state(FutureObj *fut, void *Py_UNUSED(ignored))
 static PyObject *
 FutureObj_repr(FutureObj *fut)
 {
-    ENSURE_FUTURE_ALIVE(fut)
-    return PyObject_CallOneArg(asyncio_future_repr_func, (PyObject *)fut);
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
+    ENSURE_FUTURE_ALIVE(state, fut)
+    return PyObject_CallOneArg(state->asyncio_future_repr_func, (PyObject *)fut);
 }
 
 /*[clinic input]
@@ -1368,7 +1452,8 @@ static PyObject *
 _asyncio_Future__make_cancelled_error_impl(FutureObj *self)
 /*[clinic end generated code: output=a5df276f6c1213de input=ac6effe4ba795ecc]*/
 {
-    return create_cancelled_error(self);
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)self);
+    return create_cancelled_error(state, self);
 }
 
 static void
@@ -1431,13 +1516,6 @@ finally:
     PyErr_Restore(error_type, error_value, error_traceback);
 }
 
-static PyAsyncMethods FutureType_as_async = {
-    (unaryfunc)future_new_iter,         /* am_await */
-    0,                                  /* am_aiter */
-    0,                                  /* am_anext */
-    0,                                  /* am_send  */
-};
-
 static PyMethodDef FutureType_methods[] = {
     _ASYNCIO_FUTURE_RESULT_METHODDEF
     _ASYNCIO_FUTURE_EXCEPTION_METHODDEF
@@ -1454,6 +1532,12 @@ static PyMethodDef FutureType_methods[] = {
     {NULL, NULL}        /* Sentinel */
 };
 
+static PyMemberDef FutureType_members[] = {
+    {"__weaklistoffset__", T_PYSSIZET, offsetof(FutureObj, fut_weakreflist), READONLY},
+    {"__dictoffset__", T_PYSSIZET, offsetof(FutureObj, dict), READONLY},
+    {NULL},
+};
+
 #define FUTURE_COMMON_GETSETLIST                                              \
     {"_state", (getter)FutureObj_get_state, NULL, NULL},                      \
     {"_asyncio_future_blocking", (getter)FutureObj_get_blocking,              \
@@ -1476,25 +1560,31 @@ static PyGetSetDef FutureType_getsetlist[] = {
 
 static void FutureObj_dealloc(PyObject *self);
 
-static PyTypeObject FutureType = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_asyncio.Future",
-    sizeof(FutureObj),                       /* tp_basicsize */
-    .tp_dealloc = FutureObj_dealloc,
-    .tp_as_async = &FutureType_as_async,
-    .tp_repr = (reprfunc)FutureObj_repr,
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
-    .tp_doc = _asyncio_Future___init____doc__,
-    .tp_traverse = (traverseproc)FutureObj_traverse,
-    .tp_clear = (inquiry)FutureObj_clear,
-    .tp_weaklistoffset = offsetof(FutureObj, fut_weakreflist),
-    .tp_iter = (getiterfunc)future_new_iter,
-    .tp_methods = FutureType_methods,
-    .tp_getset = FutureType_getsetlist,
-    .tp_dictoffset = offsetof(FutureObj, dict),
-    .tp_init = (initproc)_asyncio_Future___init__,
-    .tp_new = PyType_GenericNew,
-    .tp_finalize = (destructor)FutureObj_finalize,
+static PyType_Slot Future_slots[] = {
+    {Py_tp_dealloc, FutureObj_dealloc},
+    {Py_tp_repr, (reprfunc)FutureObj_repr},
+    {Py_tp_doc, (void *)_asyncio_Future___init____doc__},
+    {Py_tp_traverse, (traverseproc)FutureObj_traverse},
+    {Py_tp_clear, (inquiry)FutureObj_clear},
+    {Py_tp_iter, (getiterfunc)future_new_iter},
+    {Py_tp_methods, FutureType_methods},
+    {Py_tp_members, FutureType_members},
+    {Py_tp_getset, FutureType_getsetlist},
+    {Py_tp_init, (initproc)_asyncio_Future___init__},
+    {Py_tp_new, PyType_GenericNew},
+    {Py_tp_finalize, (destructor)FutureObj_finalize},
+
+    // async slots
+    {Py_am_await, (unaryfunc)future_new_iter},
+    {0, NULL},
+};
+
+static PyType_Spec Future_spec = {
+    .name = "_asyncio.Future",
+    .basicsize = sizeof(FutureObj),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |
+              Py_TPFLAGS_IMMUTABLETYPE),
+    .slots = Future_slots,
 };
 
 static void
@@ -1502,16 +1592,12 @@ FutureObj_dealloc(PyObject *self)
 {
     FutureObj *fut = (FutureObj *)self;
 
-    if (Future_CheckExact(fut)) {
-        /* When fut is subclass of Future, finalizer is called from
-         * subtype_dealloc.
-         */
-        if (PyObject_CallFinalizerFromDealloc(self) < 0) {
-            // resurrected.
-            return;
-        }
+    if (PyObject_CallFinalizerFromDealloc(self) < 0) {
+        // resurrected.
+        return;
     }
 
+    PyTypeObject *tp = Py_TYPE(fut);
     PyObject_GC_UnTrack(self);
 
     if (fut->fut_weakreflist != NULL) {
@@ -1519,7 +1605,8 @@ FutureObj_dealloc(PyObject *self)
     }
 
     (void)FutureObj_clear(fut);
-    Py_TYPE(fut)->tp_free(fut);
+    tp->tp_free(fut);
+    Py_DECREF(tp);
 }
 
 
@@ -1539,8 +1626,9 @@ static Py_ssize_t fi_freelist_len = 0;
 static void
 FutureIter_dealloc(futureiterobject *it)
 {
+    PyTypeObject *tp = Py_TYPE(it);
     PyObject_GC_UnTrack(it);
-    Py_CLEAR(it->future);
+    tp->tp_clear((PyObject *)it);
 
     if (fi_freelist_len < FI_FREELIST_MAXLEN) {
         fi_freelist_len++;
@@ -1549,6 +1637,7 @@ FutureIter_dealloc(futureiterobject *it)
     }
     else {
         PyObject_GC_Del(it);
+        Py_DECREF(tp);
     }
 }
 
@@ -1686,16 +1775,24 @@ FutureIter_throw(futureiterobject *self, PyObject *const *args, Py_ssize_t nargs
     return NULL;
 }
 
+static int
+FutureIter_clear(futureiterobject *it)
+{
+    Py_CLEAR(it->future);
+    return 0;
+}
+
 static PyObject *
 FutureIter_close(futureiterobject *self, PyObject *arg)
 {
-    Py_CLEAR(self->future);
+    (void)FutureIter_clear(self);
     Py_RETURN_NONE;
 }
 
 static int
 FutureIter_traverse(futureiterobject *it, visitproc visit, void *arg)
 {
+    Py_VISIT(Py_TYPE(it));
     Py_VISIT(it->future);
     return 0;
 }
@@ -1707,27 +1804,26 @@ static PyMethodDef FutureIter_methods[] = {
     {NULL, NULL}        /* Sentinel */
 };
 
-static PyAsyncMethods FutureIterType_as_async = {
-    0,                                  /* am_await */
-    0,                                  /* am_aiter */
-    0,                                  /* am_anext */
-    (sendfunc)FutureIter_am_send,       /* am_send  */
+static PyType_Slot FutureIter_slots[] = {
+    {Py_tp_dealloc, (destructor)FutureIter_dealloc},
+    {Py_tp_getattro, PyObject_GenericGetAttr},
+    {Py_tp_traverse, (traverseproc)FutureIter_traverse},
+    {Py_tp_clear, FutureIter_clear},
+    {Py_tp_iter, PyObject_SelfIter},
+    {Py_tp_iternext, (iternextfunc)FutureIter_iternext},
+    {Py_tp_methods, FutureIter_methods},
+
+    // async methods
+    {Py_am_send, (sendfunc)FutureIter_am_send},
+    {0, NULL},
 };
 
-
-static PyTypeObject FutureIterType = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_asyncio.FutureIter",
-    .tp_basicsize = sizeof(futureiterobject),
-    .tp_itemsize = 0,
-    .tp_dealloc = (destructor)FutureIter_dealloc,
-    .tp_as_async = &FutureIterType_as_async,
-    .tp_getattro = PyObject_GenericGetAttr,
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
-    .tp_traverse = (traverseproc)FutureIter_traverse,
-    .tp_iter = PyObject_SelfIter,
-    .tp_iternext = (iternextfunc)FutureIter_iternext,
-    .tp_methods = FutureIter_methods,
+static PyType_Spec FutureIter_spec = {
+    .name = "_asyncio.FutureIter",
+    .basicsize = sizeof(futureiterobject),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+              Py_TPFLAGS_IMMUTABLETYPE),
+    .slots = FutureIter_slots,
 };
 
 static PyObject *
@@ -1735,12 +1831,13 @@ future_new_iter(PyObject *fut)
 {
     futureiterobject *it;
 
-    if (!PyObject_TypeCheck(fut, &FutureType)) {
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
+    if (!Future_Check(state, fut)) {
         PyErr_BadInternalCall();
         return NULL;
     }
 
-    ENSURE_FUTURE_ALIVE(fut)
+    ENSURE_FUTURE_ALIVE(state, fut)
 
     if (fi_freelist_len) {
         fi_freelist_len--;
@@ -1750,7 +1847,7 @@ future_new_iter(PyObject *fut)
         _Py_NewReference((PyObject*) it);
     }
     else {
-        it = PyObject_GC_New(futureiterobject, &FutureIterType);
+        it = PyObject_GC_New(futureiterobject, state->FutureIterType);
         if (it == NULL) {
             return NULL;
         }
@@ -1770,9 +1867,9 @@ class _asyncio.Task "TaskObj *" "&Task_Type"
 [clinic start generated code]*/
 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=719dcef0fcc03b37]*/
 
-static int task_call_step_soon(TaskObj *, PyObject *);
+static int task_call_step_soon(asyncio_state *state, TaskObj *, PyObject *);
 static PyObject * task_wakeup(TaskObj *, PyObject *);
-static PyObject * task_step(TaskObj *, PyObject *);
+static PyObject * task_step(asyncio_state *, TaskObj *, PyObject *);
 
 /* ----- Task._step wrapper */
 
@@ -1787,9 +1884,11 @@ TaskStepMethWrapper_clear(TaskStepMethWrapper *o)
 static void
 TaskStepMethWrapper_dealloc(TaskStepMethWrapper *o)
 {
+    PyTypeObject *tp = Py_TYPE(o);
     PyObject_GC_UnTrack(o);
     (void)TaskStepMethWrapper_clear(o);
     Py_TYPE(o)->tp_free(o);
+    Py_DECREF(tp);
 }
 
 static PyObject *
@@ -1804,13 +1903,15 @@ TaskStepMethWrapper_call(TaskStepMethWrapper *o,
         PyErr_SetString(PyExc_TypeError, "function takes no positional arguments");
         return NULL;
     }
-    return task_step(o->sw_task, o->sw_arg);
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)o);
+    return task_step(state, o->sw_task, o->sw_arg);
 }
 
 static int
 TaskStepMethWrapper_traverse(TaskStepMethWrapper *o,
                              visitproc visit, void *arg)
 {
+    Py_VISIT(Py_TYPE(o));
     Py_VISIT(o->sw_task);
     Py_VISIT(o->sw_arg);
     return 0;
@@ -1830,25 +1931,30 @@ static PyGetSetDef TaskStepMethWrapper_getsetlist[] = {
     {NULL} /* Sentinel */
 };
 
-static PyTypeObject TaskStepMethWrapper_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "TaskStepMethWrapper",
-    .tp_basicsize = sizeof(TaskStepMethWrapper),
-    .tp_itemsize = 0,
-    .tp_getset = TaskStepMethWrapper_getsetlist,
-    .tp_dealloc = (destructor)TaskStepMethWrapper_dealloc,
-    .tp_call = (ternaryfunc)TaskStepMethWrapper_call,
-    .tp_getattro = PyObject_GenericGetAttr,
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
-    .tp_traverse = (traverseproc)TaskStepMethWrapper_traverse,
-    .tp_clear = (inquiry)TaskStepMethWrapper_clear,
+static PyType_Slot TaskStepMethWrapper_slots[] = {
+    {Py_tp_getset, TaskStepMethWrapper_getsetlist},
+    {Py_tp_dealloc, (destructor)TaskStepMethWrapper_dealloc},
+    {Py_tp_call, (ternaryfunc)TaskStepMethWrapper_call},
+    {Py_tp_getattro, PyObject_GenericGetAttr},
+    {Py_tp_traverse, (traverseproc)TaskStepMethWrapper_traverse},
+    {Py_tp_clear, (inquiry)TaskStepMethWrapper_clear},
+    {0, NULL},
+};
+
+static PyType_Spec TaskStepMethWrapper_spec = {
+    .name = "_asyncio.TaskStepMethWrapper",
+    .basicsize = sizeof(TaskStepMethWrapper),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+              Py_TPFLAGS_IMMUTABLETYPE),
+    .slots = TaskStepMethWrapper_slots,
 };
 
 static PyObject *
 TaskStepMethWrapper_new(TaskObj *task, PyObject *arg)
 {
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)task);
     TaskStepMethWrapper *o;
-    o = PyObject_GC_New(TaskStepMethWrapper, &TaskStepMethWrapper_Type);
+    o = PyObject_GC_New(TaskStepMethWrapper, state->TaskStepMethWrapper_Type);
     if (o == NULL) {
         return NULL;
     }
@@ -1872,10 +1978,10 @@ static  PyMethodDef TaskWakeupDef = {
 /* ----- Task introspection helpers */
 
 static int
-register_task(PyObject *task)
+register_task(asyncio_state *state, PyObject *task)
 {
-    PyObject *res = PyObject_CallMethodOneArg(all_tasks,
-                                                &_Py_ID(add), task);
+    PyObject *res = PyObject_CallMethodOneArg(state->all_tasks,
+                                                 &_Py_ID(add), task);
     if (res == NULL) {
         return -1;
     }
@@ -1885,9 +1991,9 @@ register_task(PyObject *task)
 
 
 static int
-unregister_task(PyObject *task)
+unregister_task(asyncio_state *state, PyObject *task)
 {
-    PyObject *res = PyObject_CallMethodOneArg(all_tasks,
+    PyObject *res = PyObject_CallMethodOneArg(state->all_tasks,
                                      &_Py_ID(discard), task);
     if (res == NULL) {
         return -1;
@@ -1898,7 +2004,7 @@ unregister_task(PyObject *task)
 
 
 static int
-enter_task(PyObject *loop, PyObject *task)
+enter_task(asyncio_state *state, PyObject *loop, PyObject *task)
 {
     PyObject *item;
     Py_hash_t hash;
@@ -1906,7 +2012,7 @@ enter_task(PyObject *loop, PyObject *task)
     if (hash == -1) {
         return -1;
     }
-    item = _PyDict_GetItem_KnownHash(current_tasks, loop, hash);
+    item = _PyDict_GetItem_KnownHash(state->current_tasks, loop, hash);
     if (item != NULL) {
         Py_INCREF(item);
         PyErr_Format(
@@ -1920,12 +2026,12 @@ enter_task(PyObject *loop, PyObject *task)
     if (PyErr_Occurred()) {
         return -1;
     }
-    return _PyDict_SetItem_KnownHash(current_tasks, loop, task, hash);
+    return _PyDict_SetItem_KnownHash(state->current_tasks, loop, task, hash);
 }
 
 
 static int
-leave_task(PyObject *loop, PyObject *task)
+leave_task(asyncio_state *state, PyObject *loop, PyObject *task)
 /*[clinic end generated code: output=0ebf6db4b858fb41 input=51296a46313d1ad8]*/
 {
     PyObject *item;
@@ -1934,7 +2040,7 @@ leave_task(PyObject *loop, PyObject *task)
     if (hash == -1) {
         return -1;
     }
-    item = _PyDict_GetItem_KnownHash(current_tasks, loop, hash);
+    item = _PyDict_GetItem_KnownHash(state->current_tasks, loop, hash);
     if (item != task) {
         if (item == NULL) {
             /* Not entered, replace with None */
@@ -1946,7 +2052,7 @@ leave_task(PyObject *loop, PyObject *task)
             task, item, NULL);
         return -1;
     }
-    return _PyDict_DelItem_KnownHash(current_tasks, loop, hash);
+    return _PyDict_DelItem_KnownHash(state->current_tasks, loop, hash);
 }
 
 /* ----- Task */
@@ -1973,7 +2079,8 @@ _asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop,
         return -1;
     }
 
-    int is_coro = is_coroutine(coro);
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)self);
+    int is_coro = is_coroutine(state, coro);
     if (is_coro == -1) {
         return -1;
     }
@@ -2002,7 +2109,8 @@ _asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop,
     Py_XSETREF(self->task_coro, coro);
 
     if (name == Py_None) {
-        name = PyUnicode_FromFormat("Task-%" PRIu64, ++task_name_counter);
+        name = PyUnicode_FromFormat("Task-%" PRIu64,
+                                    ++state->task_name_counter);
     } else if (!PyUnicode_CheckExact(name)) {
         name = PyObject_Str(name);
     } else {
@@ -2013,10 +2121,10 @@ _asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop,
         return -1;
     }
 
-    if (task_call_step_soon(self, NULL)) {
+    if (task_call_step_soon(state, self, NULL)) {
         return -1;
     }
-    return register_task((PyObject*)self);
+    return register_task(state, (PyObject*)self);
 }
 
 static int
@@ -2033,11 +2141,23 @@ TaskObj_clear(TaskObj *task)
 static int
 TaskObj_traverse(TaskObj *task, visitproc visit, void *arg)
 {
+    Py_VISIT(Py_TYPE(task));
     Py_VISIT(task->task_context);
     Py_VISIT(task->task_coro);
     Py_VISIT(task->task_name);
     Py_VISIT(task->task_fut_waiter);
-    (void)FutureObj_traverse((FutureObj*) task, visit, arg);
+    FutureObj *fut = (FutureObj *)task;
+    Py_VISIT(fut->fut_loop);
+    Py_VISIT(fut->fut_callback0);
+    Py_VISIT(fut->fut_context0);
+    Py_VISIT(fut->fut_callbacks);
+    Py_VISIT(fut->fut_result);
+    Py_VISIT(fut->fut_exception);
+    Py_VISIT(fut->fut_exception_tb);
+    Py_VISIT(fut->fut_source_tb);
+    Py_VISIT(fut->fut_cancel_msg);
+    Py_VISIT(fut->fut_cancelled_exc);
+    Py_VISIT(fut->dict);
     return 0;
 }
 
@@ -2101,7 +2221,9 @@ TaskObj_get_fut_waiter(TaskObj *task, void *Py_UNUSED(ignored))
 static PyObject *
 TaskObj_repr(TaskObj *task)
 {
-    return PyObject_CallOneArg(asyncio_task_repr_func, (PyObject *)task);
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)task);
+    return PyObject_CallOneArg(state->asyncio_task_repr_func,
+                               (PyObject *)task);
 }
 
 
@@ -2238,6 +2360,8 @@ _asyncio_Task_uncancel_impl(TaskObj *self)
 /*[clinic input]
 _asyncio.Task.get_stack
 
+    cls: defining_class
+    /
     *
     limit: object = None
 
@@ -2263,16 +2387,20 @@ returned for a suspended coroutine.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Task_get_stack_impl(TaskObj *self, PyObject *limit)
-/*[clinic end generated code: output=c9aeeeebd1e18118 input=05b323d42b809b90]*/
+_asyncio_Task_get_stack_impl(TaskObj *self, PyTypeObject *cls,
+                             PyObject *limit)
+/*[clinic end generated code: output=6774dfc10d3857fa input=8e01c9b2618ae953]*/
 {
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
     return PyObject_CallFunctionObjArgs(
-        asyncio_task_get_stack_func, self, limit, NULL);
+        state->asyncio_task_get_stack_func, self, limit, NULL);
 }
 
 /*[clinic input]
 _asyncio.Task.print_stack
 
+    cls: defining_class
+    /
     *
     limit: object = None
     file: object = None
@@ -2287,12 +2415,13 @@ to sys.stderr.
 [clinic start generated code]*/
 
 static PyObject *
-_asyncio_Task_print_stack_impl(TaskObj *self, PyObject *limit,
-                               PyObject *file)
-/*[clinic end generated code: output=7339e10314cd3f4d input=1a0352913b7fcd92]*/
+_asyncio_Task_print_stack_impl(TaskObj *self, PyTypeObject *cls,
+                               PyObject *limit, PyObject *file)
+/*[clinic end generated code: output=b38affe9289ec826 input=150b35ba2d3a7dee]*/
 {
+    asyncio_state *state = get_asyncio_state_by_cls(cls);
     return PyObject_CallFunctionObjArgs(
-        asyncio_task_print_stack_func, self, limit, file, NULL);
+        state->asyncio_task_print_stack_func, self, limit, file, NULL);
 }
 
 /*[clinic input]
@@ -2475,6 +2604,12 @@ static PyMethodDef TaskType_methods[] = {
     {NULL, NULL}        /* Sentinel */
 };
 
+static PyMemberDef TaskType_members[] = {
+    {"__weaklistoffset__", T_PYSSIZET, offsetof(TaskObj, task_weakreflist), READONLY},
+    {"__dictoffset__", T_PYSSIZET, offsetof(TaskObj, dict), READONLY},
+    {NULL},
+};
+
 static PyGetSetDef TaskType_getsetlist[] = {
     FUTURE_COMMON_GETSETLIST
     {"_log_destroy_pending", (getter)TaskObj_get_log_destroy_pending,
@@ -2485,26 +2620,31 @@ static PyGetSetDef TaskType_getsetlist[] = {
     {NULL} /* Sentinel */
 };
 
-static PyTypeObject TaskType = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_asyncio.Task",
-    sizeof(TaskObj),                       /* tp_basicsize */
-    .tp_base = &FutureType,
-    .tp_dealloc = TaskObj_dealloc,
-    .tp_as_async = &FutureType_as_async,
-    .tp_repr = (reprfunc)TaskObj_repr,
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
-    .tp_doc = _asyncio_Task___init____doc__,
-    .tp_traverse = (traverseproc)TaskObj_traverse,
-    .tp_clear = (inquiry)TaskObj_clear,
-    .tp_weaklistoffset = offsetof(TaskObj, task_weakreflist),
-    .tp_iter = (getiterfunc)future_new_iter,
-    .tp_methods = TaskType_methods,
-    .tp_getset = TaskType_getsetlist,
-    .tp_dictoffset = offsetof(TaskObj, dict),
-    .tp_init = (initproc)_asyncio_Task___init__,
-    .tp_new = PyType_GenericNew,
-    .tp_finalize = (destructor)TaskObj_finalize,
+static PyType_Slot Task_slots[] = {
+    {Py_tp_dealloc, TaskObj_dealloc},
+    {Py_tp_repr, (reprfunc)TaskObj_repr},
+    {Py_tp_doc, (void *)_asyncio_Task___init____doc__},
+    {Py_tp_traverse, (traverseproc)TaskObj_traverse},
+    {Py_tp_clear, (inquiry)TaskObj_clear},
+    {Py_tp_iter, (getiterfunc)future_new_iter},
+    {Py_tp_methods, TaskType_methods},
+    {Py_tp_members, TaskType_members},
+    {Py_tp_getset, TaskType_getsetlist},
+    {Py_tp_init, (initproc)_asyncio_Task___init__},
+    {Py_tp_new, PyType_GenericNew},
+    {Py_tp_finalize, (destructor)TaskObj_finalize},
+
+    // async slots
+    {Py_am_await, (unaryfunc)future_new_iter},
+    {0, NULL},
+};
+
+static PyType_Spec Task_spec = {
+    .name = "_asyncio.Task",
+    .basicsize = sizeof(TaskObj),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |
+              Py_TPFLAGS_IMMUTABLETYPE),
+    .slots = Task_slots,
 };
 
 static void
@@ -2512,16 +2652,12 @@ TaskObj_dealloc(PyObject *self)
 {
     TaskObj *task = (TaskObj *)self;
 
-    if (Task_CheckExact(self)) {
-        /* When fut is subclass of Task, finalizer is called from
-         * subtype_dealloc.
-         */
-        if (PyObject_CallFinalizerFromDealloc(self) < 0) {
-            // resurrected.
-            return;
-        }
+    if (PyObject_CallFinalizerFromDealloc(self) < 0) {
+        // resurrected.
+        return;
     }
 
+    PyTypeObject *tp = Py_TYPE(task);
     PyObject_GC_UnTrack(self);
 
     if (task->task_weakreflist != NULL) {
@@ -2529,24 +2665,26 @@ TaskObj_dealloc(PyObject *self)
     }
 
     (void)TaskObj_clear(task);
-    Py_TYPE(task)->tp_free(task);
+    tp->tp_free(task);
+    Py_DECREF(tp);
 }
 
 static int
-task_call_step_soon(TaskObj *task, PyObject *arg)
+task_call_step_soon(asyncio_state *state, TaskObj *task, PyObject *arg)
 {
     PyObject *cb = TaskStepMethWrapper_new(task, arg);
     if (cb == NULL) {
         return -1;
     }
 
-    int ret = call_soon(task->task_loop, cb, NULL, task->task_context);
+    int ret = call_soon(state, task->task_loop, cb, NULL, task->task_context);
     Py_DECREF(cb);
     return ret;
 }
 
 static PyObject *
-task_set_error_soon(TaskObj *task, PyObject *et, const char *format, ...)
+task_set_error_soon(asyncio_state *state, TaskObj *task, PyObject *et,
+                    const char *format, ...)
 {
     PyObject* msg;
 
@@ -2565,7 +2703,7 @@ task_set_error_soon(TaskObj *task, PyObject *et, const char *format, ...)
         return NULL;
     }
 
-    if (task_call_step_soon(task, e) == -1) {
+    if (task_call_step_soon(state, task, e) == -1) {
         Py_DECREF(e);
         return NULL;
     }
@@ -2589,7 +2727,7 @@ gen_status_from_result(PyObject **result)
 }
 
 static PyObject *
-task_step_impl(TaskObj *task, PyObject *exc)
+task_step_impl(asyncio_state *state, TaskObj *task, PyObject *exc)
 {
     int res;
     int clear_exc = 0;
@@ -2598,7 +2736,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
     PyObject *o;
 
     if (task->task_state != STATE_PENDING) {
-        PyErr_Format(asyncio_InvalidStateError,
+        PyErr_Format(state->asyncio_InvalidStateError,
                      "_step(): already done: %R %R",
                      task,
                      exc ? exc : Py_None);
@@ -2610,7 +2748,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
 
         if (exc) {
             /* Check if exc is a CancelledError */
-            res = PyObject_IsInstance(exc, asyncio_CancelledError);
+            res = PyObject_IsInstance(exc, state->asyncio_CancelledError);
             if (res == -1) {
                 /* An error occurred, abort */
                 goto fail;
@@ -2623,7 +2761,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
 
         if (!exc) {
             /* exc was not a CancelledError */
-            exc = create_cancelled_error((FutureObj*)task);
+            exc = create_cancelled_error(state, (FutureObj*)task);
 
             if (!exc) {
                 goto fail;
@@ -2670,10 +2808,11 @@ task_step_impl(TaskObj *task, PyObject *exc)
             if (task->task_must_cancel) {
                 // Task is cancelled right before coro stops.
                 task->task_must_cancel = 0;
-                tmp = future_cancel((FutureObj*)task, task->task_cancel_msg);
+                tmp = future_cancel(state, (FutureObj*)task,
+                                    task->task_cancel_msg);
             }
             else {
-                tmp = future_set_result((FutureObj*)task, result);
+                tmp = future_set_result(state, (FutureObj*)task, result);
             }
 
             Py_DECREF(result);
@@ -2685,7 +2824,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
             Py_RETURN_NONE;
         }
 
-        if (PyErr_ExceptionMatches(asyncio_CancelledError)) {
+        if (PyErr_ExceptionMatches(state->asyncio_CancelledError)) {
             /* CancelledError */
             PyErr_Fetch(&et, &ev, &tb);
             assert(et);
@@ -2700,7 +2839,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
             /* transfer ownership */
             fut->fut_cancelled_exc = ev;
 
-            return future_cancel(fut, NULL);
+            return future_cancel(state, fut, NULL);
         }
 
         /* Some other exception; pop it and call Task.set_exception() */
@@ -2711,7 +2850,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
             PyException_SetTraceback(ev, tb);
         }
 
-        o = future_set_exception((FutureObj*)task, ev);
+        o = future_set_exception(state, (FutureObj*)task, ev);
         if (!o) {
             /* An exception in Task.set_exception() */
             Py_DECREF(et);
@@ -2743,7 +2882,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
     }
 
     /* Check if `result` is FutureObj or TaskObj (and not a subclass) */
-    if (Future_CheckExact(result) || Task_CheckExact(result)) {
+    if (Future_CheckExact(state, result) || Task_CheckExact(state, result)) {
         PyObject *wrapper;
         PyObject *tmp;
         FutureObj *fut = (FutureObj*)result;
@@ -2764,7 +2903,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
         if (wrapper == NULL) {
             goto fail;
         }
-        tmp = future_add_done_callback(
+        tmp = future_add_done_callback(state,
             (FutureObj*)result, wrapper, task->task_context);
         Py_DECREF(wrapper);
         if (tmp == NULL) {
@@ -2799,7 +2938,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
     /* Check if `result` is None */
     if (result == Py_None) {
         /* Bare yield relinquishes control for one event loop iteration. */
-        if (task_call_step_soon(task, NULL)) {
+        if (task_call_step_soon(state, task, NULL)) {
             goto fail;
         }
         return result;
@@ -2821,7 +2960,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
         }
 
         /* Check if `result` future is attached to a different loop */
-        PyObject *oloop = get_future_loop(result);
+        PyObject *oloop = get_future_loop(state, result);
         if (oloop == NULL) {
             goto fail;
         }
@@ -2857,7 +2996,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
         stack[0] = wrapper;
         stack[1] = (PyObject *)task->task_context;
         EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, add_cb);
-        tmp = PyObject_Vectorcall(add_cb, stack, 1, context_kwname);
+        tmp = PyObject_Vectorcall(add_cb, stack, 1, state->context_kwname);
         Py_DECREF(add_cb);
         Py_DECREF(wrapper);
         if (tmp == NULL) {
@@ -2898,7 +3037,7 @@ task_step_impl(TaskObj *task, PyObject *exc)
     if (res) {
         /* `result` is a generator */
         o = task_set_error_soon(
-            task, PyExc_RuntimeError,
+            state, task, PyExc_RuntimeError,
             "yield was used instead of yield from for "
             "generator in task %R with %R", task, result);
         Py_DECREF(result);
@@ -2907,20 +3046,20 @@ task_step_impl(TaskObj *task, PyObject *exc)
 
     /* The `result` is none of the above */
     o = task_set_error_soon(
-        task, PyExc_RuntimeError, "Task got bad yield: %R", result);
+        state, task, PyExc_RuntimeError, "Task got bad yield: %R", result);
     Py_DECREF(result);
     return o;
 
 self_await:
     o = task_set_error_soon(
-        task, PyExc_RuntimeError,
+        state, task, PyExc_RuntimeError,
         "Task cannot await on itself: %R", task);
     Py_DECREF(result);
     return o;
 
 yield_insteadof_yf:
     o = task_set_error_soon(
-        task, PyExc_RuntimeError,
+        state, task, PyExc_RuntimeError,
         "yield was used instead of yield from "
         "in task %R with %R",
         task, result);
@@ -2929,7 +3068,7 @@ yield_insteadof_yf:
 
 different_loop:
     o = task_set_error_soon(
-        task, PyExc_RuntimeError,
+        state, task, PyExc_RuntimeError,
         "Task %R got Future %R attached to a different loop",
         task, result);
     Py_DECREF(result);
@@ -2941,25 +3080,25 @@ fail:
 }
 
 static PyObject *
-task_step(TaskObj *task, PyObject *exc)
+task_step(asyncio_state *state, TaskObj *task, PyObject *exc)
 {
     PyObject *res;
 
-    if (enter_task(task->task_loop, (PyObject*)task) < 0) {
+    if (enter_task(state, task->task_loop, (PyObject*)task) < 0) {
         return NULL;
     }
 
-    res = task_step_impl(task, exc);
+    res = task_step_impl(state, task, exc);
 
     if (res == NULL) {
         PyObject *et, *ev, *tb;
         PyErr_Fetch(&et, &ev, &tb);
-        leave_task(task->task_loop, (PyObject*)task);
+        leave_task(state, task->task_loop, (PyObject*)task);
         _PyErr_ChainExceptions(et, ev, tb); /* Normalizes (et, ev, tb) */
         return NULL;
     }
     else {
-        if (leave_task(task->task_loop, (PyObject*)task) < 0) {
+        if (leave_task(state, task->task_loop, (PyObject*)task) < 0) {
             Py_DECREF(res);
             return NULL;
         }
@@ -2976,9 +3115,10 @@ task_wakeup(TaskObj *task, PyObject *o)
     PyObject *result;
     assert(o);
 
-    if (Future_CheckExact(o) || Task_CheckExact(o)) {
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)task);
+    if (Future_CheckExact(state, o) || Task_CheckExact(state, o)) {
         PyObject *fut_result = NULL;
-        int res = future_get_result((FutureObj*)o, &fut_result);
+        int res = future_get_result(state, (FutureObj*)o, &fut_result);
 
         switch(res) {
         case -1:
@@ -2986,10 +3126,10 @@ task_wakeup(TaskObj *task, PyObject *o)
             break; /* exception raised */
         case 0:
             Py_DECREF(fut_result);
-            return task_step(task, NULL);
+            return task_step(state, task, NULL);
         default:
             assert(res == 1);
-            result = task_step(task, fut_result);
+            result = task_step(state, task, fut_result);
             Py_DECREF(fut_result);
             return result;
         }
@@ -2998,7 +3138,7 @@ task_wakeup(TaskObj *task, PyObject *o)
         PyObject *fut_result = PyObject_CallMethod(o, "result", NULL);
         if (fut_result != NULL) {
             Py_DECREF(fut_result);
-            return task_step(task, NULL);
+            return task_step(state, task, NULL);
         }
         /* exception raised */
     }
@@ -3010,7 +3150,7 @@ task_wakeup(TaskObj *task, PyObject *o)
         PyException_SetTraceback(ev, tb);
     }
 
-    result = task_step(task, ev);
+    result = task_step(state, task, ev);
 
     Py_DECREF(et);
     Py_XDECREF(tb);
@@ -3038,7 +3178,8 @@ _asyncio__get_running_loop_impl(PyObject *module)
 /*[clinic end generated code: output=b4390af721411a0a input=0a21627e25a4bd43]*/
 {
     PyObject *loop;
-    if (get_running_loop(&loop)) {
+    asyncio_state *state = get_asyncio_state(module);
+    if (get_running_loop(state, &loop)) {
         return NULL;
     }
     if (loop == NULL) {
@@ -3063,7 +3204,8 @@ static PyObject *
 _asyncio__set_running_loop(PyObject *module, PyObject *loop)
 /*[clinic end generated code: output=ae56bf7a28ca189a input=4c9720233d606604]*/
 {
-    if (set_running_loop(loop)) {
+    asyncio_state *state = get_asyncio_state(module);
+    if (set_running_loop(state, loop)) {
         return NULL;
     }
     Py_RETURN_NONE;
@@ -3086,7 +3228,8 @@ static PyObject *
 _asyncio_get_event_loop_impl(PyObject *module)
 /*[clinic end generated code: output=2a2d8b2f824c648b input=9364bf2916c8655d]*/
 {
-    return get_event_loop(1);
+    asyncio_state *state = get_asyncio_state(module);
+    return get_event_loop(state, 1);
 }
 
 /*[clinic input]
@@ -3098,7 +3241,8 @@ static PyObject *
 _asyncio__get_event_loop_impl(PyObject *module, int stacklevel)
 /*[clinic end generated code: output=9c1d6d3c802e67c9 input=d17aebbd686f711d]*/
 {
-    return get_event_loop(stacklevel-1);
+    asyncio_state *state = get_asyncio_state(module);
+    return get_event_loop(state, stacklevel-1);
 }
 
 /*[clinic input]
@@ -3114,7 +3258,8 @@ _asyncio_get_running_loop_impl(PyObject *module)
 /*[clinic end generated code: output=c247b5f9e529530e input=2a3bf02ba39f173d]*/
 {
     PyObject *loop;
-    if (get_running_loop(&loop)) {
+    asyncio_state *state = get_asyncio_state(module);
+    if (get_running_loop(state, &loop)) {
         return NULL;
     }
     if (loop == NULL) {
@@ -3139,7 +3284,8 @@ static PyObject *
 _asyncio__register_task_impl(PyObject *module, PyObject *task)
 /*[clinic end generated code: output=8672dadd69a7d4e2 input=21075aaea14dfbad]*/
 {
-    if (register_task(task) < 0) {
+    asyncio_state *state = get_asyncio_state(module);
+    if (register_task(state, task) < 0) {
         return NULL;
     }
     Py_RETURN_NONE;
@@ -3160,7 +3306,8 @@ static PyObject *
 _asyncio__unregister_task_impl(PyObject *module, PyObject *task)
 /*[clinic end generated code: output=6e5585706d568a46 input=28fb98c3975f7bdc]*/
 {
-    if (unregister_task(task) < 0) {
+    asyncio_state *state = get_asyncio_state(module);
+    if (unregister_task(state, task) < 0) {
         return NULL;
     }
     Py_RETURN_NONE;
@@ -3184,7 +3331,8 @@ static PyObject *
 _asyncio__enter_task_impl(PyObject *module, PyObject *loop, PyObject *task)
 /*[clinic end generated code: output=a22611c858035b73 input=de1b06dca70d8737]*/
 {
-    if (enter_task(loop, task) < 0) {
+    asyncio_state *state = get_asyncio_state(module);
+    if (enter_task(state, loop, task) < 0) {
         return NULL;
     }
     Py_RETURN_NONE;
@@ -3208,7 +3356,8 @@ static PyObject *
 _asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task)
 /*[clinic end generated code: output=0ebf6db4b858fb41 input=51296a46313d1ad8]*/
 {
-    if (leave_task(loop, task) < 0) {
+    asyncio_state *state = get_asyncio_state(module);
+    if (leave_task(state, loop, task) < 0) {
         return NULL;
     }
     Py_RETURN_NONE;
@@ -3219,10 +3368,10 @@ _asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task)
 
 
 static PyRunningLoopHolder *
-new_running_loop_holder(PyObject *loop)
+new_running_loop_holder(asyncio_state *state, PyObject *loop)
 {
-    PyRunningLoopHolder *rl = PyObject_New(
-        PyRunningLoopHolder, &PyRunningLoopHolder_Type);
+    PyRunningLoopHolder *rl = PyObject_GC_New(
+        PyRunningLoopHolder, state->PyRunningLoopHolder_Type);
     if (rl == NULL) {
         return NULL;
     }
@@ -3232,28 +3381,59 @@ new_running_loop_holder(PyObject *loop)
 #endif
     rl->rl_loop = Py_NewRef(loop);
 
+    PyObject_GC_Track(rl);
     return rl;
 }
 
 
+static int
+PyRunningLoopHolder_clear(PyRunningLoopHolder *rl)
+{
+    Py_CLEAR(rl->rl_loop);
+    return 0;
+}
+
+
+static int
+PyRunningLoopHolder_traverse(PyRunningLoopHolder *rl, visitproc visit,
+                             void *arg)
+{
+    Py_VISIT(Py_TYPE(rl));
+    Py_VISIT(rl->rl_loop);
+    return 0;
+}
+
+
 static void
 PyRunningLoopHolder_tp_dealloc(PyRunningLoopHolder *rl)
 {
-    if (cached_running_holder == (PyObject *)rl) {
-        cached_running_holder = NULL;
+    asyncio_state *state = get_asyncio_state_by_def((PyObject *)rl);
+    if (state->cached_running_holder == (PyObject *)rl) {
+        state->cached_running_holder = NULL;
     }
-    Py_CLEAR(rl->rl_loop);
-    PyObject_Free(rl);
+    PyTypeObject *tp = Py_TYPE(rl);
+    PyObject_GC_UnTrack(rl);
+    PyRunningLoopHolder_clear(rl);
+    PyObject_GC_Del(rl);
+    Py_DECREF(tp);
 }
 
 
-static PyTypeObject PyRunningLoopHolder_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_RunningLoopHolder",
-    sizeof(PyRunningLoopHolder),
-    .tp_getattro = PyObject_GenericGetAttr,
-    .tp_flags = Py_TPFLAGS_DEFAULT,
-    .tp_dealloc = (destructor)PyRunningLoopHolder_tp_dealloc,
+static PyType_Slot PyRunningLoopHolder_slots[] = {
+    {Py_tp_getattro, PyObject_GenericGetAttr},
+    {Py_tp_dealloc, (destructor)PyRunningLoopHolder_tp_dealloc},
+    {Py_tp_traverse, (traverseproc)PyRunningLoopHolder_traverse},
+    {Py_tp_clear, PyRunningLoopHolder_clear},
+    {0, NULL},
+};
+
+
+static PyType_Spec PyRunningLoopHolder_spec = {
+    .name = "_asyncio._RunningLoopHolder",
+    .basicsize = sizeof(PyRunningLoopHolder),
+    .slots = PyRunningLoopHolder_slots,
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+              Py_TPFLAGS_IMMUTABLETYPE),
 };
 
 
@@ -3279,58 +3459,106 @@ module_free_freelists(void)
     fi_freelist = NULL;
 }
 
+static int
+module_traverse(PyObject *mod, visitproc visit, void *arg)
+{
+    asyncio_state *state = get_asyncio_state(mod);
+
+    Py_VISIT(state->FutureIterType);
+    Py_VISIT(state->TaskStepMethWrapper_Type);
+    Py_VISIT(state->FutureType);
+    Py_VISIT(state->TaskType);
+    Py_VISIT(state->PyRunningLoopHolder_Type);
+
+    Py_VISIT(state->asyncio_mod);
+    Py_VISIT(state->traceback_extract_stack);
+    Py_VISIT(state->asyncio_future_repr_func);
+    Py_VISIT(state->asyncio_get_event_loop_policy);
+    Py_VISIT(state->asyncio_iscoroutine_func);
+    Py_VISIT(state->asyncio_task_get_stack_func);
+    Py_VISIT(state->asyncio_task_print_stack_func);
+    Py_VISIT(state->asyncio_task_repr_func);
+    Py_VISIT(state->asyncio_InvalidStateError);
+    Py_VISIT(state->asyncio_CancelledError);
+
+    Py_VISIT(state->all_tasks);
+    Py_VISIT(state->current_tasks);
+    Py_VISIT(state->iscoroutine_typecache);
+
+    Py_VISIT(state->context_kwname);
+
+    // Visit freelist.
+    PyObject *next = (PyObject*) fi_freelist;
+    while (next != NULL) {
+        PyObject *current = next;
+        Py_VISIT(current);
+        next = (PyObject*) ((futureiterobject*) current)->future;
+    }
+    return 0;
+}
 
-static void
-module_free(void *m)
+static int
+module_clear(PyObject *mod)
 {
-    Py_CLEAR(asyncio_mod);
-    Py_CLEAR(traceback_extract_stack);
-    Py_CLEAR(asyncio_future_repr_func);
-    Py_CLEAR(asyncio_get_event_loop_policy);
-    Py_CLEAR(asyncio_iscoroutine_func);
-    Py_CLEAR(asyncio_task_get_stack_func);
-    Py_CLEAR(asyncio_task_print_stack_func);
-    Py_CLEAR(asyncio_task_repr_func);
-    Py_CLEAR(asyncio_InvalidStateError);
-    Py_CLEAR(asyncio_CancelledError);
+    asyncio_state *state = get_asyncio_state(mod);
+
+    Py_CLEAR(state->FutureIterType);
+    Py_CLEAR(state->TaskStepMethWrapper_Type);
+    Py_CLEAR(state->FutureType);
+    Py_CLEAR(state->TaskType);
+    Py_CLEAR(state->PyRunningLoopHolder_Type);
 
-    Py_CLEAR(all_tasks);
-    Py_CLEAR(current_tasks);
-    Py_CLEAR(iscoroutine_typecache);
+    Py_CLEAR(state->asyncio_mod);
+    Py_CLEAR(state->traceback_extract_stack);
+    Py_CLEAR(state->asyncio_future_repr_func);
+    Py_CLEAR(state->asyncio_get_event_loop_policy);
+    Py_CLEAR(state->asyncio_iscoroutine_func);
+    Py_CLEAR(state->asyncio_task_get_stack_func);
+    Py_CLEAR(state->asyncio_task_print_stack_func);
+    Py_CLEAR(state->asyncio_task_repr_func);
+    Py_CLEAR(state->asyncio_InvalidStateError);
+    Py_CLEAR(state->asyncio_CancelledError);
 
-    Py_CLEAR(context_kwname);
+    Py_CLEAR(state->all_tasks);
+    Py_CLEAR(state->current_tasks);
+    Py_CLEAR(state->iscoroutine_typecache);
+
+    Py_CLEAR(state->context_kwname);
 
     module_free_freelists();
 
-    module_initialized = 0;
+    return 0;
+}
+
+static void
+module_free(void *mod)
+{
+    (void)module_clear((PyObject *)mod);
 }
 
 static int
-module_init(void)
+module_init(asyncio_state *state)
 {
     PyObject *module = NULL;
-    if (module_initialized) {
-        return 0;
-    }
 
-    asyncio_mod = PyImport_ImportModule("asyncio");
-    if (asyncio_mod == NULL) {
+    state->asyncio_mod = PyImport_ImportModule("asyncio");
+    if (state->asyncio_mod == NULL) {
         goto fail;
     }
 
-    current_tasks = PyDict_New();
-    if (current_tasks == NULL) {
+    state->current_tasks = PyDict_New();
+    if (state->current_tasks == NULL) {
         goto fail;
     }
 
-    iscoroutine_typecache = PySet_New(NULL);
-    if (iscoroutine_typecache == NULL) {
+    state->iscoroutine_typecache = PySet_New(NULL);
+    if (state->iscoroutine_typecache == NULL) {
         goto fail;
     }
 
 
-    context_kwname = Py_BuildValue("(s)", "context");
-    if (context_kwname == NULL) {
+    state->context_kwname = Py_BuildValue("(s)", "context");
+    if (state->context_kwname == NULL) {
         goto fail;
     }
 
@@ -3348,42 +3576,40 @@ module_init(void)
     }
 
     WITH_MOD("asyncio.events")
-    GET_MOD_ATTR(asyncio_get_event_loop_policy, "get_event_loop_policy")
+    GET_MOD_ATTR(state->asyncio_get_event_loop_policy, "get_event_loop_policy")
 
     WITH_MOD("asyncio.base_futures")
-    GET_MOD_ATTR(asyncio_future_repr_func, "_future_repr")
+    GET_MOD_ATTR(state->asyncio_future_repr_func, "_future_repr")
 
     WITH_MOD("asyncio.exceptions")
-    GET_MOD_ATTR(asyncio_InvalidStateError, "InvalidStateError")
-    GET_MOD_ATTR(asyncio_CancelledError, "CancelledError")
+    GET_MOD_ATTR(state->asyncio_InvalidStateError, "InvalidStateError")
+    GET_MOD_ATTR(state->asyncio_CancelledError, "CancelledError")
 
     WITH_MOD("asyncio.base_tasks")
-    GET_MOD_ATTR(asyncio_task_repr_func, "_task_repr")
-    GET_MOD_ATTR(asyncio_task_get_stack_func, "_task_get_stack")
-    GET_MOD_ATTR(asyncio_task_print_stack_func, "_task_print_stack")
+    GET_MOD_ATTR(state->asyncio_task_repr_func, "_task_repr")
+    GET_MOD_ATTR(state->asyncio_task_get_stack_func, "_task_get_stack")
+    GET_MOD_ATTR(state->asyncio_task_print_stack_func, "_task_print_stack")
 
     WITH_MOD("asyncio.coroutines")
-    GET_MOD_ATTR(asyncio_iscoroutine_func, "iscoroutine")
+    GET_MOD_ATTR(state->asyncio_iscoroutine_func, "iscoroutine")
 
     WITH_MOD("traceback")
-    GET_MOD_ATTR(traceback_extract_stack, "extract_stack")
+    GET_MOD_ATTR(state->traceback_extract_stack, "extract_stack")
 
     PyObject *weak_set;
     WITH_MOD("weakref")
     GET_MOD_ATTR(weak_set, "WeakSet");
-    all_tasks = PyObject_CallNoArgs(weak_set);
+    state->all_tasks = PyObject_CallNoArgs(weak_set);
     Py_CLEAR(weak_set);
-    if (all_tasks == NULL) {
+    if (state->all_tasks == NULL) {
         goto fail;
     }
 
-    module_initialized = 1;
     Py_DECREF(module);
     return 0;
 
 fail:
     Py_CLEAR(module);
-    module_free(NULL);
     return -1;
 
 #undef WITH_MOD
@@ -3405,64 +3631,71 @@ static PyMethodDef asyncio_methods[] = {
     {NULL, NULL}
 };
 
-static struct PyModuleDef _asynciomodule = {
-    PyModuleDef_HEAD_INIT,      /* m_base */
-    "_asyncio",                 /* m_name */
-    module_doc,                 /* m_doc */
-    -1,                         /* m_size */
-    asyncio_methods,            /* m_methods */
-    NULL,                       /* m_slots */
-    NULL,                       /* m_traverse */
-    NULL,                       /* m_clear */
-    (freefunc)module_free       /* m_free */
-};
+static int
+module_exec(PyObject *mod)
+{
+    asyncio_state *state = get_asyncio_state(mod);
 
+#define CREATE_TYPE(m, tp, spec, base)                                  \
+    do {                                                                \
+        tp = (PyTypeObject *)PyType_FromMetaclass(NULL, m, spec,        \
+                                                  (PyObject *)base);    \
+        if (tp == NULL) {                                               \
+            return -1;                                                  \
+        }                                                               \
+    } while (0)
 
-PyMODINIT_FUNC
-PyInit__asyncio(void)
-{
-    if (module_init() < 0) {
-        return NULL;
-    }
-    if (PyType_Ready(&FutureIterType) < 0) {
-        return NULL;
+    CREATE_TYPE(mod, state->TaskStepMethWrapper_Type, &TaskStepMethWrapper_spec, NULL);
+    CREATE_TYPE(mod, state->PyRunningLoopHolder_Type, &PyRunningLoopHolder_spec, NULL);
+    CREATE_TYPE(mod, state->FutureIterType, &FutureIter_spec, NULL);
+    CREATE_TYPE(mod, state->FutureType, &Future_spec, NULL);
+    CREATE_TYPE(mod, state->TaskType, &Task_spec, state->FutureType);
+
+#undef CREATE_TYPE
+
+    if (PyModule_AddType(mod, state->FutureType) < 0) {
+        return -1;
     }
-    if (PyType_Ready(&TaskStepMethWrapper_Type) < 0) {
-        return NULL;
+
+    if (PyModule_AddType(mod, state->TaskType) < 0) {
+        return -1;
     }
-    if (PyType_Ready(&PyRunningLoopHolder_Type) < 0) {
-        return NULL;
+    // Must be done after types are added to avoid a circular dependency
+    if (module_init(state) < 0) {
+        return -1;
     }
 
-    PyObject *m = PyModule_Create(&_asynciomodule);
-    if (m == NULL) {
-        return NULL;
+    if (PyModule_AddObjectRef(mod, "_all_tasks", state->all_tasks) < 0) {
+        return -1;
     }
 
-    /* FutureType and TaskType are made ready by PyModule_AddType() calls below. */
-    if (PyModule_AddType(m, &FutureType) < 0) {
-        Py_DECREF(m);
-        return NULL;
+    if (PyModule_AddObjectRef(mod, "_current_tasks", state->current_tasks) < 0) {
+        return -1;
     }
 
-    if (PyModule_AddType(m, &TaskType) < 0) {
-        Py_DECREF(m);
-        return NULL;
-    }
 
-    Py_INCREF(all_tasks);
-    if (PyModule_AddObject(m, "_all_tasks", all_tasks) < 0) {
-        Py_DECREF(all_tasks);
-        Py_DECREF(m);
-        return NULL;
-    }
+    return 0;
+}
 
-    Py_INCREF(current_tasks);
-    if (PyModule_AddObject(m, "_current_tasks", current_tasks) < 0) {
-        Py_DECREF(current_tasks);
-        Py_DECREF(m);
-        return NULL;
-    }
+static struct PyModuleDef_Slot module_slots[] = {
+    {Py_mod_exec, module_exec},
+    {0, NULL},
+};
+
+static struct PyModuleDef _asynciomodule = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "_asyncio",
+    .m_doc = module_doc,
+    .m_size = sizeof(asyncio_state),
+    .m_methods = asyncio_methods,
+    .m_slots = module_slots,
+    .m_traverse = module_traverse,
+    .m_clear = module_clear,
+    .m_free = (freefunc)module_free,
+};
 
-    return m;
+PyMODINIT_FUNC
+PyInit__asyncio(void)
+{
+    return PyModuleDef_Init(&_asynciomodule);
 }
diff --git a/Modules/clinic/_asynciomodule.c.h b/Modules/clinic/_asynciomodule.c.h
index ddec54c..11db478 100644
--- a/Modules/clinic/_asynciomodule.c.h
+++ b/Modules/clinic/_asynciomodule.c.h
@@ -112,15 +112,19 @@ PyDoc_STRVAR(_asyncio_Future_exception__doc__,
 "InvalidStateError.");
 
 #define _ASYNCIO_FUTURE_EXCEPTION_METHODDEF    \
-    {"exception", (PyCFunction)_asyncio_Future_exception, METH_NOARGS, _asyncio_Future_exception__doc__},
+    {"exception", _PyCFunction_CAST(_asyncio_Future_exception), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_exception__doc__},
 
 static PyObject *
-_asyncio_Future_exception_impl(FutureObj *self);
+_asyncio_Future_exception_impl(FutureObj *self, PyTypeObject *cls);
 
 static PyObject *
-_asyncio_Future_exception(FutureObj *self, PyObject *Py_UNUSED(ignored))
+_asyncio_Future_exception(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
 {
-    return _asyncio_Future_exception_impl(self);
+    if (nargs) {
+        PyErr_SetString(PyExc_TypeError, "exception() takes no arguments");
+        return NULL;
+    }
+    return _asyncio_Future_exception_impl(self, cls);
 }
 
 PyDoc_STRVAR(_asyncio_Future_set_result__doc__,
@@ -133,7 +137,42 @@ PyDoc_STRVAR(_asyncio_Future_set_result__doc__,
 "InvalidStateError.");
 
 #define _ASYNCIO_FUTURE_SET_RESULT_METHODDEF    \
-    {"set_result", (PyCFunction)_asyncio_Future_set_result, METH_O, _asyncio_Future_set_result__doc__},
+    {"set_result", _PyCFunction_CAST(_asyncio_Future_set_result), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_set_result__doc__},
+
+static PyObject *
+_asyncio_Future_set_result_impl(FutureObj *self, PyTypeObject *cls,
+                                PyObject *result);
+
+static PyObject *
+_asyncio_Future_set_result(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "set_result",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyObject *result;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    result = args[0];
+    return_value = _asyncio_Future_set_result_impl(self, cls, result);
+
+exit:
+    return return_value;
+}
 
 PyDoc_STRVAR(_asyncio_Future_set_exception__doc__,
 "set_exception($self, exception, /)\n"
@@ -145,7 +184,42 @@ PyDoc_STRVAR(_asyncio_Future_set_exception__doc__,
 "InvalidStateError.");
 
 #define _ASYNCIO_FUTURE_SET_EXCEPTION_METHODDEF    \
-    {"set_exception", (PyCFunction)_asyncio_Future_set_exception, METH_O, _asyncio_Future_set_exception__doc__},
+    {"set_exception", _PyCFunction_CAST(_asyncio_Future_set_exception), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_set_exception__doc__},
+
+static PyObject *
+_asyncio_Future_set_exception_impl(FutureObj *self, PyTypeObject *cls,
+                                   PyObject *exception);
+
+static PyObject *
+_asyncio_Future_set_exception(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "set_exception",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyObject *exception;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    exception = args[0];
+    return_value = _asyncio_Future_set_exception_impl(self, cls, exception);
+
+exit:
+    return return_value;
+}
 
 PyDoc_STRVAR(_asyncio_Future_add_done_callback__doc__,
 "add_done_callback($self, fn, /, *, context=<unrepresentable>)\n"
@@ -158,14 +232,14 @@ PyDoc_STRVAR(_asyncio_Future_add_done_callback__doc__,
 "scheduled with call_soon.");
 
 #define _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF    \
-    {"add_done_callback", _PyCFunction_CAST(_asyncio_Future_add_done_callback), METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
+    {"add_done_callback", _PyCFunction_CAST(_asyncio_Future_add_done_callback), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
 
 static PyObject *
-_asyncio_Future_add_done_callback_impl(FutureObj *self, PyObject *fn,
-                                       PyObject *context);
+_asyncio_Future_add_done_callback_impl(FutureObj *self, PyTypeObject *cls,
+                                       PyObject *fn, PyObject *context);
 
 static PyObject *
-_asyncio_Future_add_done_callback(FutureObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_asyncio_Future_add_done_callback(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
@@ -208,7 +282,7 @@ _asyncio_Future_add_done_callback(FutureObj *self, PyObject *const *args, Py_ssi
     }
     context = args[1];
 skip_optional_kwonly:
-    return_value = _asyncio_Future_add_done_callback_impl(self, fn, context);
+    return_value = _asyncio_Future_add_done_callback_impl(self, cls, fn, context);
 
 exit:
     return return_value;
@@ -223,7 +297,42 @@ PyDoc_STRVAR(_asyncio_Future_remove_done_callback__doc__,
 "Returns the number of callbacks removed.");
 
 #define _ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF    \
-    {"remove_done_callback", (PyCFunction)_asyncio_Future_remove_done_callback, METH_O, _asyncio_Future_remove_done_callback__doc__},
+    {"remove_done_callback", _PyCFunction_CAST(_asyncio_Future_remove_done_callback), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_remove_done_callback__doc__},
+
+static PyObject *
+_asyncio_Future_remove_done_callback_impl(FutureObj *self, PyTypeObject *cls,
+                                          PyObject *fn);
+
+static PyObject *
+_asyncio_Future_remove_done_callback(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "remove_done_callback",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyObject *fn;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    fn = args[0];
+    return_value = _asyncio_Future_remove_done_callback_impl(self, cls, fn);
+
+exit:
+    return return_value;
+}
 
 PyDoc_STRVAR(_asyncio_Future_cancel__doc__,
 "cancel($self, /, msg=None)\n"
@@ -236,13 +345,14 @@ PyDoc_STRVAR(_asyncio_Future_cancel__doc__,
 "return True.");
 
 #define _ASYNCIO_FUTURE_CANCEL_METHODDEF    \
-    {"cancel", _PyCFunction_CAST(_asyncio_Future_cancel), METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_cancel__doc__},
+    {"cancel", _PyCFunction_CAST(_asyncio_Future_cancel), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_cancel__doc__},
 
 static PyObject *
-_asyncio_Future_cancel_impl(FutureObj *self, PyObject *msg);
+_asyncio_Future_cancel_impl(FutureObj *self, PyTypeObject *cls,
+                            PyObject *msg);
 
 static PyObject *
-_asyncio_Future_cancel(FutureObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_asyncio_Future_cancel(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
@@ -283,7 +393,7 @@ _asyncio_Future_cancel(FutureObj *self, PyObject *const *args, Py_ssize_t nargs,
     }
     msg = args[0];
 skip_optional_pos:
-    return_value = _asyncio_Future_cancel_impl(self, msg);
+    return_value = _asyncio_Future_cancel_impl(self, cls, msg);
 
 exit:
     return return_value;
@@ -335,15 +445,19 @@ PyDoc_STRVAR(_asyncio_Future_get_loop__doc__,
 "Return the event loop the Future is bound to.");
 
 #define _ASYNCIO_FUTURE_GET_LOOP_METHODDEF    \
-    {"get_loop", (PyCFunction)_asyncio_Future_get_loop, METH_NOARGS, _asyncio_Future_get_loop__doc__},
+    {"get_loop", _PyCFunction_CAST(_asyncio_Future_get_loop), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_get_loop__doc__},
 
 static PyObject *
-_asyncio_Future_get_loop_impl(FutureObj *self);
+_asyncio_Future_get_loop_impl(FutureObj *self, PyTypeObject *cls);
 
 static PyObject *
-_asyncio_Future_get_loop(FutureObj *self, PyObject *Py_UNUSED(ignored))
+_asyncio_Future_get_loop(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
 {
-    return _asyncio_Future_get_loop_impl(self);
+    if (nargs) {
+        PyErr_SetString(PyExc_TypeError, "get_loop() takes no arguments");
+        return NULL;
+    }
+    return _asyncio_Future_get_loop_impl(self, cls);
 }
 
 PyDoc_STRVAR(_asyncio_Future__make_cancelled_error__doc__,
@@ -612,13 +726,14 @@ PyDoc_STRVAR(_asyncio_Task_get_stack__doc__,
 "returned for a suspended coroutine.");
 
 #define _ASYNCIO_TASK_GET_STACK_METHODDEF    \
-    {"get_stack", _PyCFunction_CAST(_asyncio_Task_get_stack), METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
+    {"get_stack", _PyCFunction_CAST(_asyncio_Task_get_stack), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
 
 static PyObject *
-_asyncio_Task_get_stack_impl(TaskObj *self, PyObject *limit);
+_asyncio_Task_get_stack_impl(TaskObj *self, PyTypeObject *cls,
+                             PyObject *limit);
 
 static PyObject *
-_asyncio_Task_get_stack(TaskObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_asyncio_Task_get_stack(TaskObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
@@ -659,7 +774,7 @@ _asyncio_Task_get_stack(TaskObj *self, PyObject *const *args, Py_ssize_t nargs,
     }
     limit = args[0];
 skip_optional_kwonly:
-    return_value = _asyncio_Task_get_stack_impl(self, limit);
+    return_value = _asyncio_Task_get_stack_impl(self, cls, limit);
 
 exit:
     return return_value;
@@ -678,14 +793,14 @@ PyDoc_STRVAR(_asyncio_Task_print_stack__doc__,
 "to sys.stderr.");
 
 #define _ASYNCIO_TASK_PRINT_STACK_METHODDEF    \
-    {"print_stack", _PyCFunction_CAST(_asyncio_Task_print_stack), METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
+    {"print_stack", _PyCFunction_CAST(_asyncio_Task_print_stack), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
 
 static PyObject *
-_asyncio_Task_print_stack_impl(TaskObj *self, PyObject *limit,
-                               PyObject *file);
+_asyncio_Task_print_stack_impl(TaskObj *self, PyTypeObject *cls,
+                               PyObject *limit, PyObject *file);
 
 static PyObject *
-_asyncio_Task_print_stack(TaskObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_asyncio_Task_print_stack(TaskObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
@@ -733,7 +848,7 @@ _asyncio_Task_print_stack(TaskObj *self, PyObject *const *args, Py_ssize_t nargs
     }
     file = args[1];
 skip_optional_kwonly:
-    return_value = _asyncio_Task_print_stack_impl(self, limit, file);
+    return_value = _asyncio_Task_print_stack_impl(self, cls, limit, file);
 
 exit:
     return return_value;
@@ -1189,4 +1304,4 @@ _asyncio__leave_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=f117b2246eaf7a55 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=550bc6603df89ed9 input=a9049054013a1b77]*/