payload rework

Author: youknowone

crates/stdlib/src/bz2.rs

@@ -79,7 +79,7 @@ mod _bz2 {
             state
                 .decompress(data, max_length, BUFSIZ, vm)
                 .map_err(|e| match e {
-                    DecompressError::Decompress(err) => vm.new_os_error(err.to_string()),
+                    DecompressError::Decompress(err) => vm.new_simple_os_error(err.to_string()),
                     DecompressError::Eof(err) => err.to_pyexception(vm),
                 })
         }

crates/stdlib/src/lzma.rs

@@ -182,7 +182,7 @@ mod _lzma {
             state
                 .decompress(data, max_length, BUFSIZ, vm)
                 .map_err(|e| match e {
-                    DecompressError::Decompress(err) => vm.new_os_error(err.to_string()),
+                    DecompressError::Decompress(err) => vm.new_simple_os_error(err.to_string()),
                     DecompressError::Eof(err) => err.to_pyexception(vm),
                 })
         }

crates/stdlib/src/openssl.rs

@@ -1480,7 +1480,7 @@ mod _ssl {
                             vm.ctx.exceptions.file_not_found_error.to_owned(),
                             e.to_string(),
                         ),
-                        _ => vm.new_os_error(e.to_string()),
+                        _ => vm.new_simple_os_error(e.to_string()),
                     }
                 })?;
 
@@ -3550,10 +3550,10 @@ mod _ssl {
 
             let mut combined_pem = String::new();
             let entries = read_dir(root)
-                .map_err(|err| vm.new_os_error(format!("read cert root: {}", err)))?;
+                .map_err(|err| vm.new_simple_os_error(format!("read cert root: {}", err)))?;
             for entry in entries {
                 let entry =
-                    entry.map_err(|err| vm.new_os_error(format!("iter cert root: {}", err)))?;
+                    entry.map_err(|err| vm.new_simple_os_error(format!("iter cert root: {}", err)))?;
 
                 let path = entry.path();
                 if !path.is_file() {
@@ -3563,7 +3563,7 @@ mod _ssl {
                 File::open(&path)
                     .and_then(|mut file| file.read_to_string(&mut combined_pem))
                     .map_err(|err| {
-                        vm.new_os_error(format!("open cert file {}: {}", path.display(), err))
+                        vm.new_simple_os_error(format!("open cert file {}: {}", path.display(), err))
                     })?;
 
                 combined_pem.push('\n');

crates/stdlib/src/select.rs

@@ -580,7 +580,7 @@ mod decl {
                     return Err(vm.new_value_error("negative sizehint"));
                 }
                 if !matches!(args.flags, 0 | libc::EPOLL_CLOEXEC) {
-                    return Err(vm.new_os_error("invalid flags".to_owned()));
+                    return Err(vm.new_simple_os_error("invalid flags".to_owned()));
                 }
                 Self::new()
                     .map_err(|e| e.into_pyexception(vm))?

crates/stdlib/src/socket.rs

@@ -945,7 +945,7 @@ mod _socket {
                         ArgStrOrBytesLike::Str(s) => vm.fsencode(s)?,
                     };
                     socket2::SockAddr::unix(path)
-                        .map_err(|_| vm.new_os_error("AF_UNIX path too long".to_owned()).into())
+                        .map_err(|_| vm.new_simple_os_error("AF_UNIX path too long".to_owned()).into())
                 }
                 c::AF_INET => {
                     let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
@@ -996,7 +996,7 @@ mod _socket {
                     }
                     Ok(addr6.into())
                 }
-                _ => Err(vm.new_os_error(format!("{caller}(): bad family")).into()),
+                _ => Err(vm.new_simple_os_error(format!("{caller}(): bad family")).into()),
             }
         }
 
@@ -1421,10 +1421,10 @@ mod _socket {
                 .map(|(_, _, buf)| buf.len())
                 .try_fold(0, |sum, len| {
                     let space = checked_cmsg_space(len).ok_or_else(|| {
-                        vm.new_os_error("ancillary data item too large".to_owned())
+                        vm.new_simple_os_error("ancillary data item too large".to_owned())
                     })?;
                     usize::checked_add(sum, space)
-                        .ok_or_else(|| vm.new_os_error("too much ancillary data".to_owned()))
+                        .ok_or_else(|| vm.new_simple_os_error("too much ancillary data".to_owned()))
                 })?;
 
             let mut cmsg_buffer = vec![0u8; capacity];
@@ -1553,7 +1553,7 @@ mod _socket {
             } else {
                 if buflen <= 0 || buflen > 1024 {
                     return Err(vm
-                        .new_os_error("getsockopt buflen out of range".to_owned())
+                        .new_simple_os_error("getsockopt buflen out of range".to_owned())
                         .into());
                 }
                 let mut buf = vec![0u8; buflen as usize];
@@ -1739,7 +1739,7 @@ mod _socket {
         gethostname::gethostname()
             .into_string()
             .map(|hostname| vm.ctx.new_str(hostname))
-            .map_err(|err| vm.new_os_error(err.into_string().unwrap()))
+            .map_err(|err| vm.new_simple_os_error(err.into_string().unwrap()))
     }
 
     #[cfg(all(unix, not(target_os = "redox")))]
@@ -1755,15 +1755,15 @@ mod _socket {
             .parse::<Ipv4Addr>()
             .map(|ip_addr| Vec::<u8>::from(ip_addr.octets()))
             .map_err(|_| {
-                vm.new_os_error("illegal IP address string passed to inet_aton".to_owned())
+                vm.new_simple_os_error("illegal IP address string passed to inet_aton".to_owned())
             })
     }
 
     #[pyfunction]
     fn inet_ntoa(packed_ip: ArgBytesLike, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         let packed_ip = packed_ip.borrow_buf();
         let packed_ip = <&[u8; 4]>::try_from(&*packed_ip)
-            .map_err(|_| vm.new_os_error("packed IP wrong length for inet_ntoa".to_owned()))?;
+            .map_err(|_| vm.new_simple_os_error("packed IP wrong length for inet_ntoa".to_owned()))?;
         Ok(vm.ctx.new_str(Ipv4Addr::from(*packed_ip).to_string()))
     }
 
@@ -1785,7 +1785,7 @@ mod _socket {
         let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
         let serv = unsafe { c::getservbyname(cstr_name.as_ptr() as _, cstr_proto as _) };
         if serv.is_null() {
-            return Err(vm.new_os_error("service/proto not found".to_owned()));
+            return Err(vm.new_simple_os_error("service/proto not found".to_owned()));
         }
         let port = unsafe { (*serv).s_port };
         Ok(u16::from_be(port as u16))
@@ -1807,7 +1807,7 @@ mod _socket {
         let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
         let serv = unsafe { c::getservbyport(port.to_be() as _, cstr_proto as _) };
         if serv.is_null() {
-            return Err(vm.new_os_error("port/proto not found".to_owned()));
+            return Err(vm.new_simple_os_error("port/proto not found".to_owned()));
         }
         let s = unsafe { ffi::CStr::from_ptr((*serv).s_name as _) };
         Ok(s.to_string_lossy().into_owned())
@@ -2024,16 +2024,16 @@ mod _socket {
             c::AF_INET => ip_string
                 .as_str()
                 .parse::<Ipv4Addr>()
-                .map_err(|_| vm.new_os_error(ERROR_MSG.to_owned()))?
+                .map_err(|_| vm.new_simple_os_error(ERROR_MSG.to_owned()))?
                 .octets()
                 .to_vec(),
             c::AF_INET6 => ip_string
                 .as_str()
                 .parse::<Ipv6Addr>()
-                .map_err(|_| vm.new_os_error(ERROR_MSG.to_owned()))?
+                .map_err(|_| vm.new_simple_os_error(ERROR_MSG.to_owned()))?
                 .octets()
                 .to_vec(),
-            _ => return Err(vm.new_os_error("Address family not supported by protocol".to_owned())),
+            _ => return Err(vm.new_simple_os_error("Address family not supported by protocol".to_owned())),
         };
         Ok(ip_addr)
     }
@@ -2063,7 +2063,7 @@ mod _socket {
         let cstr = name.to_cstring(vm)?;
         let proto = unsafe { c::getprotobyname(cstr.as_ptr() as _) };
         if proto.is_null() {
-            return Err(vm.new_os_error("protocol not found".to_owned()));
+            return Err(vm.new_simple_os_error("protocol not found".to_owned()));
         }
         let num = unsafe { (*proto).p_proto };
         Ok(vm.ctx.new_int(num).into())
@@ -2096,14 +2096,14 @@ mod _socket {
         let mut ainfo = res.next().unwrap();
         if res.next().is_some() {
             return Err(vm
-                .new_os_error("sockaddr resolved to multiple addresses".to_owned())
+                .new_simple_os_error("sockaddr resolved to multiple addresses".to_owned())
                 .into());
         }
         match &mut ainfo.sockaddr {
             SocketAddr::V4(_) => {
                 if address.len() != 2 {
                     return Err(vm
-                        .new_os_error("IPv4 sockaddr must be 2 tuple".to_owned())
+                        .new_simple_os_error("IPv4 sockaddr must be 2 tuple".to_owned())
                         .into());
                 }
             }
@@ -2146,7 +2146,7 @@ mod _socket {
 
         let ret = unsafe { c::if_nametoindex(name.as_ptr() as _) };
         if ret == 0 {
-            Err(vm.new_os_error("no interface with this name".to_owned()))
+            Err(vm.new_simple_os_error("no interface with this name".to_owned()))
         } else {
             Ok(ret)
         }
@@ -2271,7 +2271,7 @@ mod _socket {
             let ainfo = res.next().unwrap()?;
             if res.next().is_some() {
                 return Err(vm
-                    .new_os_error("wildcard resolved to multiple address".to_owned())
+                    .new_simple_os_error("wildcard resolved to multiple address".to_owned())
                     .into());
             }
             return Ok(ainfo.sockaddr);
@@ -2281,7 +2281,7 @@ mod _socket {
                 c::AF_INET | c::AF_UNSPEC => {}
                 _ => {
                     return Err(vm
-                        .new_os_error("address family mismatched".to_owned())
+                        .new_simple_os_error("address family mismatched".to_owned())
                         .into());
                 }
             }

crates/stdlib/src/ssl.rs

@@ -1890,7 +1890,7 @@ mod _ssl {
             // Validate that the file contains DH parameters
             // Read the file and check for DH PARAMETERS header
             let contents =
-                std::fs::read_to_string(&path_str).map_err(|e| vm.new_os_error(e.to_string()))?;
+                std::fs::read_to_string(&path_str).map_err(|e| vm.new_simple_os_error(e.to_string()))?;
 
             if !contents.contains("BEGIN DH PARAMETERS")
                 && !contents.contains("BEGIN X9.42 DH PARAMETERS")
@@ -2258,7 +2258,7 @@ mod _ssl {
                 std::io::ErrorKind::NotFound | std::io::ErrorKind::PermissionDenied => {
                     e.into_pyexception(vm)
                 }
-                _ => vm.new_os_error(e.to_string()),
+                _ => vm.new_simple_os_error(e.to_string()),
             })?;
 
             match self.try_parse_crl(&data) {
@@ -2468,7 +2468,7 @@ mod _ssl {
                 // Clear the error so it's only raised once
                 *self.deferred_cert_error.write() = None;
                 // Raise OSError with the stored error message
-                return Err(vm.new_os_error(error_msg));
+                return Err(vm.new_simple_os_error(error_msg));
             }
             Ok(())
         }
@@ -2683,10 +2683,10 @@ mod _ssl {
             let py_socket: PyRef<PySocket> = self.sock.clone().try_into_value(vm)?;
             let socket = py_socket
                 .sock()
-                .map_err(|e| vm.new_os_error(format!("Failed to get socket: {e}")))?;
+                .map_err(|e| vm.new_simple_os_error(format!("Failed to get socket: {e}")))?;
 
             let timed_out = sock_select(&socket, kind, timeout)
-                .map_err(|e| vm.new_os_error(format!("select failed: {e}")))?;
+                .map_err(|e| vm.new_simple_os_error(format!("select failed: {e}")))?;
 
             Ok(timed_out)
         }
@@ -3923,7 +3923,7 @@ mod _ssl {
                 let mut buf = vec![0u8; SSL3_RT_MAX_PLAIN_LENGTH];
                 let written = conn
                     .write_tls(&mut buf.as_mut_slice())
-                    .map_err(|e| vm.new_os_error(format!("TLS write failed: {e}")))?;
+                    .map_err(|e| vm.new_simple_os_error(format!("TLS write failed: {e}")))?;
 
                 if written == 0 {
                     break;
@@ -3976,7 +3976,7 @@ mod _ssl {
             // Process any remaining packets and check peer_has_closed
             let io_state = conn
                 .process_new_packets()
-                .map_err(|e| vm.new_os_error(format!("Failed to process packets: {e}")))?;
+                .map_err(|e| vm.new_simple_os_error(format!("Failed to process packets: {e}")))?;
 
             Ok(io_state.peer_has_closed())
         }
@@ -4418,7 +4418,7 @@ mod _ssl {
         let rng = SystemRandom::new();
         let mut buf = vec![0u8; n_usize];
         rng.fill(&mut buf)
-            .map_err(|_| vm.new_os_error("Failed to generate random bytes"))?;
+            .map_err(|_| vm.new_simple_os_error("Failed to generate random bytes"))?;
         Ok(PyBytesRef::from(vm.ctx.new_bytes(buf)))
     }
 
@@ -4437,7 +4437,7 @@ mod _ssl {
     fn _test_decode_cert(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         // Read certificate file
         let cert_data = std::fs::read(path.as_str()).map_err(|e| {
-            vm.new_os_error(format!(
+            vm.new_simple_os_error(format!(
                 "Failed to read certificate file {}: {}",
                 path.as_str(),
                 e

crates/vm/src/builtins/int.rs

@@ -207,23 +207,26 @@ fn inner_truediv(i1: &BigInt, i2: &BigInt, vm: &VirtualMachine) -> PyResult {
 impl Constructor for PyInt {
     type Args = IntOptions;
 
-    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+    fn py_new_ref(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         if cls.is(vm.ctx.types.bool_type) {
             return Err(vm.new_type_error("int.__new__(bool) is not safe, use bool.__new__()"));
         }
 
         // Optimization: return exact int as-is
         if cls.is(vm.ctx.types.int_type) && args.args.len() == 1 && args.kwargs.is_empty() {
-            if args.args[0].class().is(vm.ctx.types.int_type) {
-                let mut args = args;
-                return Ok(args.args.pop().expect("length checked"));
+            unsafe { 
+                if args.args[0].class().is(vm.ctx.types.int_type) {
+                    let mut args = args;
+                    let int_arg = args.args.pop().expect("length checked");
+                    return Ok(int_arg.downcast_unchecked());
+                }
             }
         }
 
         let options: Self::Args = args.bind(vm)?;
 
         let payload = Self::py_new(&cls, options, vm)?;
-        payload.into_ref_with_type(vm, cls).map(Into::into)
+        payload.into_ref_with_type(vm, cls)
     }
 
     fn py_new(_cls: &Py<PyType>, options: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {

crates/vm/src/exceptions.rs

@@ -1468,43 +1468,32 @@ pub(super) mod types {
             })
         }
 
-        #[cfg(not(target_arch = "wasm32"))]
         fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             // We need this method, because of how `CPython` copies `init`
             // from `BaseException` in `SimpleExtendsException` macro.
             // See: `BaseException_new`
             if *cls.name() == *vm.ctx.exceptions.os_error.name() {
-                if let Some(error) = Self::optional_new(args.args.to_vec(), vm) {
-                    return error.to_pyresult(vm);
+                let args_vec = args.args.to_vec();
+                let len = args_vec.len();
+                if (2..=5).contains(&len) {
+                    let errno = &args_vec[0];
+                    if let Some(error) = errno
+                        .downcast_ref::<PyInt>()
+                        .and_then(|errno| errno.try_to_primitive::<i32>(vm).ok())
+                        .and_then(|errno| super::errno_to_exc_type(errno, vm))
+                        .and_then(|typ| vm.invoke_exception(typ.to_owned(), args_vec).ok())
+                    {
+                        return error.to_pyresult(vm);
+                    }
                 }
             }
             let payload = Self::py_new(&cls, args, vm)?;
             payload.into_ref_with_type(vm, cls).map(Into::into)
         }
-
-        #[cfg(target_arch = "wasm32")]
-        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let payload = Self::py_new(&cls, args, vm)?;
-            payload.into_ref_with_type(vm, cls).map(Into::into)
-        }
     }
 
     #[pyexception(with(Constructor))]
     impl PyOSError {
-        #[cfg(not(target_arch = "wasm32"))]
-        fn optional_new(args: Vec<PyObjectRef>, vm: &VirtualMachine) -> Option<PyBaseExceptionRef> {
-            let len = args.len();
-            if (2..=5).contains(&len) {
-                let errno = &args[0];
-                errno
-                    .downcast_ref::<PyInt>()
-                    .and_then(|errno| errno.try_to_primitive::<i32>(vm).ok())
-                    .and_then(|errno| super::errno_to_exc_type(errno, vm))
-                    .and_then(|typ| vm.invoke_exception(typ.to_owned(), args.to_vec()).ok())
-            } else {
-                None
-            }
-        }
         #[pyslot]
         #[pymethod(name = "__init__")]
         pub fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {

crates/vm/src/stdlib/builtins.rs

@@ -488,9 +488,9 @@ mod builtins {
                 ReadlineResult::Interrupt => {
                     Err(vm.new_exception_empty(vm.ctx.exceptions.keyboard_interrupt.to_owned()))
                 }
-                ReadlineResult::Io(e) => Err(vm.new_os_error(e.to_string())),
+                ReadlineResult::Io(e) => Err(vm.new_simple_os_error(e.to_string())),
                 #[cfg(unix)]
-                ReadlineResult::OsError(num) => Err(vm.new_os_error(num.to_string())),
+                ReadlineResult::OsError(num) => Err(vm.new_simple_os_error(num.to_string())),
                 ReadlineResult::Other(e) => Err(vm.new_runtime_error(e.to_string())),
             }
         } else {