#include "Python.h"

#include "pycore_call.h"

#include "pycore_code.h" // CO_FAST_FREE

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

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

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

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

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

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

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

#define next_version_tag (_PyRuntime.types.next_version_tag)

typedef struct PySlot_Offset {

short subslot_offset;

short slot_offset;

} PySlot_Offset;

static PyObject *

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

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

#ifndef NDEBUG

static inline int

static_builtin_index_is_set(PyTypeObject *self)

{

return self->tp_subclasses != NULL;

}

static inline size_t

static_builtin_index_get(PyTypeObject *self)

{

assert(static_builtin_index_is_set(self));

/* We store a 1-based index so 0 can mean "not initialized". */

return (size_t)self->tp_subclasses - 1;

}

static inline void

static_builtin_index_set(PyTypeObject *self, size_t index)

{

assert(index < _Py_MAX_STATIC_BUILTIN_TYPES);

/* We store a 1-based index so 0 can mean "not initialized". */

self->tp_subclasses = (PyObject *)(index + 1);

}

static inline void

static_builtin_index_clear(PyTypeObject *self)

{

self->tp_subclasses = NULL;

}

static inline static_builtin_state *

static_builtin_state_get(PyInterpreterState *interp, PyTypeObject *self)

{

return &(interp->types.builtins[static_builtin_index_get(self)]);

}

static_builtin_state *

_PyStaticType_GetState(PyTypeObject *self)

{

assert(self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);

PyInterpreterState *interp = _PyInterpreterState_GET();

return static_builtin_state_get(interp, self);

}

static void

static_builtin_state_init(PyTypeObject *self)

{

/* Set the type's per-interpreter state. */

PyInterpreterState *interp = _PyInterpreterState_GET();

/* It should only be called once for each builtin type. */

assert(!static_builtin_index_is_set(self));

static_builtin_index_set(self, interp->types.num_builtins_initialized);

interp->types.num_builtins_initialized++;

static_builtin_state *state = static_builtin_state_get(interp, self);

state->type = self;

/* state->tp_subclasses is left NULL until init_subclasses() sets it. */

/* state->tp_weaklist is left NULL until insert_head() or insert_after()

}

static void

static_builtin_state_clear(PyTypeObject *self)

{

/* Reset the type's per-interpreter state.

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = static_builtin_state_get(interp, self);

state->type = NULL;

assert(state->tp_weaklist == NULL); // It was already cleared out.

static_builtin_index_clear(self);

assert(interp->types.num_builtins_initialized > 0);

interp->types.num_builtins_initialized--;

}

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->types.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->types.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().

// (See _PyType_FixCacheRefcounts() about the refcount.)

entry->name = Py_None;

entry->value = NULL;

}

}

_PyType_FixCacheRefcounts(void)

{

_Py_RefcntAdd(Py_None, (1 << MCACHE_SIZE_EXP));

}

static unsigned int

_PyType_ClearCache(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->types.type_cache;

// 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->types.type_cache;

type_cache_clear(cache, NULL);

assert(interp->types.num_builtins_initialized == 0);

// All the static builtin types should have been finalized already.

for (size_t i = 0; i < _Py_MAX_STATIC_BUILTIN_TYPES; i++) {

assert(interp->types.builtins[i].type == NULL);

}

}

static PyObject * lookup_subclasses(PyTypeObject *);

PyType_AddWatcher(PyType_WatchCallback callback)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

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

if (!interp->type_watchers[i]) {

interp->type_watchers[i] = callback;

return i;

}

}

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

return -1;

}

static inline int

validate_watcher_id(PyInterpreterState *interp, int watcher_id)

{

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

PyErr_Format(PyExc_ValueError, "Invalid type watcher ID %d", watcher_id);

return -1;

}

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

PyErr_Format(PyExc_ValueError, "No type watcher set for ID %d", watcher_id);

return -1;

}

return 0;

}

PyType_ClearWatcher(int watcher_id)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (validate_watcher_id(interp, watcher_id) < 0) {

return -1;

}

interp->type_watchers[watcher_id] = NULL;

return 0;

}

static int assign_version_tag(PyTypeObject *type);

PyType_Watch(int watcher_id, PyObject* obj)

{

if (!PyType_Check(obj)) {

PyErr_SetString(PyExc_ValueError, "Cannot watch non-type");

return -1;

}

PyTypeObject *type = (PyTypeObject *)obj;

PyInterpreterState *interp = _PyInterpreterState_GET();

if (validate_watcher_id(interp, watcher_id) < 0) {

return -1;

}

// ensure we will get a callback on the next modification

assign_version_tag(type);

type->tp_watched |= (1 << watcher_id);

return 0;

}

PyType_Unwatch(int watcher_id, PyObject* obj)

{

if (!PyType_Check(obj)) {

PyErr_SetString(PyExc_ValueError, "Cannot watch non-type");

return -1;

}

PyTypeObject *type = (PyTypeObject *)obj;

PyInterpreterState *interp = _PyInterpreterState_GET();

if (validate_watcher_id(interp, watcher_id)) {

return -1;

}

type->tp_watched &= ~(1 << watcher_id);

return 0;

}

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 = lookup_subclasses(type);

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

}

}

// Notify registered type watchers, if any

if (type->tp_watched) {

PyInterpreterState *interp = _PyInterpreterState_GET();

int bits = type->tp_watched;

int i = 0;

while (bits) {

assert(i < TYPE_MAX_WATCHERS);

if (bits & 1) {

PyType_WatchCallback cb = interp->type_watchers[i];

if (cb && (cb(type) < 0)) {

PyErr_WriteUnraisable((PyObject *)type);

}

}

i++;

bits >>= 1;

}

}

type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;

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

if (PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) {

// This field *must* be invalidated if the type is modified (see the

// comment on struct _specialization_cache):

((PyHeapTypeObject *)type)->_spec_cache.getitem = NULL;

}

}

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

if (PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) {

// This field *must* be invalidated if the type is modified (see the

// comment on struct _specialization_cache):

((PyHeapTypeObject *)type)->_spec_cache.getitem = NULL;

}

}

static int

assign_version_tag(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(_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},

/* Note that this value is misleading for static builtin types,

{"__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;

return Py_NewRef(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;

return Py_NewRef(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_SETREF(((PyHeapTypeObject*)type)->ht_name, Py_NewRef(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_SETREF(et->ht_qualname, Py_NewRef(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_NewRef(&_Py_ID(builtins));

}

}

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;

}

return Py_NewRef(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)

{

return Py_NewRef(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 (_PyType_HasSubclasses(type)) {

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