Struct PyType 

pub struct PyType {
    pub base: PyAtomicRef<Option<Self>>,
    pub bases: PyRwLock<PyRef<PyTuple<PyTypeRef>>>,
    pub mro: PyRwLock<Vec<PyTypeRef>>,
    pub subclasses: PyRwLock<Vec<PyRef<PyWeak>>>,
    pub attributes: TypeNamespace,
    pub slots: PyTypeSlots,
    pub heaptype_ext: Option<Pin<Box<HeapTypeExt>>>,
    pub tp_version_tag: AtomicU32,
}

Fields

base: PyAtomicRef<Option<Self>>

bases: PyRwLock<PyRef<PyTuple<PyTypeRef>>>

mro: PyRwLock<Vec<PyTypeRef>>

subclasses: PyRwLock<Vec<PyRef<PyWeak>>>

attributes: TypeNamespace

slots: PyTypeSlots

heaptype_ext: Option<Pin<Box<HeapTypeExt>>>

tp_version_tag: AtomicU32

Type version tag for inline caching. 0 means unassigned/invalidated.

Implementations

impl PyType

pub fn modified(&self)

pub fn is_visible_to_interpreter(&self, interpreter_id: i64) -> bool

Whether the interpreter with interpreter_id can see this type.

Interpreters share the context, so a subclass of a shared type is recorded on an object every interpreter reaches. Only the interpreter that created it can name it, so only that one lists it.

pub fn new_simple_heap( name: &str, base: &Py<Self>, ctx: &Context, ) -> Result<PyRef<Self>, String>

pub fn new_heap( name: &str, bases: Vec<PyRef<Self>>, attrs: IndexMap<&'static PyStrInterned, PyObjectRef, RandomState>, slots: PyTypeSlots, metaclass: PyRef<Self>, ctx: &Context, ) -> Result<PyRef<Self>, String>

pub fn has_patma_collection_flag(&self, flag: u8) -> bool

pub fn set_is_abstract(&self, is_abstract: bool)

pub fn set_abc_collection_flags_recursive(&self, flags: PyTypeFlags)

pub fn new_static( base: PyRef<Self>, attrs: IndexMap<&'static PyStrInterned, PyObjectRef, RandomState>, slots: PyTypeSlots, metaclass: PyRef<Self>, ) -> Result<PyRef<Self>, String>

pub fn set_str_attr<V: Into<PyObjectRef>>( &self, attr_name: &str, value: V, ctx: impl AsRef<Context>, )

pub fn set_attr(&self, attr_name: &'static PyStrInterned, value: PyObjectRef)

pub fn get_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef>

Internal get_attr implementation for fast lookup on a class. Searches the full MRO (including self) with method cache acceleration.

pub fn get_direct_attr( &self, attr_name: &'static PyStrInterned, ) -> Option<PyObjectRef>

pub fn lookup_ref( &self, name: &Py<PyStr>, vm: &VirtualMachine, ) -> Option<PyObjectRef>

_PyType_LookupRef: look up a name through the MRO without setting an exception.

pub fn get_super_attr( &self, attr_name: &'static PyStrInterned, ) -> Option<PyObjectRef>

pub fn has_attr(&self, attr_name: &'static PyStrInterned) -> bool

Fast lookup for attribute existence on a class.

pub fn get_attributes( &self, ctx: &Context, ) -> IndexMap<&'static PyStrInterned, PyObjectRef, RandomState>

pub fn slot_name(&self) -> BorrowedValue<'_, str>

pub fn __qualname__(&self, vm: &VirtualMachine) -> PyObjectRef

pub fn __module__(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef>

pub fn fully_qualified_name(&self, vm: &VirtualMachine) -> PyResult<String>

The type’s fully qualified name, the way the %T format code prints it: module.qualname, with a builtins or __main__ module left off.

pub fn name(&self) -> BorrowedValue<'_, str>

pub fn init_type_data<T: Any + Send + Sync + 'static>( &self, data: T, ) -> Result<(), String>

Initialize type data for this type. Can only be called once. Returns an error if the type is not a heap type or if data is already initialized.

pub fn get_type_data<T: Any + 'static>(&self) -> Option<TypeDataRef<'_, T>>

Get a read guard to the type data. Returns None if the type is not a heap type, has no data, or the data type doesn’t match.

pub fn get_type_data_mut<T: Any + 'static>( &self, ) -> Option<TypeDataRefMut<'_, T>>

Get a write guard to the type data. Returns None if the type is not a heap type, has no data, or the data type doesn’t match.

pub fn has_type_data<T: Any + 'static>(&self) -> bool

Check if this type has type data of the given type.

impl PyType

pub fn __ror__( zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult

pub fn __or__( zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult

Trait Implementations

impl AsNumber for PyType

fn as_number() -> &'static PyNumberMethods

fn extend_slots(slots: &mut PyTypeSlots)

fn clone_exact(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyRef<Self>

fn number_downcast(num: PyNumber<'_>) -> &Py<Self>

fn number_downcast_exact(num: PyNumber<'_>, vm: &VirtualMachine) -> PyRef<Self>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Callable for PyType

type Args = FuncArgs

fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult

fn slot_call(zelf: &PyObject, args: FuncArgs, vm: &VirtualMachine) -> PyResult

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Constructor for PyType

type Args = FuncArgs

fn slot_new( metatype: PyTypeRef, args: FuncArgs, vm: &VirtualMachine, ) -> PyResult

The type slot for __new__. Override this only when you need special behavior beyond simple payload creation.

fn py_new( _cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine, ) -> PyResult<Self>

Creates the payload for this type. In most cases, just implement this method and let the default slot_new handle wrapping with the correct type.

const DROP_KWARGS_WHEN_INIT_OVERRIDDEN: bool = false

When true, extra keywords are dropped if a subclass replaced tp_init.

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Debug for PyType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for PyType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl GetAttr for PyType

fn getattro( zelf: &Py<Self>, name_str: &Py<PyStr>, vm: &VirtualMachine, ) -> PyResult

fn slot_getattro( obj: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine, ) -> PyResult

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Initializer for PyType

type Args = FuncArgs

fn slot_init( _zelf: &PyObject, args: FuncArgs, vm: &VirtualMachine, ) -> PyResult<()>

fn init( _zelf: &Py<Self>, _args: Self::Args, _vm: &VirtualMachine, ) -> PyResult<()>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl MaybeTraverse for PyType

const HAS_TRAVERSE: bool = true

if is traceable, will be used by vtable to determine

const HAS_CLEAR: bool = true

if has clear implementation for circular reference resolution (tp_clear)

fn try_traverse(&self, tracer_fn: &mut TraverseFn<'_>)

fn try_clear(&mut self, out: &mut Vec<PyObjectRef>)

impl PyClassDef for PyType

const NAME: &'static str = "type"

const MODULE_NAME: Option<&'static str> = None

const TP_NAME: &'static str = "type"

const DOC: ItemDoc

const ATTR_DOCS: &'static [(&'static str, u32, u32)]

Attribute name → database span, sorted by name. (u32::MAX, 0) is an explicit empty doc.

const BASICSIZE: usize

const UNHASHABLE: bool = false

const MEMBERS: &'static [PyMemberSpec]

type Base = PyBaseObject

fn assert_member_layout()

const ITEMSIZE: usize = 0

impl PyClassImpl for PyType

const TP_FLAGS: PyTypeFlags

const INTERNAL_DOC: ItemDoc

Signature-bearing class doc. ItemDoc::NONE when the constructor has no signature.

const METHOD_DEFS: &'static [PyMethodDef]

fn impl_extend_class(ctx: &'static Context, class: &'static Py<PyType>)

fn extend_slots(slots: &mut PyTypeSlots)

fn extend_class(ctx: &'static Context, class: &'static Py<PyType>)

where Self: Sized,

fn make_static_type() -> PyTypeRef

where Self: StaticType + Sized,

fn make_slots() -> PyTypeSlots

impl PyPayload for PyType

fn class(ctx: &Context) -> &'static Py<PyType>

const PAYLOAD_TYPE_ID: TypeId = _

unsafe fn validate_downcastable_from(_obj: &PyObject) -> bool

Safety

fn try_downcast_from(obj: &PyObject, vm: &VirtualMachine) -> PyResult<()>

const NEW_REF_UNTRACKED: bool = false

Whether PyRef::new_ref skips auto-tracking this type in the GC even when it would otherwise qualify (has traverse, dict, or heap type). Such objects are created untracked and must be tracked explicitly if and when they can become part of a reference cycle. Used by FrameObject, which is created untracked and tracked lazily only on escape.

const HAS_FREELIST: bool = false

Whether this type has a freelist. Types with freelists require immediate (non-deferred) GC untracking during dealloc to prevent race conditions when the object is reused.

const MAX_FREELIST: usize = 0

Maximum number of objects to keep in the freelist.

unsafe fn freelist_push(_obj: *mut PyObject) -> bool

Try to push a dead object onto this type’s freelist for reuse. Returns true if the object was stored (caller must NOT free the memory). Called after tp_clear, so the payload is a cleared husk; implementations must not rely on its pre-clear contents.

unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>>

Try to pop a pre-allocated object from this type’s freelist. The returned pointer still has the old payload; the caller must reinitialize ref_count, gc_bits, and payload.

fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef

where Self: Debug,

fn _into_ref(self, cls: PyTypeRef, ctx: &Context) -> PyRef<Self>

where Self: Debug,

fn into_exact_ref(self, ctx: &Context) -> PyRefExact<Self>

where Self: Debug,

fn into_ref(self, ctx: &Context) -> PyRef<Self>

where Self: Debug,

fn into_ref_with_type( self, vm: &VirtualMachine, cls: PyTypeRef, ) -> PyResult<PyRef<Self>>

where Self: Debug,

fn into_ref_with_type_lazy_dict( self, vm: &VirtualMachine, cls: PyTypeRef, ) -> PyResult<PyRef<Self>>

where Self: Debug,

Like into_ref_with_type, but leaves the instance __dict__ unallocated until the first attribute write or __dict__ access. Only valid for types whose attribute protocol materializes the dict lazily via get_or_insert.

fn into_ref_with_type_and_dict( self, vm: &VirtualMachine, cls: PyTypeRef, eager_dict: bool, ) -> PyResult<PyRef<Self>>

where Self: Debug,

impl Representable for PyType

fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String>

fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>>

fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>>

fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl SetAttr for PyType

fn setattro( zelf: &Py<Self>, attr_name: &Py<PyStr>, value: PySetterValue, vm: &VirtualMachine, ) -> PyResult<()>

fn slot_setattro( obj: &PyObject, name: &Py<PyStr>, value: PySetterValue, vm: &VirtualMachine, ) -> PyResult<()>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl StaticType for PyType

fn static_cell() -> &'static StaticCell<PyTypeRef>

fn static_metaclass() -> &'static Py<PyType>

fn static_baseclass() -> &'static Py<PyType>

fn static_type() -> &'static Py<PyType>

fn init_manually(typ: PyTypeRef) -> &'static Py<PyType>

fn init_builtin_type() -> &'static Py<PyType>

where Self: PyClassImpl,

fn create_static_type() -> PyTypeRef

where Self: PyClassImpl,

impl Traverse for PyType

fn clear(&mut self, out: &mut Vec<PyObjectRef>)

type_clear: break reference cycles in type objects

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>)

impl traverse() with caution! Following those guideline so traverse doesn’t cause memory error!: