#include "Python.h"

#include "pycore_code.h" // _PyCode_VerifyStateless()

#include "pycore_dict.h" // _Py_INCREF_DICT()

#include "pycore_function.h" // _PyFunction_Vectorcall

#include "pycore_long.h" // _PyLong_GetOne()

#include "pycore_modsupport.h" // _PyArg_NoKeywords()

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_pyerrors.h" // _PyErr_Occurred()

#include "pycore_setobject.h" // _PySet_NextEntry()

#include "pycore_stats.h"

#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS()

static const char *

func_event_name(PyFunction_WatchEvent event) {

switch (event) {

#define CASE(op) \

case PyFunction_EVENT_##op: \

return "PyFunction_EVENT_" #op;

PY_FOREACH_FUNC_EVENT(CASE)

#undef CASE

}

Py_UNREACHABLE();

}

static void

notify_func_watchers(PyInterpreterState *interp, PyFunction_WatchEvent event,

PyFunctionObject *func, PyObject *new_value)

{

uint8_t bits = interp->active_func_watchers;

int i = 0;

while (bits) {

assert(i < FUNC_MAX_WATCHERS);

if (bits & 1) {

PyFunction_WatchCallback cb = interp->func_watchers[i];

// callback must be non-null if the watcher bit is set

assert(cb != NULL);

if (cb(event, func, new_value) < 0) {

PyErr_FormatUnraisable(

"Exception ignored in %s watcher callback for function %U at %p",

func_event_name(event), func->func_qualname, func);

}

}

i++;

bits >>= 1;

}

}

static inline void

handle_func_event(PyFunction_WatchEvent event, PyFunctionObject *func,

PyObject *new_value)

{

assert(Py_REFCNT(func) > 0);

PyInterpreterState *interp = _PyInterpreterState_GET();

assert(interp->_initialized);

if (interp->active_func_watchers) {

notify_func_watchers(interp, event, func, new_value);

}

switch (event) {

case PyFunction_EVENT_MODIFY_CODE:

case PyFunction_EVENT_MODIFY_DEFAULTS:

case PyFunction_EVENT_MODIFY_KWDEFAULTS:

RARE_EVENT_INTERP_INC(interp, func_modification);

break;

default:

break;

}

}

PyFunction_AddWatcher(PyFunction_WatchCallback callback)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

assert(interp->_initialized);

for (int i = 0; i < FUNC_MAX_WATCHERS; i++) {

if (interp->func_watchers[i] == NULL) {

interp->func_watchers[i] = callback;

interp->active_func_watchers |= (1 << i);

return i;

}

}

PyErr_SetString(PyExc_RuntimeError, "no more func watcher IDs available");

return -1;

}

PyFunction_ClearWatcher(int watcher_id)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (watcher_id < 0 || watcher_id >= FUNC_MAX_WATCHERS) {

PyErr_Format(PyExc_ValueError, "invalid func watcher ID %d",

watcher_id);

return -1;

}

if (!interp->func_watchers[watcher_id]) {

PyErr_Format(PyExc_ValueError, "no func watcher set for ID %d",

watcher_id);

return -1;

}

interp->func_watchers[watcher_id] = NULL;

interp->active_func_watchers &= ~(1 << watcher_id);

return 0;

}

PyFunctionObject *

_PyFunction_FromConstructor(PyFrameConstructor *constr)

{

PyObject *module;

if (PyDict_GetItemRef(constr->fc_globals, &_Py_ID(__name__), &module) < 0) {

return NULL;

}

PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);

if (op == NULL) {

Py_XDECREF(module);

return NULL;

}

_Py_INCREF_DICT(constr->fc_globals);

op->func_globals = constr->fc_globals;

_Py_INCREF_BUILTINS(constr->fc_builtins);

op->func_builtins = constr->fc_builtins;

op->func_name = Py_NewRef(constr->fc_name);

op->func_qualname = Py_NewRef(constr->fc_qualname);

_Py_INCREF_CODE((PyCodeObject *)constr->fc_code);

op->func_code = constr->fc_code;

op->func_defaults = Py_XNewRef(constr->fc_defaults);

op->func_kwdefaults = Py_XNewRef(constr->fc_kwdefaults);

op->func_closure = Py_XNewRef(constr->fc_closure);

op->func_doc = Py_NewRef(Py_None);

op->func_dict = NULL;

op->func_weakreflist = NULL;

op->func_module = module;

op->func_annotations = NULL;

op->func_annotate = NULL;

op->func_typeparams = NULL;

op->vectorcall = _PyFunction_Vectorcall;

op->func_version = FUNC_VERSION_UNSET;

// NOTE: functions created via FrameConstructor do not use deferred

// reference counting because they are typically not part of cycles

// nor accessed by multiple threads.

_PyObject_GC_TRACK(op);

handle_func_event(PyFunction_EVENT_CREATE, op, NULL);

return op;

}

PyObject *

PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname)

{

assert(globals != NULL);

assert(PyDict_Check(globals));

_Py_INCREF_DICT(globals);

PyCodeObject *code_obj = (PyCodeObject *)code;

_Py_INCREF_CODE(code_obj);

assert(code_obj->co_name != NULL);

PyObject *name = Py_NewRef(code_obj->co_name);

if (!qualname) {

qualname = code_obj->co_qualname;

}

assert(qualname != NULL);

Py_INCREF(qualname);

PyObject *consts = code_obj->co_consts;

assert(PyTuple_Check(consts));

PyObject *doc;

if (code_obj->co_flags & CO_HAS_DOCSTRING) {

assert(PyTuple_Size(consts) >= 1);

doc = PyTuple_GetItem(consts, 0);

if (!PyUnicode_Check(doc)) {

doc = Py_None;

}

}

else {

doc = Py_None;

}

Py_INCREF(doc);

// __module__: Use globals['__name__'] if it exists, or NULL.

PyObject *module;

PyObject *builtins = NULL;

if (PyDict_GetItemRef(globals, &_Py_ID(__name__), &module) < 0) {

goto error;

}

builtins = _PyDict_LoadBuiltinsFromGlobals(globals);

if (builtins == NULL) {

goto error;

}

PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);

if (op == NULL) {

goto error;

}

/* Note: No failures from this point on, since func_dealloc() does not

op->func_globals = globals;

op->func_builtins = builtins;

op->func_name = name;

op->func_qualname = qualname;

op->func_code = (PyObject*)code_obj;

op->func_defaults = NULL; // No default positional arguments

op->func_kwdefaults = NULL; // No default keyword arguments

op->func_closure = NULL;

op->func_doc = doc;

op->func_dict = NULL;

op->func_weakreflist = NULL;

op->func_module = module;

op->func_annotations = NULL;

op->func_annotate = NULL;

op->func_typeparams = NULL;

op->vectorcall = _PyFunction_Vectorcall;

op->func_version = FUNC_VERSION_UNSET;

if (((code_obj->co_flags & CO_NESTED) == 0) ||

(code_obj->co_flags & CO_METHOD)) {

// Use deferred reference counting for top-level functions, but not

// nested functions because they are more likely to capture variables,

// which makes prompt deallocation more important.

//

// Nested methods (functions defined in class scope) are also deferred,

// since they will likely be cleaned up by GC anyway.

_PyObject_SetDeferredRefcount((PyObject *)op);

}

_PyObject_GC_TRACK(op);

handle_func_event(PyFunction_EVENT_CREATE, op, NULL);

return (PyObject *)op;

error:

Py_DECREF(globals);

Py_DECREF(code_obj);

Py_DECREF(name);

Py_DECREF(qualname);

Py_DECREF(doc);

Py_XDECREF(module);

Py_XDECREF(builtins);

return NULL;

}

#ifndef Py_GIL_DISABLED

static inline struct _func_version_cache_item *

get_cache_item(PyInterpreterState *interp, uint32_t version)

{

return interp->func_state.func_version_cache +

(version % FUNC_VERSION_CACHE_SIZE);

}

_PyFunction_SetVersion(PyFunctionObject *func, uint32_t version)

{

assert(func->func_version == FUNC_VERSION_UNSET);

assert(version >= FUNC_VERSION_FIRST_VALID);

// This should only be called from MAKE_FUNCTION. No code is specialized

// based on the version, so we do not need to stop the world to set it.

func->func_version = version;

#ifndef Py_GIL_DISABLED

PyInterpreterState *interp = _PyInterpreterState_GET();

struct _func_version_cache_item *slot = get_cache_item(interp, version);

slot->func = func;

slot->code = func->func_code;

}

static void

func_clear_version(PyInterpreterState *interp, PyFunctionObject *func)

{

if (func->func_version < FUNC_VERSION_FIRST_VALID) {

// Version was never set or has already been cleared.

return;

}

#ifndef Py_GIL_DISABLED

struct _func_version_cache_item *slot =

get_cache_item(interp, func->func_version);

if (slot->func == func) {

slot->func = NULL;

// Leave slot->code alone, there may be use for it.

}

func->func_version = FUNC_VERSION_CLEARED;

}

static void

_PyFunction_ClearVersion(PyFunctionObject *func)

{

if (func->func_version < FUNC_VERSION_FIRST_VALID) {

// Version was never set or has already been cleared.

return;

}

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyEval_StopTheWorld(interp);

func_clear_version(interp, func);

_PyEval_StartTheWorld(interp);

}

_PyFunction_ClearCodeByVersion(uint32_t version)

{

#ifndef Py_GIL_DISABLED

PyInterpreterState *interp = _PyInterpreterState_GET();

struct _func_version_cache_item *slot = get_cache_item(interp, version);

if (slot->code) {

assert(PyCode_Check(slot->code));

PyCodeObject *code = (PyCodeObject *)slot->code;

if (code->co_version == version) {

slot->code = NULL;

slot->func = NULL;

}

}

}

PyFunctionObject *

_PyFunction_LookupByVersion(uint32_t version, PyObject **p_code)

{

#ifdef Py_GIL_DISABLED

return NULL;

PyInterpreterState *interp = _PyInterpreterState_GET();

struct _func_version_cache_item *slot = get_cache_item(interp, version);

if (slot->code) {

assert(PyCode_Check(slot->code));

PyCodeObject *code = (PyCodeObject *)slot->code;

if (code->co_version == version) {

*p_code = slot->code;

}

}

else {

*p_code = NULL;

}

if (slot->func && slot->func->func_version == version) {

assert(slot->func->func_code == slot->code);

return slot->func;

}

return NULL;

}

_PyFunction_GetVersionForCurrentState(PyFunctionObject *func)

{

return func->func_version;

}

PyObject *

PyFunction_New(PyObject *code, PyObject *globals)

{

return PyFunction_NewWithQualName(code, globals, NULL);

}

PyObject *

PyFunction_GetCode(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_code;

}

PyObject *

PyFunction_GetGlobals(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_globals;

}

PyObject *

PyFunction_GetModule(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_module;

}

PyObject *

PyFunction_GetDefaults(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_defaults;

}

PyFunction_SetDefaults(PyObject *op, PyObject *defaults)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (defaults == Py_None)

defaults = NULL;

else if (defaults && PyTuple_Check(defaults)) {

Py_INCREF(defaults);

}

else {

PyErr_SetString(PyExc_SystemError, "non-tuple default args");

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_DEFAULTS,

(PyFunctionObject *) op, defaults);

_PyFunction_ClearVersion((PyFunctionObject *)op);

Py_XSETREF(((PyFunctionObject *)op)->func_defaults, defaults);

return 0;

}

PyFunction_SetVectorcall(PyFunctionObject *func, vectorcallfunc vectorcall)

{

assert(func != NULL);

_PyFunction_ClearVersion(func);

func->vectorcall = vectorcall;

}

PyObject *

PyFunction_GetKwDefaults(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_kwdefaults;

}

PyFunction_SetKwDefaults(PyObject *op, PyObject *defaults)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (defaults == Py_None)

defaults = NULL;

else if (defaults && PyDict_Check(defaults)) {

Py_INCREF(defaults);

}

else {

PyErr_SetString(PyExc_SystemError,

"non-dict keyword only default args");

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_KWDEFAULTS,

(PyFunctionObject *) op, defaults);

_PyFunction_ClearVersion((PyFunctionObject *)op);

Py_XSETREF(((PyFunctionObject *)op)->func_kwdefaults, defaults);

return 0;

}

PyObject *

PyFunction_GetClosure(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_closure;

}

PyFunction_SetClosure(PyObject *op, PyObject *closure)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (closure == Py_None)

closure = NULL;

else if (PyTuple_Check(closure)) {

Py_INCREF(closure);

}

else {

PyErr_Format(PyExc_SystemError,

"expected tuple for closure, got '%.100s'",

Py_TYPE(closure)->tp_name);

return -1;

}

_PyFunction_ClearVersion((PyFunctionObject *)op);

Py_XSETREF(((PyFunctionObject *)op)->func_closure, closure);

return 0;

}

static PyObject *

func_get_annotation_dict(PyFunctionObject *op)

{

if (op->func_annotations == NULL) {

if (op->func_annotate == NULL || !PyCallable_Check(op->func_annotate)) {

Py_RETURN_NONE;

}

PyObject *one = _PyLong_GetOne();

PyObject *ann_dict = _PyObject_CallOneArg(op->func_annotate, one);

if (ann_dict == NULL) {

return NULL;

}

if (!PyDict_Check(ann_dict)) {

PyErr_Format(PyExc_TypeError, "__annotate__ returned non-dict of type '%.100s'",

Py_TYPE(ann_dict)->tp_name);

Py_DECREF(ann_dict);

return NULL;

}

Py_XSETREF(op->func_annotations, ann_dict);

return ann_dict;

}

if (PyTuple_CheckExact(op->func_annotations)) {

PyObject *ann_tuple = op->func_annotations;

PyObject *ann_dict = PyDict_New();

if (ann_dict == NULL) {

return NULL;

}

assert(PyTuple_GET_SIZE(ann_tuple) % 2 == 0);

for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(ann_tuple); i += 2) {

int err = PyDict_SetItem(ann_dict,

PyTuple_GET_ITEM(ann_tuple, i),

PyTuple_GET_ITEM(ann_tuple, i + 1));

if (err < 0) {

Py_DECREF(ann_dict);

return NULL;

}

}

Py_SETREF(op->func_annotations, ann_dict);

}

assert(PyDict_Check(op->func_annotations));

return op->func_annotations;

}

PyObject *

PyFunction_GetAnnotations(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return func_get_annotation_dict((PyFunctionObject *)op);

}

PyFunction_SetAnnotations(PyObject *op, PyObject *annotations)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (annotations == Py_None)

annotations = NULL;

else if (annotations && PyDict_Check(annotations)) {

Py_INCREF(annotations);

}

else {

PyErr_SetString(PyExc_SystemError,

"non-dict annotations");

return -1;

}

PyFunctionObject *func = (PyFunctionObject *)op;

Py_XSETREF(func->func_annotations, annotations);

Py_CLEAR(func->func_annotate);

return 0;

}

#define OFF(x) offsetof(PyFunctionObject, x)

static PyMemberDef func_memberlist[] = {

{"__closure__", _Py_T_OBJECT, OFF(func_closure), Py_READONLY},

{"__doc__", _Py_T_OBJECT, OFF(func_doc), 0},

{"__globals__", _Py_T_OBJECT, OFF(func_globals), Py_READONLY},

{"__module__", _Py_T_OBJECT, OFF(func_module), 0},

{"__builtins__", _Py_T_OBJECT, OFF(func_builtins), Py_READONLY},

{NULL} /* Sentinel */

};

#include "clinic/funcobject.c.h"

static PyObject *

func_get_code(PyObject *self, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

if (PySys_Audit("object.__getattr__", "Os", op, "__code__") < 0) {

return NULL;

}

return Py_NewRef(op->func_code);

}

static int

func_set_code(PyObject *self, PyObject *value, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

/* Not legal to del f.func_code or to set it to anything

if (value == NULL || !PyCode_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__code__ must be set to a code object");

return -1;

}

if (PySys_Audit("object.__setattr__", "OsO",

op, "__code__", value) < 0) {

return -1;

}

int nfree = ((PyCodeObject *)value)->co_nfreevars;

Py_ssize_t nclosure = (op->func_closure == NULL ? 0 :

PyTuple_GET_SIZE(op->func_closure));

if (nclosure != nfree) {

PyErr_Format(PyExc_ValueError,

"%U() requires a code object with %zd free vars,"

" not %d",

op->func_name,

nclosure, nfree);

return -1;

}

PyObject *func_code = PyFunction_GET_CODE(op);

int old_flags = ((PyCodeObject *)func_code)->co_flags;

int new_flags = ((PyCodeObject *)value)->co_flags;

int mask = CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR;

if ((old_flags & mask) != (new_flags & mask)) {

if (PyErr_Warn(PyExc_DeprecationWarning,

"Assigning a code object of non-matching type is deprecated "

"(e.g., from a generator to a plain function)") < 0)

{

return -1;

}

}

handle_func_event(PyFunction_EVENT_MODIFY_CODE, op, value);

_PyFunction_ClearVersion(op);

Py_XSETREF(op->func_code, Py_NewRef(value));

return 0;

}

static PyObject *

func_get_name(PyObject *self, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

return Py_NewRef(op->func_name);

}

static int

func_set_name(PyObject *self, PyObject *value, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

/* Not legal to del f.func_name or to set it to anything

if (value == NULL || !PyUnicode_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__name__ must be set to a string object");

return -1;

}

Py_XSETREF(op->func_name, Py_NewRef(value));

return 0;

}

static PyObject *

func_get_qualname(PyObject *self, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

return Py_NewRef(op->func_qualname);

}

static int

func_set_qualname(PyObject *self, PyObject *value, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

/* Not legal to del f.__qualname__ or to set it to anything

if (value == NULL || !PyUnicode_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__qualname__ must be set to a string object");

return -1;

}

Py_XSETREF(op->func_qualname, Py_NewRef(value));

return 0;

}

static PyObject *

func_get_defaults(PyObject *self, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

if (PySys_Audit("object.__getattr__", "Os", op, "__defaults__") < 0) {

return NULL;

}

if (op->func_defaults == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(op->func_defaults);

}

static int

func_set_defaults(PyObject *self, PyObject *value, void *Py_UNUSED(ignored))

{

/* Legal to del f.func_defaults.

PyFunctionObject *op = _PyFunction_CAST(self);

if (value == Py_None)

value = NULL;

if (value != NULL && !PyTuple_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__defaults__ must be set to a tuple object");

return -1;

}

if (value) {

if (PySys_Audit("object.__setattr__", "OsO",

op, "__defaults__", value) < 0) {

return -1;

}

} else if (PySys_Audit("object.__delattr__", "Os",

op, "__defaults__") < 0) {

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_DEFAULTS, op, value);

_PyFunction_ClearVersion(op);

Py_XSETREF(op->func_defaults, Py_XNewRef(value));

return 0;

}

static PyObject *

func_get_kwdefaults(PyObject *self, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

if (PySys_Audit("object.__getattr__", "Os",

op, "__kwdefaults__") < 0) {

return NULL;

}

if (op->func_kwdefaults == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(op->func_kwdefaults);

}

static int

func_set_kwdefaults(PyObject *self, PyObject *value, void *Py_UNUSED(ignored))

{

PyFunctionObject *op = _PyFunction_CAST(self);

if (value == Py_None)

value = NULL;

/* Legal to del f.func_kwdefaults.

if (value != NULL && !PyDict_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__kwdefaults__ must be set to a dict object");

return -1;

}

if (value) {

if (PySys_Audit("object.__setattr__", "OsO",

op, "__kwdefaults__", value) < 0) {

return -1;

}

} else if (PySys_Audit("object.__delattr__", "Os",

op, "__kwdefaults__") < 0) {

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_KWDEFAULTS, op, value);

_PyFunction_ClearVersion(op);

Py_XSETREF(op->func_kwdefaults, Py_XNewRef(value));

return 0;

}

static PyObject *

function___annotate___get_impl(PyFunctionObject *self)

{

if (self->func_annotate == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->func_annotate);

}

static int

function___annotate___set_impl(PyFunctionObject *self, PyObject *value)

{

if (value == NULL) {

PyErr_SetString(PyExc_TypeError,

"__annotate__ cannot be deleted");

return -1;

}

if (Py_IsNone(value)) {

Py_XSETREF(self->func_annotate, value);

return 0;

}

else if (PyCallable_Check(value)) {

Py_XSETREF(self->func_annotate, Py_XNewRef(value));

Py_CLEAR(self->func_annotations);

return 0;

}

else {

PyErr_SetString(PyExc_TypeError,

"__annotate__ must be callable or None");

return -1;

}

}

static PyObject *

function___annotations___get_impl(PyFunctionObject *self)

{

PyObject *d = NULL;

if (self->func_annotations == NULL &&

(self->func_annotate == NULL || !PyCallable_Check(self->func_annotate))) {

self->func_annotations = PyDict_New();

if (self->func_annotations == NULL)

return NULL;

}

d = func_get_annotation_dict(self);

return Py_XNewRef(d);

}

static int

function___annotations___set_impl(PyFunctionObject *self, PyObject *value)

{

if (value == Py_None)

value = NULL;

/* Legal to del f.func_annotations.

if (value != NULL && !PyDict_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__annotations__ must be set to a dict object");

return -1;

}

Py_XSETREF(self->func_annotations, Py_XNewRef(value));

Py_CLEAR(self->func_annotate);

return 0;

}

static PyObject *

function___type_params___get_impl(PyFunctionObject *self)

{

if (self->func_typeparams == NULL) {

return PyTuple_New(0);

}

assert(PyTuple_Check(self->func_typeparams));

return Py_NewRef(self->func_typeparams);

}

static int

function___type_params___set_impl(PyFunctionObject *self, PyObject *value)

{

/* Not legal to del f.__type_params__ or to set it to anything

if (value == NULL || !PyTuple_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__type_params__ must be set to a tuple");

return -1;

}

Py_XSETREF(self->func_typeparams, Py_NewRef(value));

return 0;

}

PyObject *

_Py_set_function_type_params(PyThreadState *Py_UNUSED(ignored), PyObject *func,

PyObject *type_params)

{

assert(PyFunction_Check(func));

assert(PyTuple_Check(type_params));

PyFunctionObject *f = (PyFunctionObject *)func;

Py_XSETREF(f->func_typeparams, Py_NewRef(type_params));

return Py_NewRef(func);

}

static PyGetSetDef func_getsetlist[] = {

{"__code__", func_get_code, func_set_code},

{"__defaults__", func_get_defaults, func_set_defaults},

{"__kwdefaults__", func_get_kwdefaults, func_set_kwdefaults},

FUNCTION___ANNOTATIONS___GETSETDEF

FUNCTION___ANNOTATE___GETSETDEF

{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},

{"__name__", func_get_name, func_set_name},

{"__qualname__", func_get_qualname, func_set_qualname},

FUNCTION___TYPE_PARAMS___GETSETDEF

{NULL} /* Sentinel */

};