/* Type object implementation */

#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 "frameobject.h" // PyFrameObject

#include "pycore_frame.h" // InterpreterFrame

#include "opcode.h" // MAKE_CELL

#include "structmember.h" // PyMemberDef

#include <ctype.h>

/*[clinic input]

class type "PyTypeObject *" "&PyType_Type"

class object "PyObject *" "&PyBaseObject_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=4b94608d231c434b]*/

#include "clinic/typeobject.c.h"

/* Support type attribute lookup cache */

/* The cache can keep references to the names alive for longer than

they normally would. This is why the maximum size is limited to

MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large

strings are used as attribute names. */

#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)

// bpo-42745: next_version_tag remains shared by all interpreters because of static types

// Used to set PyTypeObject.tp_version_tag

static unsigned int next_version_tag = 1;

typedef struct PySlot_Offset {

short subslot_offset;

short slot_offset;

} PySlot_Offset;

/* alphabetical order */

_Py_IDENTIFIER(__abstractmethods__);

_Py_IDENTIFIER(__annotations__);

_Py_IDENTIFIER(__class__);

_Py_IDENTIFIER(__class_getitem__);

_Py_IDENTIFIER(__classcell__);

_Py_IDENTIFIER(__delitem__);

_Py_IDENTIFIER(__dict__);

_Py_IDENTIFIER(__doc__);

_Py_IDENTIFIER(__getattribute__);

_Py_IDENTIFIER(__getitem__);

_Py_IDENTIFIER(__hash__);

_Py_IDENTIFIER(__init_subclass__);

_Py_IDENTIFIER(__len__);

_Py_IDENTIFIER(__module__);

_Py_IDENTIFIER(__name__);

_Py_IDENTIFIER(__new__);

_Py_IDENTIFIER(__qualname__);

_Py_IDENTIFIER(__set_name__);

_Py_IDENTIFIER(__setitem__);

_Py_IDENTIFIER(__weakref__);

_Py_IDENTIFIER(builtins);

_Py_IDENTIFIER(mro);

static PyObject *

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

static void

clear_slotdefs(void);

static PyObject *

lookup_maybe_method(PyObject *self, _Py_Identifier *attrid, int *unbound);

static int

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

/*

* finds the beginning of the docstring's introspection signature.

* if present, returns a pointer pointing to the first '('.

* otherwise returns NULL.

*

* doesn't guarantee that the signature is valid, only that it

* has a valid prefix. (the signature must also pass skip_signature.)

*/

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

/*

* skips past the end of the docstring's introspection signature.

* (assumes doc starts with a valid signature prefix.)

*/

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;

}

int

_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_ContainsId(type->tp_dict, &PyId___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;

}

}

void

_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);

#endif

// 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;

}

unsigned int

PyType_ClearCache(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return _PyType_ClearCache(interp);

}

void

_PyTypes_Fini(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->type_cache;

type_cache_clear(cache, NULL);

if (_Py_IsMainInterpreter(interp)) {

clear_slotdefs();

}

}

void

PyType_Modified(PyTypeObject *type)

{

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

subclasses. This function is called after the base

classes, mro, or attributes of the type are altered.

Invariants:

- before Py_TPFLAGS_VALID_VERSION_TAG can be set on a type,

it must first be set on all super types.

This function clears the Py_TPFLAGS_VALID_VERSION_TAG of a

type (so it must first clear it on all subclasses). The

tp_version_tag value is meaningless unless this flag is set.

We don't assign new version tags eagerly, but only as

needed.

*/

PyObject *raw, *ref;

Py_ssize_t i;

if (!_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))

return;

raw = type->tp_subclasses;

if (raw != NULL) {

assert(PyDict_CheckExact(raw));

i = 0;

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

assert(PyWeakref_CheckRef(ref));

ref = PyWeakref_GET_OBJECT(ref);

if (ref != Py_None) {

PyType_Modified((PyTypeObject *)ref);

}

}

}

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) {

/*

Check that all base classes or elements of the MRO of type are

able to be cached. This function is called after the base

classes or mro of the type are altered.

Unset HAVE_VERSION_TAG and VALID_VERSION_TAG if the type

has a custom MRO that includes a type which is not officially

super type, or if the type implements its own mro() method.

Called from mro_internal, which will subsequently be called on

each subclass when their mro is recursively updated.

*/

Py_ssize_t i, n;

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

int unbound;

PyObject *mro_meth = NULL;

PyObject *type_mro_meth = NULL;

if (custom) {

mro_meth = lookup_maybe_method(

(PyObject *)type, &PyId_mro, &unbound);

if (mro_meth == NULL)

goto clear;

type_mro_meth = lookup_maybe_method(

(PyObject *)&PyType_Type, &PyId_mro, &unbound);

if (type_mro_meth == NULL)

goto clear;

if (mro_meth != type_mro_meth)

goto clear;

Py_XDECREF(mro_meth);

Py_XDECREF(type_mro_meth);

}

n = PyTuple_GET_SIZE(bases);

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

PyObject *b = PyTuple_GET_ITEM(bases, i);

PyTypeObject *cls;

assert(PyType_Check(b));

cls = (PyTypeObject *)b;

if (!PyType_IsSubtype(type, cls)) {

goto clear;

}

}

return;

clear:

Py_XDECREF(mro_meth);

Py_XDECREF(type_mro_meth);

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

Py_TPFLAGS_VALID_VERSION_TAG. To respect the invariant, this

must first be done on all super classes. Return 0 if this

cannot be done, 1 if Py_TPFLAGS_VALID_VERSION_TAG.

*/

Py_ssize_t i, n;

PyObject *bases;

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);

bases = type->tp_bases;

n = PyTuple_GET_SIZE(bases);

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

PyObject *b = PyTuple_GET_ITEM(bases, i);

assert(PyType_Check(b));

if (!assign_version_tag(cache, (PyTypeObject *)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_GetItemIdWithError(type->tp_dict, &PyId___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 = _PyUnicode_FromId(&PyId_builtins);

Py_XINCREF(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_SetItemId(type->tp_dict, &PyId___module__, value);

}

static PyObject *

type_abstractmethods(PyTypeObject *type, void *context)

{

PyObject *mod = NULL;

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

that. */

if (type != &PyType_Type)

mod = _PyDict_GetItemIdWithError(type->tp_dict, &PyId___abstractmethods__);

if (!mod) {

if (!PyErr_Occurred()) {

PyObject *message = _PyUnicode_FromId(&PyId___abstractmethods__);

if (message)

PyErr_SetObject(PyExc_AttributeError, message);

}

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

abc.ABCMeta.__new__, so this function doesn't do anything

special to update subclasses.

*/

int abstract, res;

if (value != NULL) {

abstract = PyObject_IsTrue(value);

if (abstract < 0)

return -1;

res = _PyDict_SetItemId(type->tp_dict, &PyId___abstractmethods__, value);

}

else {

abstract = 0;

res = _PyDict_DelItemId(type->tp_dict, &PyId___abstractmethods__);

if (res && PyErr_ExceptionMatches(PyExc_KeyError)) {

PyObject *message = _PyUnicode_FromId(&PyId___abstractmethods__);

if (message)

PyErr_SetObject(PyExc_AttributeError, message);

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 *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)

{

int res;

PyObject *new_mro, *old_mro;

PyObject *tuple;

PyObject *subclasses;

Py_ssize_t i, n;

res = mro_internal(type, &old_mro);

if (res <= 0)

/* error / reentrance */

return res;

new_mro = type->tp_mro;

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);

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

Otherwise type->tp_subclasses might be altered

in the middle of the loop, for example, through a custom mro(),

by invoking type_set_bases on some subclass of the type

which in turn calls remove_subclass/add_subclass on this type.

Finally, this makes things simple avoiding the need to deal

with dictionary iterators and weak references.

*/

subclasses = type___subclasses___impl(type);

if (subclasses == NULL)

return -1;

n = PyList_GET_SIZE(subclasses);

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

PyTypeObject *subclass;

subclass = (PyTypeObject *)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)

{

int res = 0;

PyObject *temp;

PyObject *old_bases;

PyTypeObject *new_base, *old_base;

Py_ssize_t i;

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

return -1;

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;

}

for (i = 0; i < PyTuple_GET_SIZE(new_bases); i++) {

PyObject *ob;

PyTypeObject *base;

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;

}

base = (PyTypeObject*)ob;

if (PyType_IsSubtype(base, type) ||

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

the above check is not enough since it relies on

base->tp_mro which would gonna be updated inside

mro_internal only upon returning from the mro().

However, base->tp_base has already been assigned (see

below), which in turn may cause an inheritance cycle

through tp_base chain. And this is definitely

not what you want to ever happen. */

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

PyErr_SetString(PyExc_TypeError,

"a __bases__ item causes an inheritance cycle");

return -1;

}

}

new_base = best_base(new_bases);

if (new_base == NULL)

return -1;

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

return -1;

Py_INCREF(new_bases);

Py_INCREF(new_base);

old_bases = type->tp_bases;

old_base = type->tp_base;

type->tp_bases = new_bases;

type->tp_base = new_base;

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

through reentrance. */

if (type->tp_bases == new_bases) {

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

need to remove |type| from its tp_subclasses.

conversely, any class now in __bases__ that wasn't

needs to have |type| added to its subclasses. */

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

add to all new_bases */

remove_all_subclasses(type, old_bases);

res = add_all_subclasses(type, new_bases);

update_all_slots(type);

}

Py_DECREF(old_bases);

Py_DECREF(old_base);

assert(_PyType_CheckConsistency(type));

return res;

undo:

for (i = PyList_GET_SIZE(temp) - 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_GetItemIdWithError(type->tp_dict, &PyId___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_SetItemId(type->tp_dict, &PyId___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_ContainsId(type->tp_dict, &PyId___annotations__)) {

annotations = _PyDict_GetItemIdWithError(type->tp_dict, &PyId___annotations__);

/*

** _PyDict_GetItemIdWithError could still fail,

** for instance with a well-timed Ctrl-C or a MemoryError.

** so let's be totally safe.

*/

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_SetItemId(type->tp_dict, &PyId___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_SetItemId(type->tp_dict, &PyId___annotations__, value);

} else {

/* delete */

if (!_PyDict_ContainsId(type->tp_dict, &PyId___annotations__)) {

PyErr_Format(PyExc_AttributeError, "__annotations__");

return -1;

}

result = _PyDict_DelItemId(type->tp_dict, &PyId___annotations__);

}

if (result == 0) {

PyType_Modified(type);

}

return result;

}

/*[clinic input]

type.__instancecheck__ -> bool

instance: object

/