#include "Python.h"

#include "pycore_call.h"

#include "pycore_code.h" // CO_FAST_FREE

#include "pycore_compile.h" // _Py_Mangle()

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_moduleobject.h" // _PyModule_GetDef()

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

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

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_typeobject.h" // struct type_cache

#include "pycore_unionobject.h" // _Py_union_type_or

#include "pycore_frame.h" // _PyInterpreterFrame

#include "opcode.h" // MAKE_CELL

#include "structmember.h" // PyMemberDef

#include <ctype.h>

#include "clinic/typeobject.c.h"

#define MCACHE_MAX_ATTR_SIZE 100

#define MCACHE_HASH(version, name_hash) \

(((unsigned int)(version) ^ (unsigned int)(name_hash)) \

& ((1 << MCACHE_SIZE_EXP) - 1))

#define MCACHE_HASH_METHOD(type, name) \

MCACHE_HASH((type)->tp_version_tag, ((Py_ssize_t)(name)) >> 3)

#define MCACHE_CACHEABLE_NAME(name) \

PyUnicode_CheckExact(name) && \

PyUnicode_IS_READY(name) && \

(PyUnicode_GET_LENGTH(name) <= MCACHE_MAX_ATTR_SIZE)

static unsigned int next_version_tag = 1;

typedef struct PySlot_Offset {

short subslot_offset;

short slot_offset;

} PySlot_Offset;

static PyObject *

slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds);

static void

clear_slotdefs(void);

static PyObject *

lookup_maybe_method(PyObject *self, PyObject *attr, int *unbound);

static int

slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value);

static inline PyTypeObject * subclass_from_ref(PyObject *ref);

static const char *

find_signature(const char *name, const char *doc)

{

const char *dot;

size_t length;

if (!doc)

return NULL;

assert(name != NULL);

/* for dotted names like classes, only use the last component */

dot = strrchr(name, '.');

if (dot)

name = dot + 1;

length = strlen(name);

if (strncmp(doc, name, length))

return NULL;

doc += length;

if (*doc != '(')

return NULL;

return doc;

}

#define SIGNATURE_END_MARKER ")\n--\n\n"

#define SIGNATURE_END_MARKER_LENGTH 6

static const char *

skip_signature(const char *doc)

{

while (*doc) {

if ((*doc == *SIGNATURE_END_MARKER) &&

!strncmp(doc, SIGNATURE_END_MARKER, SIGNATURE_END_MARKER_LENGTH))

return doc + SIGNATURE_END_MARKER_LENGTH;

if ((*doc == '\n') && (doc[1] == '\n'))

return NULL;

doc++;

}

return NULL;

}

_PyType_CheckConsistency(PyTypeObject *type)

{

#define CHECK(expr) \

do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG((PyObject *)type, Py_STRINGIFY(expr)); } } while (0)

CHECK(!_PyObject_IsFreed((PyObject *)type));

if (!(type->tp_flags & Py_TPFLAGS_READY)) {

/* don't check static types before PyType_Ready() */

return 1;

}

CHECK(Py_REFCNT(type) >= 1);

CHECK(PyType_Check(type));

CHECK(!(type->tp_flags & Py_TPFLAGS_READYING));

CHECK(type->tp_dict != NULL);

if (type->tp_flags & Py_TPFLAGS_HAVE_GC) {

// bpo-44263: tp_traverse is required if Py_TPFLAGS_HAVE_GC is set.

// Note: tp_clear is optional.

CHECK(type->tp_traverse != NULL);

}

if (type->tp_flags & Py_TPFLAGS_DISALLOW_INSTANTIATION) {

CHECK(type->tp_new == NULL);

CHECK(PyDict_Contains(type->tp_dict, &_Py_ID(__new__)) == 0);

}

return 1;

#undef CHECK

}

static const char *

_PyType_DocWithoutSignature(const char *name, const char *internal_doc)

{

const char *doc = find_signature(name, internal_doc);

if (doc) {

doc = skip_signature(doc);

if (doc)

return doc;

}

return internal_doc;

}

PyObject *

_PyType_GetDocFromInternalDoc(const char *name, const char *internal_doc)

{

const char *doc = _PyType_DocWithoutSignature(name, internal_doc);

if (!doc || *doc == '\0') {

Py_RETURN_NONE;

}

return PyUnicode_FromString(doc);

}

PyObject *

_PyType_GetTextSignatureFromInternalDoc(const char *name, const char *internal_doc)

{

const char *start = find_signature(name, internal_doc);

const char *end;

if (start)

end = skip_signature(start);

else

end = NULL;

if (!end) {

Py_RETURN_NONE;

}

/* back "end" up until it points just past the final ')' */

end -= SIGNATURE_END_MARKER_LENGTH - 1;

assert((end - start) >= 2); /* should be "()" at least */

assert(end[-1] == ')');

assert(end[0] == '\n');

return PyUnicode_FromStringAndSize(start, end - start);

}

static struct type_cache*

get_type_cache(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return &interp->type_cache;

}

static void

type_cache_clear(struct type_cache *cache, PyObject *value)

{

for (Py_ssize_t i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {

struct type_cache_entry *entry = &cache->hashtable[i];

entry->version = 0;

Py_XSETREF(entry->name, _Py_XNewRef(value));

entry->value = NULL;

}

}

_PyType_InitCache(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->type_cache;

for (Py_ssize_t i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {

struct type_cache_entry *entry = &cache->hashtable[i];

assert(entry->name == NULL);

entry->version = 0;

// Set to None so _PyType_Lookup() can use Py_SETREF(),

// rather than using slower Py_XSETREF().

entry->name = Py_NewRef(Py_None);

entry->value = NULL;

}

}

static unsigned int

_PyType_ClearCache(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->type_cache;

#if MCACHE_STATS

size_t total = cache->hits + cache->collisions + cache->misses;

fprintf(stderr, "-- Method cache hits = %zd (%d%%)\n",

cache->hits, (int) (100.0 * cache->hits / total));

fprintf(stderr, "-- Method cache true misses = %zd (%d%%)\n",

cache->misses, (int) (100.0 * cache->misses / total));

fprintf(stderr, "-- Method cache collisions = %zd (%d%%)\n",

cache->collisions, (int) (100.0 * cache->collisions / total));

fprintf(stderr, "-- Method cache size = %zd KiB\n",

sizeof(cache->hashtable) / 1024);

// Set to None, rather than NULL, so _PyType_Lookup() can

// use Py_SETREF() rather than using slower Py_XSETREF().

type_cache_clear(cache, Py_None);

return next_version_tag - 1;

}

PyType_ClearCache(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return _PyType_ClearCache(interp);

}

_PyTypes_Fini(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->type_cache;

type_cache_clear(cache, NULL);

if (_Py_IsMainInterpreter(interp)) {

clear_slotdefs();

}

}

PyType_Modified(PyTypeObject *type)

{

/* Invalidate any cached data for the specified type and all

if (!_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {

return;

}

PyObject *subclasses = type->tp_subclasses;

if (subclasses != NULL) {

assert(PyDict_CheckExact(subclasses));

Py_ssize_t i = 0;

PyObject *ref;

while (PyDict_Next(subclasses, &i, NULL, &ref)) {

PyTypeObject *subclass = subclass_from_ref(ref); // borrowed

if (subclass == NULL) {

continue;

}

PyType_Modified(subclass);

}

}

type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;

type->tp_version_tag = 0; /* 0 is not a valid version tag */

}

static void

type_mro_modified(PyTypeObject *type, PyObject *bases) {

/*

Py_ssize_t i, n;

int custom = !Py_IS_TYPE(type, &PyType_Type);

int unbound;

if (custom) {

PyObject *mro_meth, *type_mro_meth;

mro_meth = lookup_maybe_method(

(PyObject *)type, &_Py_ID(mro), &unbound);

if (mro_meth == NULL) {

goto clear;

}

type_mro_meth = lookup_maybe_method(

(PyObject *)&PyType_Type, &_Py_ID(mro), &unbound);

if (type_mro_meth == NULL) {

Py_DECREF(mro_meth);

goto clear;

}

int custom_mro = (mro_meth != type_mro_meth);

Py_DECREF(mro_meth);

Py_DECREF(type_mro_meth);

if (custom_mro) {

goto clear;

}

}

n = PyTuple_GET_SIZE(bases);

for (i = 0; i < n; i++) {

PyObject *b = PyTuple_GET_ITEM(bases, i);

PyTypeObject *cls = _PyType_CAST(b);

if (!PyType_IsSubtype(type, cls)) {

goto clear;

}

}

return;

clear:

type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;

type->tp_version_tag = 0; /* 0 is not a valid version tag */

}

static int

assign_version_tag(struct type_cache *cache, PyTypeObject *type)

{

/* Ensure that the tp_version_tag is valid and set

if (_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {

return 1;

}

if (!_PyType_HasFeature(type, Py_TPFLAGS_READY)) {

return 0;

}

if (next_version_tag == 0) {

/* We have run out of version numbers */

return 0;

}

type->tp_version_tag = next_version_tag++;

assert (type->tp_version_tag != 0);

PyObject *bases = type->tp_bases;

Py_ssize_t n = PyTuple_GET_SIZE(bases);

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *b = PyTuple_GET_ITEM(bases, i);

if (!assign_version_tag(cache, _PyType_CAST(b)))

return 0;

}

type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;

return 1;

}

static PyMemberDef type_members[] = {

{"__basicsize__", T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),READONLY},

{"__itemsize__", T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), READONLY},

{"__flags__", T_ULONG, offsetof(PyTypeObject, tp_flags), READONLY},

{"__weakrefoffset__", T_PYSSIZET,

offsetof(PyTypeObject, tp_weaklistoffset), READONLY},

{"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY},

{"__dictoffset__", T_PYSSIZET,

offsetof(PyTypeObject, tp_dictoffset), READONLY},

{"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY},

{0}

};

static int

check_set_special_type_attr(PyTypeObject *type, PyObject *value, const char *name)

{

if (_PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE)) {

PyErr_Format(PyExc_TypeError,

"cannot set '%s' attribute of immutable type '%s'",

name, type->tp_name);

return 0;

}

if (!value) {

PyErr_Format(PyExc_TypeError,

"cannot delete '%s' attribute of immutable type '%s'",

name, type->tp_name);

return 0;

}

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

type, name, value) < 0) {

return 0;

}

return 1;

}

const char *

_PyType_Name(PyTypeObject *type)

{

assert(type->tp_name != NULL);

const char *s = strrchr(type->tp_name, '.');

if (s == NULL) {

s = type->tp_name;

}

else {

s++;

}

return s;

}

static PyObject *

type_name(PyTypeObject *type, void *context)

{

if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

PyHeapTypeObject* et = (PyHeapTypeObject*)type;

Py_INCREF(et->ht_name);

return et->ht_name;

}

else {

return PyUnicode_FromString(_PyType_Name(type));

}

}

static PyObject *

type_qualname(PyTypeObject *type, void *context)

{

if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

PyHeapTypeObject* et = (PyHeapTypeObject*)type;

Py_INCREF(et->ht_qualname);

return et->ht_qualname;

}

else {

return PyUnicode_FromString(_PyType_Name(type));

}

}

static int

type_set_name(PyTypeObject *type, PyObject *value, void *context)

{

const char *tp_name;

Py_ssize_t name_size;

if (!check_set_special_type_attr(type, value, "__name__"))

return -1;

if (!PyUnicode_Check(value)) {

PyErr_Format(PyExc_TypeError,

"can only assign string to %s.__name__, not '%s'",

type->tp_name, Py_TYPE(value)->tp_name);

return -1;

}

tp_name = PyUnicode_AsUTF8AndSize(value, &name_size);

if (tp_name == NULL)

return -1;

if (strlen(tp_name) != (size_t)name_size) {

PyErr_SetString(PyExc_ValueError,

"type name must not contain null characters");

return -1;

}

type->tp_name = tp_name;

Py_INCREF(value);

Py_SETREF(((PyHeapTypeObject*)type)->ht_name, value);

return 0;

}

static int

type_set_qualname(PyTypeObject *type, PyObject *value, void *context)

{

PyHeapTypeObject* et;

if (!check_set_special_type_attr(type, value, "__qualname__"))

return -1;

if (!PyUnicode_Check(value)) {

PyErr_Format(PyExc_TypeError,

"can only assign string to %s.__qualname__, not '%s'",

type->tp_name, Py_TYPE(value)->tp_name);

return -1;

}

et = (PyHeapTypeObject*)type;

Py_INCREF(value);

Py_SETREF(et->ht_qualname, value);

return 0;

}

static PyObject *

type_module(PyTypeObject *type, void *context)

{

PyObject *mod;

if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

mod = PyDict_GetItemWithError(type->tp_dict, &_Py_ID(__module__));

if (mod == NULL) {

if (!PyErr_Occurred()) {

PyErr_Format(PyExc_AttributeError, "__module__");

}

return NULL;

}

Py_INCREF(mod);

}

else {

const char *s = strrchr(type->tp_name, '.');

if (s != NULL) {

mod = PyUnicode_FromStringAndSize(

type->tp_name, (Py_ssize_t)(s - type->tp_name));

if (mod != NULL)

PyUnicode_InternInPlace(&mod);

}

else {

mod = &_Py_ID(builtins);

Py_INCREF(mod);

}

}

return mod;

}

static int

type_set_module(PyTypeObject *type, PyObject *value, void *context)

{

if (!check_set_special_type_attr(type, value, "__module__"))

return -1;

PyType_Modified(type);

return PyDict_SetItem(type->tp_dict, &_Py_ID(__module__), value);

}

static PyObject *

type_abstractmethods(PyTypeObject *type, void *context)

{

PyObject *mod = NULL;

/* type itself has an __abstractmethods__ descriptor (this). Don't return

if (type != &PyType_Type)

mod = PyDict_GetItemWithError(type->tp_dict,

&_Py_ID(__abstractmethods__));

if (!mod) {

if (!PyErr_Occurred()) {

PyErr_SetObject(PyExc_AttributeError, &_Py_ID(__abstractmethods__));

}

return NULL;

}

Py_INCREF(mod);

return mod;

}

static int

type_set_abstractmethods(PyTypeObject *type, PyObject *value, void *context)

{

/* __abstractmethods__ should only be set once on a type, in

int abstract, res;

if (value != NULL) {

abstract = PyObject_IsTrue(value);

if (abstract < 0)

return -1;

res = PyDict_SetItem(type->tp_dict, &_Py_ID(__abstractmethods__), value);

}

else {

abstract = 0;

res = PyDict_DelItem(type->tp_dict, &_Py_ID(__abstractmethods__));

if (res && PyErr_ExceptionMatches(PyExc_KeyError)) {

PyErr_SetObject(PyExc_AttributeError, &_Py_ID(__abstractmethods__));

return -1;

}

}

if (res == 0) {

PyType_Modified(type);

if (abstract)

type->tp_flags |= Py_TPFLAGS_IS_ABSTRACT;

else

type->tp_flags &= ~Py_TPFLAGS_IS_ABSTRACT;

}

return res;

}

static PyObject *

type_get_bases(PyTypeObject *type, void *context)

{

Py_INCREF(type->tp_bases);

return type->tp_bases;

}

static PyTypeObject *best_base(PyObject *);

static int mro_internal(PyTypeObject *, PyObject **);

static int type_is_subtype_base_chain(PyTypeObject *, PyTypeObject *);

static int compatible_for_assignment(PyTypeObject *, PyTypeObject *, const char *);

static int add_subclass(PyTypeObject*, PyTypeObject*);

static int add_all_subclasses(PyTypeObject *type, PyObject *bases);

static void remove_subclass(PyTypeObject *, PyTypeObject *);

static void remove_all_subclasses(PyTypeObject *type, PyObject *bases);

static void update_all_slots(PyTypeObject *);

typedef int (*update_callback)(PyTypeObject *, void *);

static int update_subclasses(PyTypeObject *type, PyObject *attr_name,

update_callback callback, void *data);

static int recurse_down_subclasses(PyTypeObject *type, PyObject *name,

update_callback callback, void *data);

static int

mro_hierarchy(PyTypeObject *type, PyObject *temp)

{

PyObject *old_mro;

int res = mro_internal(type, &old_mro);

if (res <= 0) {

/* error / reentrance */

return res;

}

PyObject *new_mro = type->tp_mro;

PyObject *tuple;

if (old_mro != NULL) {

tuple = PyTuple_Pack(3, type, new_mro, old_mro);

}

else {

tuple = PyTuple_Pack(2, type, new_mro);

}

if (tuple != NULL) {

res = PyList_Append(temp, tuple);

}

else {

res = -1;

}

Py_XDECREF(tuple);

if (res < 0) {

type->tp_mro = old_mro;

Py_DECREF(new_mro);

return -1;

}

Py_XDECREF(old_mro);

// Avoid creating an empty list if there is no subclass

if (type->tp_subclasses != NULL) {

/* Obtain a copy of subclasses list to iterate over.

PyObject *subclasses = _PyType_GetSubclasses(type);

if (subclasses == NULL) {

return -1;

}

Py_ssize_t n = PyList_GET_SIZE(subclasses);

for (Py_ssize_t i = 0; i < n; i++) {

PyTypeObject *subclass = _PyType_CAST(PyList_GET_ITEM(subclasses, i));

res = mro_hierarchy(subclass, temp);

if (res < 0) {

break;

}

}

Py_DECREF(subclasses);

}

return res;

}

static int

type_set_bases(PyTypeObject *type, PyObject *new_bases, void *context)

{

// Check arguments

if (!check_set_special_type_attr(type, new_bases, "__bases__")) {

return -1;

}

assert(new_bases != NULL);

if (!PyTuple_Check(new_bases)) {

PyErr_Format(PyExc_TypeError,

"can only assign tuple to %s.__bases__, not %s",

type->tp_name, Py_TYPE(new_bases)->tp_name);

return -1;

}

if (PyTuple_GET_SIZE(new_bases) == 0) {

PyErr_Format(PyExc_TypeError,

"can only assign non-empty tuple to %s.__bases__, not ()",

type->tp_name);

return -1;

}

Py_ssize_t n = PyTuple_GET_SIZE(new_bases);

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *ob = PyTuple_GET_ITEM(new_bases, i);

if (!PyType_Check(ob)) {

PyErr_Format(PyExc_TypeError,

"%s.__bases__ must be tuple of classes, not '%s'",

type->tp_name, Py_TYPE(ob)->tp_name);

return -1;

}

PyTypeObject *base = (PyTypeObject*)ob;

if (PyType_IsSubtype(base, type) ||

/* In case of reentering here again through a custom mro()

(base->tp_mro != NULL && type_is_subtype_base_chain(base, type)))

{

PyErr_SetString(PyExc_TypeError,

"a __bases__ item causes an inheritance cycle");

return -1;

}

}

// Compute the new MRO and the new base class

PyTypeObject *new_base = best_base(new_bases);

if (new_base == NULL)

return -1;

if (!compatible_for_assignment(type->tp_base, new_base, "__bases__")) {

return -1;

}

PyObject *old_bases = type->tp_bases;

assert(old_bases != NULL);

PyTypeObject *old_base = type->tp_base;

type->tp_bases = Py_NewRef(new_bases);

type->tp_base = (PyTypeObject *)Py_NewRef(new_base);

PyObject *temp = PyList_New(0);

if (temp == NULL) {

goto bail;

}

if (mro_hierarchy(type, temp) < 0) {

goto undo;

}

Py_DECREF(temp);

/* Take no action in case if type->tp_bases has been replaced

int res;

if (type->tp_bases == new_bases) {

/* any base that was in __bases__ but now isn't, we

/* for now, sod that: just remove from all old_bases,

remove_all_subclasses(type, old_bases);

res = add_all_subclasses(type, new_bases);

update_all_slots(type);

}

else {

res = 0;

}

Py_DECREF(old_bases);

Py_DECREF(old_base);

assert(_PyType_CheckConsistency(type));

return res;

undo:

n = PyList_GET_SIZE(temp);

for (Py_ssize_t i = n - 1; i >= 0; i--) {

PyTypeObject *cls;

PyObject *new_mro, *old_mro = NULL;

PyArg_UnpackTuple(PyList_GET_ITEM(temp, i),

"", 2, 3, &cls, &new_mro, &old_mro);

/* Do not rollback if cls has a newer version of MRO. */

if (cls->tp_mro == new_mro) {

Py_XINCREF(old_mro);

cls->tp_mro = old_mro;

Py_DECREF(new_mro);

}

}

Py_DECREF(temp);

bail:

if (type->tp_bases == new_bases) {

assert(type->tp_base == new_base);

type->tp_bases = old_bases;

type->tp_base = old_base;

Py_DECREF(new_bases);

Py_DECREF(new_base);

}

else {

Py_DECREF(old_bases);

Py_DECREF(old_base);

}

assert(_PyType_CheckConsistency(type));

return -1;

}

static PyObject *

type_dict(PyTypeObject *type, void *context)

{

if (type->tp_dict == NULL) {

Py_RETURN_NONE;

}

return PyDictProxy_New(type->tp_dict);

}

static PyObject *

type_get_doc(PyTypeObject *type, void *context)

{

PyObject *result;

if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL) {

return _PyType_GetDocFromInternalDoc(type->tp_name, type->tp_doc);

}

result = PyDict_GetItemWithError(type->tp_dict, &_Py_ID(__doc__));

if (result == NULL) {

if (!PyErr_Occurred()) {

result = Py_None;

Py_INCREF(result);

}

}

else if (Py_TYPE(result)->tp_descr_get) {

result = Py_TYPE(result)->tp_descr_get(result, NULL,

(PyObject *)type);

}

else {

Py_INCREF(result);

}

return result;

}

static PyObject *

type_get_text_signature(PyTypeObject *type, void *context)

{

return _PyType_GetTextSignatureFromInternalDoc(type->tp_name, type->tp_doc);

}

static int

type_set_doc(PyTypeObject *type, PyObject *value, void *context)

{

if (!check_set_special_type_attr(type, value, "__doc__"))

return -1;

PyType_Modified(type);

return PyDict_SetItem(type->tp_dict, &_Py_ID(__doc__), value);

}

static PyObject *

type_get_annotations(PyTypeObject *type, void *context)

{

if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {

PyErr_Format(PyExc_AttributeError, "type object '%s' has no attribute '__annotations__'", type->tp_name);

return NULL;

}

PyObject *annotations;

/* there's no _PyDict_GetItemId without WithError, so let's LBYL. */

if (PyDict_Contains(type->tp_dict, &_Py_ID(__annotations__))) {

annotations = PyDict_GetItemWithError(

type->tp_dict, &_Py_ID(__annotations__));

/*

if (annotations) {

if (Py_TYPE(annotations)->tp_descr_get) {

annotations = Py_TYPE(annotations)->tp_descr_get(

annotations, NULL, (PyObject *)type);

} else {

Py_INCREF(annotations);

}

}

} else {

annotations = PyDict_New();

if (annotations) {

int result = PyDict_SetItem(

type->tp_dict, &_Py_ID(__annotations__), annotations);

if (result) {

Py_CLEAR(annotations);

} else {

PyType_Modified(type);

}

}

}

return annotations;

}

static int

type_set_annotations(PyTypeObject *type, PyObject *value, void *context)

{

if (_PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE)) {

PyErr_Format(PyExc_TypeError,

"cannot set '__annotations__' attribute of immutable type '%s'",

type->tp_name);

return -1;

}

int result;

if (value != NULL) {

/* set */

result = PyDict_SetItem(type->tp_dict, &_Py_ID(__annotations__), value);

} else {

/* delete */

if (!PyDict_Contains(type->tp_dict, &_Py_ID(__annotations__))) {

PyErr_Format(PyExc_AttributeError, "__annotations__");

return -1;

}

result = PyDict_DelItem(type->tp_dict, &_Py_ID(__annotations__));

}

if (result == 0) {

PyType_Modified(type);

}

return result;

}

static int

type___instancecheck___impl(PyTypeObject *self, PyObject *instance)

{

return _PyObject_RealIsInstance(instance, (PyObject *)self);

}