x

youknowone · youknowone · commit 86de80edbf8f · 2025-12-13T17:47:43.000+09:00
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
@@ -88,9 +88,7 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
     fileio::extend_module(vm, &module).unwrap();
 
-    let unsupported_operation = _io::UNSUPPORTED_OPERATION
-        .get_or_init(|| _io::make_unsupportedop(ctx))
-        .clone();
+    let unsupported_operation = _io::unsupported_operation().to_owned();
     extend_module!(vm, &module, {
         "UnsupportedOperation" => unsupported_operation,
         "BlockingIOError" => ctx.exceptions.blocking_io_error.to_owned(),
@@ -205,7 +203,8 @@ mod _io {
     }
 
     pub fn new_unsupported_operation(vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {
-        vm.new_exception_msg(UNSUPPORTED_OPERATION.get().unwrap().clone(), msg)
+        vm.new_os_subtype_error(unsupported_operation().to_owned(), None, msg)
+            .upcast()
     }
 
     fn _unsupported<T>(vm: &VirtualMachine, zelf: &PyObject, operation: &str) -> PyResult<T> {
@@ -4244,11 +4243,7 @@ mod _io {
         }
     }
 
-    rustpython_common::static_cell! {
-        pub(super) static UNSUPPORTED_OPERATION: PyTypeRef;
-    }
-
-    pub(super) fn make_unsupportedop(ctx: &Context) -> PyTypeRef {
+    fn create_unsupported_operation(ctx: &Context) -> PyTypeRef {
         use crate::types::PyTypeSlots;
         PyType::new_heap(
             "UnsupportedOperation",
@@ -4264,6 +4259,13 @@ mod _io {
         .unwrap()
     }
 
+    pub fn unsupported_operation() -> &'static Py<PyType> {
+        rustpython_common::static_cell! {
+            static CELL: PyTypeRef;
+        }
+        CELL.get_or_init(|| create_unsupported_operation(Context::genesis()))
+    }
+
     #[pyfunction]
     fn text_encoding(
         encoding: PyObjectRef,
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
@@ -106,24 +106,38 @@ impl VirtualMachine {
         )
     }
 
+    pub fn new_os_error(&self, msg: impl ToPyObject) -> PyRef<PyBaseException> {
+        self.new_os_subtype_error(self.ctx.exceptions.os_error.to_owned(), None, msg)
+            .upcast()
+    }
+
     pub fn new_os_subtype_error(
         &self,
         exc_type: PyTypeRef,
         errno: Option<i32>,
         msg: impl ToPyObject,
     ) -> PyRef<PyOSError> {
         debug_assert_eq!(exc_type.slots.basicsize, std::mem::size_of::<PyOSError>());
+        let msg = msg.to_pyobject(self);
+
+        fn new_os_subtype_error_impl(
+            vm: &VirtualMachine,
+            exc_type: PyTypeRef,
+            errno: Option<i32>,
+            msg: PyObjectRef,
+        ) -> PyRef<PyOSError> {
+            let args = match errno {
+                Some(e) => vec![vm.new_pyobj(e), msg],
+                None => vec![msg],
+            };
+            let payload =
+                PyOSError::py_new(&exc_type, args.into(), vm).expect("new_os_error usage error");
+            payload
+                .into_ref_with_type(vm, exc_type)
+                .expect("new_os_error usage error")
+        }
 
-        let errno_obj: PyObjectRef = match errno {
-            Some(e) => self.new_pyobj(e),
-            None => self.ctx.none(),
-        };
-        let args = vec![errno_obj, msg.to_pyobject(self)];
-        let payload =
-            PyOSError::py_new(&exc_type, args.into(), self).expect("new_os_error usage error");
-        payload
-            .into_ref_with_type(self, exc_type)
-            .expect("new_os_error usage error")
+        new_os_subtype_error_impl(self, exc_type, errno, msg)
     }
 
     /// Instantiate an exception with no arguments.
@@ -582,7 +596,6 @@ impl VirtualMachine {
     define_exception_fn!(fn new_eof_error, eof_error, EOFError);
     define_exception_fn!(fn new_attribute_error, attribute_error, AttributeError);
     define_exception_fn!(fn new_type_error, type_error, TypeError);
-    define_exception_fn!(fn new_os_error, os_error, OSError);
     define_exception_fn!(fn new_system_error, system_error, SystemError);
 
     // TODO: remove & replace with new_unicode_decode_error_real
