/* Type object implementation */

#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_memoryobject.h" // _PyMemoryView_FromBufferProc()

#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 <stddef.h> // ptrdiff_t

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

#define NEXT_GLOBAL_VERSION_TAG _PyRuntime.types.next_version_tag

#define NEXT_VERSION_TAG(interp) \

(interp)->types.next_version_tag

typedef struct PySlot_Offset {

short subslot_offset;

short slot_offset;

} PySlot_Offset;

static void

slot_bf_releasebuffer(PyObject *self, Py_buffer *buffer);

static void

releasebuffer_call_python(PyObject *self, Py_buffer *buffer);

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 *

type_from_ref(PyObject *ref)

{

assert(PyWeakref_CheckRef(ref));

PyObject *obj = PyWeakref_GET_OBJECT(ref); // borrowed ref

assert(obj != NULL);

if (obj == Py_None) {

return NULL;

}

assert(PyType_Check(obj));

return _PyType_CAST(obj);

}

/* helpers for for static builtin types */

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

}

/* For static types we store some state in an array on each interpreter. */

static_builtin_state *

_PyStaticType_GetState(PyInterpreterState *interp, PyTypeObject *self)

{

assert(self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);

return static_builtin_state_get(interp, self);

}

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

static void

static_builtin_state_init(PyInterpreterState *interp, PyTypeObject *self)

{

if (!static_builtin_index_is_set(self)) {

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

}

static_builtin_state *state = static_builtin_state_get(interp, self);

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

assert(state->type == NULL);

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

(in weakrefobject.c) sets it. */

interp->types.num_builtins_initialized++;

}

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

This basically undoes what static_builtin_state_init() did. */

static void

static_builtin_state_clear(PyInterpreterState *interp, PyTypeObject *self)

{

static_builtin_state *state = static_builtin_state_get(interp, self);

assert(state->type != NULL);

state->type = NULL;

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

if (_Py_IsMainInterpreter(interp)) {

static_builtin_index_clear(self);

}

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

interp->types.num_builtins_initialized--;

}

// Also see _PyStaticType_InitBuiltin() and _PyStaticType_Dealloc().

/* end static builtin helpers */

static inline void

start_readying(PyTypeObject *type)

{

if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = static_builtin_state_get(interp, type);

assert(state != NULL);

assert(!state->readying);

state->readying = 1;

return;

}

assert((type->tp_flags & Py_TPFLAGS_READYING) == 0);

type->tp_flags |= Py_TPFLAGS_READYING;

}

static inline void

stop_readying(PyTypeObject *type)

{

if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = static_builtin_state_get(interp, type);

assert(state != NULL);

assert(state->readying);

state->readying = 0;

return;

}

assert(type->tp_flags & Py_TPFLAGS_READYING);

type->tp_flags &= ~Py_TPFLAGS_READYING;

}

static inline int

is_readying(PyTypeObject *type)

{

if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = static_builtin_state_get(interp, type);

assert(state != NULL);

return state->readying;

}

return (type->tp_flags & Py_TPFLAGS_READYING) != 0;

}

/* accessors for objects stored on PyTypeObject */

static inline PyObject *

lookup_tp_dict(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

return state->tp_dict;

}

return self->tp_dict;

}

PyObject *

_PyType_GetDict(PyTypeObject *self)

{

/* It returns a borrowed reference. */

return lookup_tp_dict(self);

}

PyObject *

PyType_GetDict(PyTypeObject *self)

{

PyObject *dict = lookup_tp_dict(self);

return _Py_XNewRef(dict);

}

static inline void

set_tp_dict(PyTypeObject *self, PyObject *dict)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

state->tp_dict = dict;

return;

}

self->tp_dict = dict;

}

static inline void

clear_tp_dict(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

Py_CLEAR(state->tp_dict);

return;

}

Py_CLEAR(self->tp_dict);

}

static inline PyObject *

lookup_tp_bases(PyTypeObject *self)

{

return self->tp_bases;

}

PyObject *

_PyType_GetBases(PyTypeObject *self)

{

/* It returns a borrowed reference. */

return lookup_tp_bases(self);

}

static inline void

set_tp_bases(PyTypeObject *self, PyObject *bases)

{

assert(PyTuple_CheckExact(bases));

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

// XXX tp_bases can probably be statically allocated for each

// static builtin type.

assert(_Py_IsMainInterpreter(_PyInterpreterState_GET()));

assert(self->tp_bases == NULL);

if (PyTuple_GET_SIZE(bases) == 0) {

assert(self->tp_base == NULL);

}

else {

assert(PyTuple_GET_SIZE(bases) == 1);

assert(PyTuple_GET_ITEM(bases, 0) == (PyObject *)self->tp_base);

assert(self->tp_base->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);

assert(_Py_IsImmortal(self->tp_base));

}

_Py_SetImmortal(bases);

}

self->tp_bases = bases;

}

static inline void

clear_tp_bases(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

if (_Py_IsMainInterpreter(_PyInterpreterState_GET())) {

if (self->tp_bases != NULL) {

if (PyTuple_GET_SIZE(self->tp_bases) == 0) {

Py_CLEAR(self->tp_bases);

}

else {

assert(_Py_IsImmortal(self->tp_bases));

_Py_ClearImmortal(self->tp_bases);

}

}

}

return;

}

Py_CLEAR(self->tp_bases);

}

static inline PyObject *

lookup_tp_mro(PyTypeObject *self)

{

return self->tp_mro;

}

PyObject *

_PyType_GetMRO(PyTypeObject *self)

{

/* It returns a borrowed reference. */

return lookup_tp_mro(self);

}

static inline void

set_tp_mro(PyTypeObject *self, PyObject *mro)

{

assert(PyTuple_CheckExact(mro));

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

// XXX tp_mro can probably be statically allocated for each

// static builtin type.

assert(_Py_IsMainInterpreter(_PyInterpreterState_GET()));

assert(self->tp_mro == NULL);

/* Other checks are done via set_tp_bases. */

_Py_SetImmortal(mro);

}

self->tp_mro = mro;

}

static inline void

clear_tp_mro(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

if (_Py_IsMainInterpreter(_PyInterpreterState_GET())) {

if (self->tp_mro != NULL) {

if (PyTuple_GET_SIZE(self->tp_mro) == 0) {

Py_CLEAR(self->tp_mro);

}

else {

assert(_Py_IsImmortal(self->tp_mro));

_Py_ClearImmortal(self->tp_mro);

}

}

}

return;

}

Py_CLEAR(self->tp_mro);

}

static PyObject *

init_tp_subclasses(PyTypeObject *self)

{

PyObject *subclasses = PyDict_New();

if (subclasses == NULL) {

return NULL;

}

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

state->tp_subclasses = subclasses;

return subclasses;

}

self->tp_subclasses = (void *)subclasses;

return subclasses;

}

static void

clear_tp_subclasses(PyTypeObject *self)

{

/* Delete the dictionary to save memory. _PyStaticType_Dealloc()

callers also test if tp_subclasses is NULL to check if a static type

has no subclass. */

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

Py_CLEAR(state->tp_subclasses);

return;

}

Py_CLEAR(self->tp_subclasses);

}

static inline PyObject *

lookup_tp_subclasses(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

return state->tp_subclasses;

}

return (PyObject *)self->tp_subclasses;

}

int

_PyType_HasSubclasses(PyTypeObject *self)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN

// XXX _PyStaticType_GetState() should never return NULL.

&& _PyStaticType_GetState(interp, self) == NULL)

{

return 0;

}

if (lookup_tp_subclasses(self) == NULL) {

return 0;

}

return 1;

}

PyObject*

_PyType_GetSubclasses(PyTypeObject *self)

{

PyObject *list = PyList_New(0);

if (list == NULL) {

return NULL;

}

PyObject *subclasses = lookup_tp_subclasses(self); // borrowed ref

if (subclasses == NULL) {

return list;

}

assert(PyDict_CheckExact(subclasses));

// The loop cannot modify tp_subclasses, there is no need

// to hold a strong reference (use a borrowed reference).

Py_ssize_t i = 0;

PyObject *ref; // borrowed ref

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

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

if (subclass == NULL) {

continue;

}

if (PyList_Append(list, _PyObject_CAST(subclass)) < 0) {

Py_DECREF(list);

return NULL;

}

}

return list;

}

/* end accessors for objects stored on PyTypeObject */

/*

* 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(!is_readying(type));

CHECK(lookup_tp_dict(type) != 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(lookup_tp_dict(type), &_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;

}

}

void

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

entry->name = Py_None;

entry->value = NULL;

}

}

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(interp) - 1;

}

unsigned int

PyType_ClearCache(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return _PyType_ClearCache(interp);

}

void

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

}

}

int

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;

}

int

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(PyInterpreterState *interp, PyTypeObject *type);

int

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(interp, type);

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

return 0;

}

int

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;

}

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.

*/

if (!_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {

return;

}

PyObject *subclasses = lookup_tp_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 = type_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) {

/*

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;

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:

assert(!(type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN));

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(PyInterpreterState *interp, 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.

*/

if (_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {

return 1;

}

if (!_PyType_HasFeature(type, Py_TPFLAGS_READY)) {

return 0;

}

if (type->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) {

/* static types */

if (NEXT_GLOBAL_VERSION_TAG > _Py_MAX_GLOBAL_TYPE_VERSION_TAG) {

/* We have run out of version numbers */

return 0;

}

type->tp_version_tag = NEXT_GLOBAL_VERSION_TAG++;

assert (type->tp_version_tag <= _Py_MAX_GLOBAL_TYPE_VERSION_TAG);

}

else {

/* heap types */

if (NEXT_VERSION_TAG(interp) == 0) {

/* We have run out of version numbers */

return 0;

}

type->tp_version_tag = NEXT_VERSION_TAG(interp)++;

assert (type->tp_version_tag != 0);

}

PyObject *bases = lookup_tp_bases(type);

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(interp, _PyType_CAST(b)))

return 0;

}

type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;

return 1;

}

int PyUnstable_Type_AssignVersionTag(PyTypeObject *type)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return assign_version_tag(interp, type);

}

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,

since the memory at this offset will always be NULL. */

{"__weakrefoffset__", T_PYSSIZET,

offsetof(PyTypeObject, tp_weaklistoffset), READONLY},

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

{"__dictoffset__", T_PYSSIZET,

offsetof(PyTypeObject, tp_dictoffset), 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 *