Move init_static_type_pointers to pylifecycle.rs

RustPython · bschoenmaeckers · Apr 4, 2026 · Apr 5, 2026 · Apr 5, 2026 · Apr 5, 2026
commit e4c8bd74f2fbdc19e32c0061cfe219a4056b2c87
diff --git a/crates/capi/src/longobject.rs b/crates/capi/src/longobject.rs
@@ -1,5 +1,4 @@
 use core::ffi::{c_long, c_longlong, c_ulong, c_ulonglong};
-use core::ptr;
 
 use crate::PyObject;
 use crate::pyerrors::{PyErr_SetString, PyExc_OverflowError};

diff --git a/crates/capi/src/object.rs b/crates/capi/src/object.rs
@@ -1,5 +1,4 @@
 use crate::PyObject;
-use crate::pylifecycle::INITIALIZED;
 use crate::pystate::with_vm;
 use core::ffi::c_ulong;
 use rustpython_vm::builtins::PyType;
@@ -28,26 +27,6 @@ pub static mut PyTuple_Type: MaybeUninit<&'static Py<PyType>> = MaybeUninit::uni
 #[unsafe(no_mangle)]
 pub static mut PyUnicode_Type: MaybeUninit<&'static Py<PyType>> = MaybeUninit::uninit();
 
-/// Initialize the static type pointers. This should be called once during interpreter initialization,
-/// and before any of the static type pointers are used.
-///
-/// Panics:
-/// Panics when the interpreter is already initialized.
-#[allow(static_mut_refs)]
-pub(crate) fn init_static_type_pointers() {
-    assert!(
-        !INITIALIZED.is_completed(),
-        "Python already initialized, we should not touch the static type pointers"
-    );
-    let zoo = &Context::genesis().types;
-    unsafe {
-        PyType_Type.write(zoo.type_type);
-        PyLong_Type.write(zoo.int_type);
-        PyTuple_Type.write(zoo.tuple_type);
-        PyUnicode_Type.write(zoo.str_type);
-    };
-}
-
 #[unsafe(no_mangle)]
 pub extern "C" fn Py_TYPE(op: *mut PyObject) -> *const Py<PyType> {
     // SAFETY: The caller must guarantee that `op` is a valid pointer to a `PyObject`.

diff --git a/crates/capi/src/pylifecycle.rs b/crates/capi/src/pylifecycle.rs
@@ -1,9 +1,9 @@
 use crate::log_stub;
-use crate::object::init_static_type_pointers;
+use crate::object::{PyLong_Type, PyTuple_Type, PyType_Type, PyUnicode_Type};
 use crate::pystate::attach_vm_to_thread;
 use core::ffi::c_int;
-use rustpython_vm::Interpreter;
 use rustpython_vm::vm::thread::ThreadedVirtualMachine;
+use rustpython_vm::{Context, Interpreter};
 use std::sync::{Once, OnceLock, mpsc};
 
 static VM_REQUEST_TX: OnceLock<mpsc::Sender<mpsc::Sender<ThreadedVirtualMachine>>> =
@@ -20,6 +20,28 @@ pub(crate) fn request_vm_from_interpreter() -> ThreadedVirtualMachine {
     response_rx.recv().expect("Failed to receive VM response")
 }
 #[test] 
 fn test_new_thread() { 
     Python::attach(|py| { 
         let number = PyInt::new(py, 123).unbind(); 
         std::thread::spawn(move || { 
             Python::attach(|py| { 
                 let number = number.bind(py); 
                 assert!(number.is_instance_of::<PyInt>()); 
             }); 
         }) 
         .join() 
         .unwrap(); 
     }) 
 } 
 #[test] 
 fn test_new_thread() { 
     Python::attach(|py| { 
         let number = PyInt::new(py, 123).unbind(); 
  
         std::thread::spawn(move || { 
             Python::attach(|py| { 
                 let number = number.bind(py); 
                 assert!(number.is_instance_of::<PyInt>()); 
             }); 
         }) 
         .join() 
         .unwrap(); 
     }) 
 } 
 
+/// Initialize the static type pointers. This should be called once during interpreter initialization,
+/// and before any of the static type pointers are used.
+///
+/// Panics:
+/// Panics when the interpreter is already initialized.
+#[allow(static_mut_refs)]
+pub(crate) fn init_static_type_pointers() {
+    assert!(
+        !INITIALIZED.is_completed(),
+        "Python already initialized, we should not touch the static type pointers"
+    );
+    let context = Context::genesis();
+    let types = &context.types;
+
+    unsafe {
+        PyType_Type.write(types.type_type);
+        PyLong_Type.write(types.int_type);
+        PyTuple_Type.write(types.tuple_type);
+        PyUnicode_Type.write(types.str_type);
+    };
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn Py_IsInitialized() -> c_int {
     INITIALIZED.is_completed() as _

diff --git a/crates/capi/src/unicodeobject.rs b/crates/capi/src/unicodeobject.rs
@@ -29,7 +29,7 @@ pub extern "C" fn PyUnicode_FromStringAndSize(s: *const c_char, len: isize) -> *
 
 #[unsafe(no_mangle)]
 pub extern "C" fn PyUnicode_AsUTF8AndSize(obj: *mut PyObject, size: *mut isize) -> *const c_char {
-    with_vm(|vm| {
+    with_vm(|_vm| {
         let obj = unsafe {
             obj.as_ref()
                 .expect("PyUnicode_AsUTF8AndSize called with null pointer")