bpo-38787: C API for module state access from extension methods (PEP 573) (GH-19936)
Module C state is now accessible from C-defined heap type methods (PEP 573).
Patch by Marcel Plch and Petr Viktorin.
Co-authored-by: Marcel Plch <mplch@redhat.com>
Co-authored-by: Victor Stinner <vstinner@python.org>
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index 572baa5..c9754a1 100644
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -127,7 +127,11 @@
((PyTypeObject *)type)->tp_name);
return NULL;
}
- return PyCFunction_NewEx(descr->d_method, type, NULL);
+ PyTypeObject *cls = NULL;
+ if (descr->d_method->ml_flags & METH_METHOD) {
+ cls = descr->d_common.d_type;
+ }
+ return PyCMethod_New(descr->d_method, type, NULL, cls);
}
static PyObject *
@@ -137,7 +141,19 @@
if (descr_check((PyDescrObject *)descr, obj, &res))
return res;
- return PyCFunction_NewEx(descr->d_method, obj, NULL);
+ if (descr->d_method->ml_flags & METH_METHOD) {
+ if (PyType_Check(type)) {
+ return PyCMethod_New(descr->d_method, obj, NULL, descr->d_common.d_type);
+ } else {
+ PyErr_Format(PyExc_TypeError,
+ "descriptor '%V' needs a type, not '%s', as arg 2",
+ descr_name((PyDescrObject *)descr),
+ Py_TYPE(type)->tp_name);
+ return NULL;
+ }
+ } else {
+ return PyCFunction_NewEx(descr->d_method, obj, NULL);
+ }
}
static PyObject *
@@ -336,6 +352,27 @@
}
static PyObject *
+method_vectorcall_FASTCALL_KEYWORDS_METHOD(
+ PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+ PyThreadState *tstate = _PyThreadState_GET();
+ Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+ if (method_check_args(func, args, nargs, NULL)) {
+ return NULL;
+ }
+ NULL;
+ PyCMethod meth = (PyCMethod) method_enter_call(tstate, func);
+ if (meth == NULL) {
+ return NULL;
+ }
+ PyObject *result = meth(args[0],
+ ((PyMethodDescrObject *)func)->d_common.d_type,
+ args+1, nargs-1, kwnames);
+ Py_LeaveRecursiveCall();
+ return result;
+}
+
+static PyObject *
method_vectorcall_FASTCALL(
PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
{
@@ -868,7 +905,8 @@
{
/* Figure out correct vectorcall function to use */
vectorcallfunc vectorcall;
- switch (method->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS))
+ switch (method->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS |
+ METH_O | METH_KEYWORDS | METH_METHOD))
{
case METH_VARARGS:
vectorcall = method_vectorcall_VARARGS;
@@ -888,6 +926,9 @@
case METH_O:
vectorcall = method_vectorcall_O;
break;
+ case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+ vectorcall = method_vectorcall_FASTCALL_KEYWORDS_METHOD;
+ break;
default:
PyErr_Format(PyExc_SystemError,
"%s() method: bad call flags", method->ml_name);
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index 20eba6f..5659f21 100644
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -10,12 +10,16 @@
/* undefine macro trampoline to PyCFunction_NewEx */
#undef PyCFunction_New
+/* undefine macro trampoline to PyCMethod_New */
+#undef PyCFunction_NewEx
/* Forward declarations */
static PyObject * cfunction_vectorcall_FASTCALL(
PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
static PyObject * cfunction_vectorcall_FASTCALL_KEYWORDS(
PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * cfunction_vectorcall_FASTCALL_KEYWORDS_METHOD(
+ PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
static PyObject * cfunction_vectorcall_NOARGS(
PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
static PyObject * cfunction_vectorcall_O(
@@ -33,9 +37,16 @@
PyObject *
PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
{
+ return PyCMethod_New(ml, self, module, NULL);
+}
+
+PyObject *
+PyCMethod_New(PyMethodDef *ml, PyObject *self, PyObject *module, PyTypeObject *cls)
+{
/* Figure out correct vectorcall function to use */
vectorcallfunc vectorcall;
- switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS))
+ switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS |
+ METH_O | METH_KEYWORDS | METH_METHOD))
{
case METH_VARARGS:
case METH_VARARGS | METH_KEYWORDS:
@@ -55,17 +66,44 @@
case METH_O:
vectorcall = cfunction_vectorcall_O;
break;
+ case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+ vectorcall = cfunction_vectorcall_FASTCALL_KEYWORDS_METHOD;
+ break;
default:
PyErr_Format(PyExc_SystemError,
"%s() method: bad call flags", ml->ml_name);
return NULL;
}
- PyCFunctionObject *op =
- PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
- if (op == NULL) {
- return NULL;
+ PyCFunctionObject *op = NULL;
+
+ if (ml->ml_flags & METH_METHOD) {
+ if (!cls) {
+ PyErr_SetString(PyExc_SystemError,
+ "attempting to create PyCMethod with a METH_METHOD "
+ "flag but no class");
+ return NULL;
+ }
+ PyCMethodObject *om = PyObject_GC_New(PyCMethodObject, &PyCMethod_Type);
+ if (om == NULL) {
+ return NULL;
+ }
+ Py_INCREF(cls);
+ om->mm_class = cls;
+ op = (PyCFunctionObject *)om;
+ } else {
+ if (cls) {
+ PyErr_SetString(PyExc_SystemError,
+ "attempting to create PyCFunction with class "
+ "but no METH_METHOD flag");
+ return NULL;
+ }
+ op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
+ if (op == NULL) {
+ return NULL;
+ }
}
+
op->m_weakreflist = NULL;
op->m_ml = ml;
Py_XINCREF(self);
@@ -107,6 +145,16 @@
return PyCFunction_GET_FLAGS(op);
}
+PyTypeObject *
+PyCMethod_GetClass(PyObject *op)
+{
+ if (!PyCFunction_Check(op)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ return PyCFunction_GET_CLASS(op);
+}
+
/* Methods (the standard built-in methods, that is) */
static void
@@ -118,6 +166,7 @@
}
Py_XDECREF(m->m_self);
Py_XDECREF(m->m_module);
+ Py_XDECREF(PyCFunction_GET_CLASS(m));
PyObject_GC_Del(m);
}
@@ -196,6 +245,7 @@
{
Py_VISIT(m->m_self);
Py_VISIT(m->m_module);
+ Py_VISIT(PyCFunction_GET_CLASS(m));
return 0;
}
@@ -314,6 +364,13 @@
0, /* tp_dict */
};
+PyTypeObject PyCMethod_Type = {
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+ .tp_name = "builtin_method",
+ .tp_basicsize = sizeof(PyCMethodObject),
+ .tp_base = &PyCFunction_Type,
+};
+
/* Vectorcall functions for each of the PyCFunction calling conventions,
* except for METH_VARARGS (possibly combined with METH_KEYWORDS) which
* doesn't use vectorcall.
@@ -386,6 +443,22 @@
}
static PyObject *
+cfunction_vectorcall_FASTCALL_KEYWORDS_METHOD(
+ PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+ PyThreadState *tstate = _PyThreadState_GET();
+ PyTypeObject *cls = PyCFunction_GET_CLASS(func);
+ Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+ PyCMethod meth = (PyCMethod)cfunction_enter_call(tstate, func);
+ if (meth == NULL) {
+ return NULL;
+ }
+ PyObject *result = meth(PyCFunction_GET_SELF(func), cls, args, nargs, kwnames);
+ _Py_LeaveRecursiveCall(tstate);
+ return result;
+}
+
+static PyObject *
cfunction_vectorcall_NOARGS(
PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
{
diff --git a/Objects/object.c b/Objects/object.c
index 75ea92a..623ee52 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -1789,6 +1789,7 @@
INIT_TYPE(&PyCode_Type, "code");
INIT_TYPE(&PyFrame_Type, "frame");
INIT_TYPE(&PyCFunction_Type, "builtin function");
+ INIT_TYPE(&PyCMethod_Type, "builtin method");
INIT_TYPE(&PyMethod_Type, "method");
INIT_TYPE(&PyFunction_Type, "function");
INIT_TYPE(&PyDictProxy_Type, "dict proxy");
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 0d5600b..525f5ac 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -2708,6 +2708,9 @@
if (qualname != NULL && _PyDict_DelItemId(dict, &PyId___qualname__) < 0)
goto error;
+ /* Set ht_module */
+ et->ht_module = NULL;
+
/* Set tp_doc to a copy of dict['__doc__'], if the latter is there
and is a string. The __doc__ accessor will first look for tp_doc;
if that fails, it will still look into __dict__.
@@ -2940,6 +2943,12 @@
PyObject *
PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
{
+ return PyType_FromModuleAndSpec(NULL, spec, bases);
+}
+
+PyObject *
+PyType_FromModuleAndSpec(PyObject *module, PyType_Spec *spec, PyObject *bases)
+{
PyHeapTypeObject *res;
PyObject *modname;
PyTypeObject *type, *base;
@@ -2998,6 +3007,9 @@
Py_INCREF(res->ht_qualname);
type->tp_name = spec->name;
+ Py_XINCREF(module);
+ res->ht_module = module;
+
/* Adjust for empty tuple bases */
if (!bases) {
base = &PyBaseObject_Type;
@@ -3176,6 +3188,40 @@
return *(void**)(((char*)type) + slotoffsets[slot]);
}
+PyObject *
+PyType_GetModule(PyTypeObject *type)
+{
+ assert(PyType_Check(type));
+ if (!_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "PyType_GetModule: Type '%s' is not a heap type",
+ type->tp_name);
+ return NULL;
+ }
+
+ PyHeapTypeObject* et = (PyHeapTypeObject*)type;
+ if (!et->ht_module) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "PyType_GetModule: Type '%s' has no associated module",
+ type->tp_name);
+ return NULL;
+ }
+ return et->ht_module;
+
+}
+
+void *
+PyType_GetModuleState(PyTypeObject *type)
+{
+ PyObject *m = PyType_GetModule(type);
+ if (m == NULL) {
+ return NULL;
+ }
+ return PyModule_GetState(m);
+}
+
/* Internal API to look for a name through the MRO, bypassing the method cache.
This returns a borrowed reference, and might set an exception.
'error' is set to: -1: error with exception; 1: error without exception; 0: ok */
@@ -3503,8 +3549,10 @@
Py_XDECREF(et->ht_name);
Py_XDECREF(et->ht_qualname);
Py_XDECREF(et->ht_slots);
- if (et->ht_cached_keys)
+ if (et->ht_cached_keys) {
_PyDictKeys_DecRef(et->ht_cached_keys);
+ }
+ Py_XDECREF(et->ht_module);
Py_TYPE(type)->tp_free((PyObject *)type);
}
@@ -3694,6 +3742,7 @@
Py_VISIT(type->tp_mro);
Py_VISIT(type->tp_bases);
Py_VISIT(type->tp_base);
+ Py_VISIT(((PyHeapTypeObject *)type)->ht_module);
/* There's no need to visit type->tp_subclasses or
((PyHeapTypeObject *)type)->ht_slots, because they can't be involved
@@ -3715,10 +3764,13 @@
the dict, so that other objects caught in a reference cycle
don't start calling destroyed methods.
- Otherwise, the only field we need to clear is tp_mro, which is
+ Otherwise, the we need to clear tp_mro, which is
part of a hard cycle (its first element is the class itself) that
won't be broken otherwise (it's a tuple and tuples don't have a
- tp_clear handler). None of the other fields need to be
+ tp_clear handler).
+ We also need to clear ht_module, if present: the module usually holds a
+ reference to its class. None of the other fields need to be
+
cleared, and here's why:
tp_cache:
@@ -3743,8 +3795,11 @@
((PyHeapTypeObject *)type)->ht_cached_keys = NULL;
_PyDictKeys_DecRef(cached_keys);
}
- if (type->tp_dict)
+ if (type->tp_dict) {
PyDict_Clear(type->tp_dict);
+ }
+ Py_CLEAR(((PyHeapTypeObject *)type)->ht_module);
+
Py_CLEAR(type->tp_mro);
return 0;