Struct Frame 

pub struct Frame { /* private fields */ }

Python-visible frame object. Currently always wraps an InterpreterFrame. Analogous to CPython’s PyFrameObject.

Implementations

impl Frame

pub fn f_code(&self) -> PyRef<PyCode>

pub fn f_lineno(&self) -> usize

impl Frame

pub unsafe fn fastlocals(&self) -> &[Option<PyObjectRef>]

Access fastlocals immutably.

Safety

Caller must ensure no concurrent mutable access (frame not executing, or called from the same thread during trace callback).

pub unsafe fn fastlocals_mut(&self) -> &mut [Option<PyObjectRef>]

Access fastlocals mutably.

Safety

Caller must ensure exclusive access (frame not executing).

pub fn set_generator(&self, generator: &PyObject)

Store a borrowed back-reference to the owning generator/coroutine. The caller must ensure the generator outlives the frame.

pub fn clear_generator(&self)

Clear the generator back-reference. Called when the generator is finalized.

pub fn current_location(&self) -> SourceLocation

pub fn previous_frame(&self) -> *const Frame

Get the previous frame pointer for signal-safe traceback walking.

pub fn lasti(&self) -> u32

pub fn set_lasti(&self, val: u32)

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

Sync locals dict back to fastlocals. Called before generator/coroutine resume to apply any modifications made via f_locals.

pub fn locals(&self, vm: &VirtualMachine) -> PyResult<ArgMapping>

Trait Implementations

impl Debug for Frame

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

Formats the value using the given formatter.

impl Deref for Frame

fn deref(&self) -> &InterpreterFrame

Transparent access to InterpreterFrame fields.

Safety argument

Immutable fields (code, globals, builtins, func_obj, locals) are safe to access at any time. Atomic/mutex fields (lasti, trace, owner, etc.) provide their own synchronization. Mutable fields (localsplus, prev_line) are only mutated during single-threaded execution via with_exec.

type Target = InterpreterFrame

The resulting type after dereferencing.

impl MaybeTraverse for Frame

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 Frame

const NAME: &'static str = "frame"

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

const TP_NAME: &'static str = "frame"

const DOC: Option<&'static str>

const BASICSIZE: usize

const UNHASHABLE: bool = false

type Base = PyBaseObject

const ITEMSIZE: usize = 0

impl PyClassImpl for Frame

const TP_FLAGS: PyTypeFlags

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 Frame

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 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 before tp_clear, so the payload is still intact.

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,

impl Representable for Frame

fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef>

fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String>

fn slot_repr(zelf: &PyObject, 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 StaticType for Frame

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 Frame

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

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

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

Extract all owned child PyObjectRefs for circular reference resolution (tp_clear). Called just before object deallocation to break circular references. Default implementation does nothing.