Method dispatch_traced_frame

crates/vm/src/vm/mod.rs:1686–1714

Fire trace/profile 'call' and 'return' events around a frame body. Matches `call_trace_protected` / `trace_trampoline` protocol: - Fire `TraceEvent::Call`; if the trace function returns non-None, install it as the per-frame `f_trace`. - Execute the closure (the actual frame body). - Fire `TraceEvent::Return` on both normal return **and** exception unwind (`PY_UNWIND` → `PyTrace_RETURN` with `arg

(
        &self,
        frame: &Py<Frame>,
        f: F,
    )

    ///   unwind (`PY_UNWIND` → `PyTrace_RETURN` with `arg = None`).
    ///   Propagate any trace-function error, replacing the original exception.
    fn dispatch_traced_frame<R, F: FnOnce(&Py<Frame>) -> PyResult<R>>(
        &self,
        frame: &Py<Frame>,
        f: F,
    ) -> PyResult<R> {
        use crate::protocol::TraceEvent;

        // Fire 'call' trace event. current_frame() now returns the callee.
        let trace_result = self.trace_event(TraceEvent::Call, None)?;
        if let Some(local_trace) = trace_result {
            *frame.trace.lock() = local_trace;
        }

        let result = f(frame);

        // Fire 'return' event if frame is being traced or profiled.
        // PY_UNWIND fires PyTrace_RETURN with arg=None — so we fire for
        // both Ok and Err, matching `call_trace_protected` behavior.
        if self.use_tracing.get()
            && (!self.is_none(&frame.trace.lock()) || !self.is_none(&self.profile_func.borrow()))
        {
            let ret_result = self.trace_event(TraceEvent::Return, None);
            // call_trace_protected: if trace function raises, its error
            // replaces the original exception.
            ret_result?;
        }

        result
    }

    /// Returns a basic CompileOpts instance with options accurate to the vm. Used
    /// as the CompileOpts for `vm.compile()`.