RustPython
diff --git a/‎crates/stdlib/src/_asyncio.rs‎
Lines changed: 22 additions & 38 deletions b/‎crates/stdlib/src/_asyncio.rs‎
Lines changed: 22 additions & 38 deletions
diff --git a/‎crates/stdlib/src/_remote_debugging.rs‎
Lines changed: 1 addition & 1 deletion b/‎crates/stdlib/src/_remote_debugging.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/stdlib/src/_sqlite3.rs‎
Lines changed: 3 additions & 3 deletions b/‎crates/stdlib/src/_sqlite3.rs‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎crates/stdlib/src/faulthandler.rs‎
Lines changed: 7 additions & 11 deletions b/‎crates/stdlib/src/faulthandler.rs‎
Lines changed: 7 additions & 11 deletions
diff --git a/‎crates/stdlib/src/hashlib.rs‎
Lines changed: 10 additions & 10 deletions b/‎crates/stdlib/src/hashlib.rs‎
Lines changed: 10 additions & 10 deletions
diff --git a/‎crates/stdlib/src/math.rs‎
Lines changed: 4 additions & 4 deletions b/‎crates/stdlib/src/math.rs‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎crates/stdlib/src/mmap.rs‎
Lines changed: 4 additions & 6 deletions b/‎crates/stdlib/src/mmap.rs‎
Lines changed: 4 additions & 6 deletions
@@ -151,7 +151,7 @@ pub(crate) mod _asyncio {
         fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
             // Future does not accept positional arguments
             if !args.args.is_empty() {
-                return Err(vm.new_type_error("Future() takes no positional arguments".to_string()));
+                return Err(vm.new_type_error("Future() takes no positional arguments"));
             }
             // Extract only 'loop' keyword argument
             let loop_ = args.kwargs.get("loop").cloned();
@@ -265,7 +265,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn set_result(zelf: PyRef<Self>, result: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             if zelf.fut_state.load() != FutureState::Pending {
                 return Err(new_invalid_state_error(vm, "invalid state"));
@@ -283,7 +283,7 @@ pub(crate) mod _asyncio {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             if zelf.fut_state.load() != FutureState::Pending {
                 return Err(new_invalid_state_error(vm, "invalid state"));
@@ -336,7 +336,7 @@ pub(crate) mod _asyncio {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let ctx = match args.context.flatten() {
                 Some(c) => c,
@@ -364,7 +364,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn remove_done_callback(&self, func: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
             if self.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let mut cleared_callback0 = 0usize;
 
@@ -461,7 +461,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn cancel(zelf: PyRef<Self>, args: CancelArgs, vm: &VirtualMachine) -> PyResult<bool> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             if zelf.fut_state.load() != FutureState::Pending {
                 // Clear log_tb even when cancel fails
@@ -598,9 +598,7 @@ pub(crate) mod _asyncio {
                     self.fut_blocking.store(v, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -670,16 +668,12 @@ pub(crate) mod _asyncio {
             match value {
                 PySetterValue::Assign(v) => {
                     if v {
-                        return Err(vm.new_value_error(
-                            "_log_traceback can only be set to False".to_string(),
-                        ));
+                        return Err(vm.new_value_error("_log_traceback can only be set to False"));
                     }
                     self.fut_log_tb.store(false, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -1055,7 +1049,7 @@ pub(crate) mod _asyncio {
                 // Must be a subclass of BaseException
                 if !exc_class.fast_issubclass(vm.ctx.exceptions.base_exception_type) {
                     return Err(vm.new_type_error(
-                        "exceptions must be classes or instances deriving from BaseException, not type".to_string()
+                        "exceptions must be classes or instances deriving from BaseException, not type"
                     ));
                 }
 
@@ -1072,9 +1066,9 @@ pub(crate) mod _asyncio {
                 if let OptionalArg::Present(ref val) = exc_val
                     && !vm.is_none(val)
                 {
-                    return Err(vm.new_type_error(
-                        "instance exception may not have a separate value".to_string(),
-                    ));
+                    return Err(
+                        vm.new_type_error("instance exception may not have a separate value")
+                    );
                 }
                 exc_type
             } else {
@@ -1339,7 +1333,7 @@ pub(crate) mod _asyncio {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if zelf.base.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let ctx = match args.context.flatten() {
                 Some(c) => c,
@@ -1367,7 +1361,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn remove_done_callback(&self, func: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
             if self.base.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let mut cleared_callback0 = 0usize;
 
@@ -1686,9 +1680,7 @@ pub(crate) mod _asyncio {
                     self.base.fut_blocking.store(v, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -1718,7 +1710,7 @@ pub(crate) mod _asyncio {
                     Ok(())
                 }
                 PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("can't delete _log_destroy_pending".to_owned()))
+                    Err(vm.new_attribute_error("can't delete _log_destroy_pending"))
                 }
             }
         }
@@ -1737,16 +1729,12 @@ pub(crate) mod _asyncio {
             match value {
                 PySetterValue::Assign(v) => {
                     if v {
-                        return Err(vm.new_value_error(
-                            "_log_traceback can only be set to False".to_string(),
-                        ));
+                        return Err(vm.new_value_error("_log_traceback can only be set to False"));
                     }
                     self.base.fut_log_tb.store(false, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -2532,14 +2520,10 @@ pub(crate) mod _asyncio {
             let running_task = vm.asyncio_running_task.borrow();
             match running_task.as_ref() {
                 None => {
-                    return Err(vm.new_runtime_error(
-                        "_leave_task: task is not the current task".to_owned(),
-                    ));
+                    return Err(vm.new_runtime_error("_leave_task: task is not the current task"));
                 }
                 Some(current) if !current.is(&task) => {
-                    return Err(vm.new_runtime_error(
-                        "_leave_task: task is not the current task".to_owned(),
-                    ));
+                    return Err(vm.new_runtime_error("_leave_task: task is not the current task"));
                 }
                 _ => {}
             }
@@ -2777,7 +2761,7 @@ pub(crate) mod _asyncio {
             .ok_or_else(|| vm.new_attribute_error("CancelledError not found"))?;
         exc_type
             .downcast()
-            .map_err(|_| vm.new_type_error("CancelledError is not a type".to_string()))
+            .map_err(|_| vm.new_type_error("CancelledError is not a type"))
     }
 
     fn is_cancelled_error(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool {
 
@@ -98,7 +98,7 @@ mod _remote_debugging {
         type Args = FuncArgs;
 
         fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-            Err(vm.new_not_implemented_error("_remote_debugging is not available".to_owned()))
+            Err(vm.new_not_implemented_error("_remote_debugging is not available"))
         }
     }
 
 
@@ -1512,9 +1512,9 @@ mod _sqlite3 {
                     let _ = unsafe { self.isolation_level.swap(value) };
                     Ok(())
                 }
-                PySetterValue::Delete => Err(vm.new_attribute_error(
-                    "'isolation_level' attribute cannot be deleted".to_owned(),
-                )),
+                PySetterValue::Delete => {
+                    Err(vm.new_attribute_error("'isolation_level' attribute cannot be deleted"))
+                }
             }
         }
 
 
@@ -463,7 +463,7 @@ mod decl {
 
         // Install signal handlers
         if !faulthandler_enable_internal() {
-            return Err(vm.new_runtime_error("Failed to enable faulthandler".to_owned()));
+            return Err(vm.new_runtime_error("Failed to enable faulthandler"));
         }
 
         Ok(())
@@ -802,19 +802,15 @@ mod decl {
                 // Check if it's an integer (file descriptor)
                 if let Ok(fd) = f.try_to_value::<i32>(vm) {
                     if fd < 0 {
-                        return Err(
-                            vm.new_value_error("file is not a valid file descriptor".to_owned())
-                        );
+                        return Err(vm.new_value_error("file is not a valid file descriptor"));
                     }
                     return Ok(fd);
                 }
                 // Try to get fileno() from file object
                 let fileno = vm.call_method(&f, "fileno", ())?;
                 let fd: i32 = fileno.try_to_value(vm)?;
                 if fd < 0 {
-                    return Err(
-                        vm.new_value_error("file is not a valid file descriptor".to_owned())
-                    );
+                    return Err(vm.new_value_error("file is not a valid file descriptor"));
                 }
                 // Try to flush the file
                 let _ = vm.call_method(&f, "flush", ());
@@ -824,7 +820,7 @@ mod decl {
                 // file=None or file not passed: fall back to sys.stderr
                 let stderr = vm.sys_module.get_attr("stderr", vm)?;
                 if vm.is_none(&stderr) {
-                    return Err(vm.new_runtime_error("sys.stderr is None".to_owned()));
+                    return Err(vm.new_runtime_error("sys.stderr is None"));
                 }
                 let fileno = vm.call_method(&stderr, "fileno", ())?;
                 let fd: i32 = fileno.try_to_value(vm)?;
@@ -912,15 +908,15 @@ mod decl {
         let timeout: f64 = args.timeout.into_float();
 
         if timeout <= 0.0 {
-            return Err(vm.new_value_error("timeout must be greater than 0".to_owned()));
+            return Err(vm.new_value_error("timeout must be greater than 0"));
         }
 
         let fd = get_fd_from_file_opt(args.file, vm)?;
 
         // Convert timeout to microseconds
         let timeout_us = (timeout * 1_000_000.0) as u64;
         if timeout_us == 0 {
-            return Err(vm.new_value_error("timeout must be greater than 0".to_owned()));
+            return Err(vm.new_value_error("timeout must be greater than 0"));
         }
 
         let header = format_timeout(timeout_us);
@@ -1098,7 +1094,7 @@ mod decl {
 
         // Check if signal is in valid range
         if !(1..64).contains(&signum) {
-            return Err(vm.new_value_error("signal number out of range".to_owned()));
+            return Err(vm.new_value_error("signal number out of range"));
         }
 
         Ok(())
 
@@ -210,8 +210,7 @@ pub mod _hashlib {
             (Some(_), Some(_)) => Err(vm.new_type_error(
                 "'data' and 'string' are mutually exclusive \
                  and support for 'string' keyword parameter \
-                 is slated for removal in a future version."
-                    .to_owned(),
+                 is slated for removal in a future version.",
             )),
         }
     }
@@ -306,7 +305,7 @@ pub mod _hashlib {
     impl PyHmac {
         #[pyslot]
         fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error("cannot create '_hashlib.HMAC' instances".to_owned()))
+            Err(vm.new_type_error("cannot create '_hashlib.HMAC' instances"))
         }
 
         #[pygetset]
@@ -758,9 +757,10 @@ pub mod _hashlib {
 
     #[pyfunction]
     fn hmac_new(args: NewHMACHashArgs, vm: &VirtualMachine) -> PyResult<PyHmac> {
-        let digestmod = args.digestmod.into_option().ok_or_else(|| {
-            vm.new_type_error("Missing required parameter 'digestmod'.".to_owned())
-        })?;
+        let digestmod = args
+            .digestmod
+            .into_option()
+            .ok_or_else(|| vm.new_type_error("Missing required parameter 'digestmod'."))?;
         let name = resolve_digestmod(&digestmod, vm)?;
 
         let key_buf = args.key.borrow_buf();
@@ -833,10 +833,10 @@ pub mod _hashlib {
         let name = args.hash_name.as_str().to_lowercase();
 
         if args.iterations < 1 {
-            return Err(vm.new_value_error("iteration value must be greater than 0.".to_owned()));
+            return Err(vm.new_value_error("iteration value must be greater than 0."));
         }
         let rounds = u32::try_from(args.iterations)
-            .map_err(|_| vm.new_overflow_error("iteration value is too great.".to_owned()))?;
+            .map_err(|_| vm.new_overflow_error("iteration value is too great."))?;
 
         let dklen: usize = match args.dklen.into_option() {
             Some(obj) if vm.is_none(&obj) => {
@@ -845,10 +845,10 @@ pub mod _hashlib {
             Some(obj) => {
                 let len: i64 = obj.try_into_value(vm)?;
                 if len < 1 {
-                    return Err(vm.new_value_error("key length must be greater than 0.".to_owned()));
+                    return Err(vm.new_value_error("key length must be greater than 0."));
                 }
                 usize::try_from(len)
-                    .map_err(|_| vm.new_overflow_error("key length is too great.".to_owned()))?
+                    .map_err(|_| vm.new_overflow_error("key length is too great."))?
             }
             None => hash_digest_size(&name).ok_or_else(|| unsupported_hash(&name, vm))?,
         };
 
@@ -102,13 +102,13 @@ mod math {
                 )));
             }
             if b == 1.0 {
-                return Err(vm.new_value_error("math domain error".to_owned()));
+                return Err(vm.new_value_error("math domain error"));
             }
         }
         // Handle BigInt specially for large values (only for actual int type, not float)
         if let Some(i) = x.downcast_ref::<PyInt>() {
             return pymath::math::log_bigint(i.as_bigint(), base).map_err(|err| match err {
-                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input"),
                 _ => pymath_exception(err, vm),
             });
         }
@@ -132,7 +132,7 @@ mod math {
         // Handle BigInt specially for large values (only for actual int type, not float)
         if let Some(i) = x.downcast_ref::<PyInt>() {
             return pymath::math::log2_bigint(i.as_bigint()).map_err(|err| match err {
-                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input"),
                 _ => pymath_exception(err, vm),
             });
         }
@@ -151,7 +151,7 @@ mod math {
         // Handle BigInt specially for large values (only for actual int type, not float)
         if let Some(i) = x.downcast_ref::<PyInt>() {
             return pymath::math::log10_bigint(i.as_bigint()).map_err(|err| match err {
-                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input"),
                 _ => pymath_exception(err, vm),
             });
         }
 
@@ -557,13 +557,11 @@ mod mmap {
             // Parse tagname: None or a string
             let tag_str: Option<String> = match tagname {
                 Some(ref obj) if !vm.is_none(obj) => {
-                    let s = obj.try_to_value::<String>(vm).map_err(|_| {
-                        vm.new_type_error("tagname must be a string or None".to_owned())
-                    })?;
+                    let s = obj
+                        .try_to_value::<String>(vm)
+                        .map_err(|_| vm.new_type_error("tagname must be a string or None"))?;
                     if s.contains('\0') {
-                        return Err(vm.new_value_error(
-                            "tagname must not contain null characters".to_owned(),
-                        ));
+                        return Err(vm.new_value_error("tagname must not contain null characters"));
                     }
                     Some(s)
                 }
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ pub(crate) mod _asyncio {`
`151`	`151`	`fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {`
`152`	`152`	`// Future does not accept positional arguments`
`153`	`153`	`if !args.args.is_empty() {`
`154`		`- return Err(vm.new_type_error("Future() takes no positional arguments".to_string()));`
	`154`	`+ return Err(vm.new_type_error("Future() takes no positional arguments"));`
`155`	`155`	`}`
`156`	`156`	`// Extract only 'loop' keyword argument`
`157`	`157`	`let loop_ = args.kwargs.get("loop").cloned();`
`@@ -265,7 +265,7 @@ pub(crate) mod _asyncio {`
`265`	`265`	`#[pymethod]`
`266`	`266`	`fn set_result(zelf: PyRef<Self>, result: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {`
`267`	`267`	`if zelf.fut_loop.read().is_none() {`
`268`		`- return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));`
	`268`	`+ return Err(vm.new_runtime_error("Future object is not initialized."));`
`269`	`269`	`}`
`270`	`270`	`if zelf.fut_state.load() != FutureState::Pending {`
`271`	`271`	`return Err(new_invalid_state_error(vm, "invalid state"));`
`@@ -283,7 +283,7 @@ pub(crate) mod _asyncio {`
`283`	`283`	`vm: &VirtualMachine,`
`284`	`284`	`) -> PyResult<()> {`
`285`	`285`	`if zelf.fut_loop.read().is_none() {`
`286`		`- return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));`
	`286`	`+ return Err(vm.new_runtime_error("Future object is not initialized."));`
`287`	`287`	`}`
`288`	`288`	`if zelf.fut_state.load() != FutureState::Pending {`
`289`	`289`	`return Err(new_invalid_state_error(vm, "invalid state"));`
`@@ -336,7 +336,7 @@ pub(crate) mod _asyncio {`
`336`	`336`	`vm: &VirtualMachine,`
`337`	`337`	`) -> PyResult<()> {`
`338`	`338`	`if zelf.fut_loop.read().is_none() {`
`339`		`- return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));`
	`339`	`+ return Err(vm.new_runtime_error("Future object is not initialized."));`
`340`	`340`	`}`
`341`	`341`	`let ctx = match args.context.flatten() {`
`342`	`342`	`Some(c) => c,`
`@@ -364,7 +364,7 @@ pub(crate) mod _asyncio {`
`364`	`364`	`#[pymethod]`
`365`	`365`	`fn remove_done_callback(&self, func: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {`
`366`	`366`	`if self.fut_loop.read().is_none() {`
`367`		`- return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));`
	`367`	`+ return Err(vm.new_runtime_error("Future object is not initialized."));`
`368`	`368`	`}`
`369`	`369`	`let mut cleared_callback0 = 0usize;`
`370`	`370`
`@@ -461,7 +461,7 @@ pub(crate) mod _asyncio {`
`461`	`461`	`#[pymethod]`
`462`	`462`	`fn cancel(zelf: PyRef<Self>, args: CancelArgs, vm: &VirtualMachine) -> PyResult<bool> {`
`463`	`463`	`if zelf.fut_loop.read().is_none() {`
`464`		`- return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));`
	`464`	`+ return Err(vm.new_runtime_error("Future object is not initialized."));`
`465`	`465`	`}`
`466`	`466`	`if zelf.fut_state.load() != FutureState::Pending {`
`467`	`467`	`// Clear log_tb even when cancel fails`
`@@ -598,9 +598,7 @@ pub(crate) mod _asyncio {`
`598`	`598`	`self.fut_blocking.store(v, Ordering::Relaxed);`
`599`	`599`	`Ok(())`
`600`	`600`	`}`
`601`		`- PySetterValue::Delete => {`
`602`		`- Err(vm.new_attribute_error("cannot delete attribute".to_string()))`
`603`		`- }`
	`601`	`+ PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),`
`604`	`602`	`}`
`605`	`603`	`}`
`606`	`604`
`@@ -670,16 +668,12 @@ pub(crate) mod _asyncio {`
`670`	`668`	`match value {`
`671`	`669`	`PySetterValue::Assign(v) => {`
`672`	`670`	`if v {`
`673`		`- return Err(vm.new_value_error(`
`674`		`- "_log_traceback can only be set to False".to_string(),`
`675`		`- ));`
	`671`	`+ return Err(vm.new_value_error("_log_traceback can only be set to False"));`
`676`	`672`	`}`
`677`	`673`	`self.fut_log_tb.store(false, Ordering::Relaxed);`
`678`	`674`	`Ok(())`
`679`	`675`	`}`
`680`		`- PySetterValue::Delete => {`
`681`		`- Err(vm.new_attribute_error("cannot delete attribute".to_string()))`
`682`		`- }`
	`676`	`+ PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),`
`683`	`677`	`}`
`684`	`678`	`}`
`685`	`679`
`@@ -1055,7 +1049,7 @@ pub(crate) mod _asyncio {`
`1055`	`1049`	`// Must be a subclass of BaseException`
`1056`	`1050`	`if !exc_class.fast_issubclass(vm.ctx.exceptions.base_exception_type) {`
`1057`	`1051`	`return Err(vm.new_type_error(`
`1058`		`- "exceptions must be classes or instances deriving from BaseException, not type".to_string()`
	`1052`	`+ "exceptions must be classes or instances deriving from BaseException, not type"`
`1059`	`1053`	`));`
`1060`	`1054`	`}`
`1061`	`1055`
`@@ -1072,9 +1066,9 @@ pub(crate) mod _asyncio {`
`1072`	`1066`	`if let OptionalArg::Present(ref val) = exc_val`
`1073`	`1067`	`&& !vm.is_none(val)`
`1074`	`1068`	`{`
`1075`		`- return Err(vm.new_type_error(`
`1076`		`- "instance exception may not have a separate value".to_string(),`
`1077`		`- ));`
	`1069`	`+ return Err(`
	`1070`	`+ vm.new_type_error("instance exception may not have a separate value")`
	`1071`	`+ );`
`1078`	`1072`	`}`
`1079`	`1073`	`exc_type`
`1080`	`1074`	`} else {`
`@@ -1339,7 +1333,7 @@ pub(crate) mod _asyncio {`
`1339`	`1333`	`vm: &VirtualMachine,`
`1340`	`1334`	`) -> PyResult<()> {`
`1341`	`1335`	`if zelf.base.fut_loop.read().is_none() {`
`1342`		`- return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));`
	`1336`	`+ return Err(vm.new_runtime_error("Future object is not initialized."));`
`1343`	`1337`	`}`
`1344`	`1338`	`let ctx = match args.context.flatten() {`
`1345`	`1339`	`Some(c) => c,`
`@@ -1367,7 +1361,7 @@ pub(crate) mod _asyncio {`
`1367`	`1361`	`#[pymethod]`
`1368`	`1362`	`fn remove_done_callback(&self, func: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {`
`1369`	`1363`	`if self.base.fut_loop.read().is_none() {`
`1370`		`- return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));`
	`1364`	`+ return Err(vm.new_runtime_error("Future object is not initialized."));`
`1371`	`1365`	`}`
`1372`	`1366`	`let mut cleared_callback0 = 0usize;`
`1373`	`1367`
`@@ -1686,9 +1680,7 @@ pub(crate) mod _asyncio {`
`1686`	`1680`	`self.base.fut_blocking.store(v, Ordering::Relaxed);`
`1687`	`1681`	`Ok(())`
`1688`	`1682`	`}`
`1689`		`- PySetterValue::Delete => {`
`1690`		`- Err(vm.new_attribute_error("cannot delete attribute".to_string()))`
`1691`		`- }`
	`1683`	`+ PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),`
`1692`	`1684`	`}`
`1693`	`1685`	`}`
`1694`	`1686`
`@@ -1718,7 +1710,7 @@ pub(crate) mod _asyncio {`
`1718`	`1710`	`Ok(())`
`1719`	`1711`	`}`
`1720`	`1712`	`PySetterValue::Delete => {`
`1721`		`- Err(vm.new_attribute_error("can't delete _log_destroy_pending".to_owned()))`
	`1713`	`+ Err(vm.new_attribute_error("can't delete _log_destroy_pending"))`
`1722`	`1714`	`}`
`1723`	`1715`	`}`
`1724`	`1716`	`}`
`@@ -1737,16 +1729,12 @@ pub(crate) mod _asyncio {`
`1737`	`1729`	`match value {`
`1738`	`1730`	`PySetterValue::Assign(v) => {`
`1739`	`1731`	`if v {`
`1740`		`- return Err(vm.new_value_error(`
`1741`		`- "_log_traceback can only be set to False".to_string(),`
`1742`		`- ));`
	`1732`	`+ return Err(vm.new_value_error("_log_traceback can only be set to False"));`
`1743`	`1733`	`}`
`1744`	`1734`	`self.base.fut_log_tb.store(false, Ordering::Relaxed);`
`1745`	`1735`	`Ok(())`
`1746`	`1736`	`}`
`1747`		`- PySetterValue::Delete => {`
`1748`		`- Err(vm.new_attribute_error("cannot delete attribute".to_string()))`
`1749`		`- }`
	`1737`	`+ PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),`
`1750`	`1738`	`}`
`1751`	`1739`	`}`
`1752`	`1740`
`@@ -2532,14 +2520,10 @@ pub(crate) mod _asyncio {`
`2532`	`2520`	`let running_task = vm.asyncio_running_task.borrow();`
`2533`	`2521`	`match running_task.as_ref() {`
`2534`	`2522`	`None => {`
`2535`		`- return Err(vm.new_runtime_error(`
`2536`		`- "_leave_task: task is not the current task".to_owned(),`
`2537`		`- ));`
	`2523`	`+ return Err(vm.new_runtime_error("_leave_task: task is not the current task"));`
`2538`	`2524`	`}`
`2539`	`2525`	`Some(current) if !current.is(&task) => {`
`2540`		`- return Err(vm.new_runtime_error(`
`2541`		`- "_leave_task: task is not the current task".to_owned(),`
`2542`		`- ));`
	`2526`	`+ return Err(vm.new_runtime_error("_leave_task: task is not the current task"));`
`2543`	`2527`	`}`
`2544`	`2528`	`_ => {}`
`2545`	`2529`	`}`
`@@ -2777,7 +2761,7 @@ pub(crate) mod _asyncio {`
`2777`	`2761`	`.ok_or_else(\|\| vm.new_attribute_error("CancelledError not found"))?;`
`2778`	`2762`	`exc_type`
`2779`	`2763`	`.downcast()`
`2780`		`- .map_err(\|_\| vm.new_type_error("CancelledError is not a type".to_string()))`
	`2764`	`+ .map_err(\|_\| vm.new_type_error("CancelledError is not a type"))`
`2781`	`2765`	`}`
`2782`	`2766`
`2783`	`2767`	`fn is_cancelled_error(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool {`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ mod _remote_debugging {`
`98`	`98`	`type Args = FuncArgs;`
`99`	`99`
`100`	`100`	`fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {`
`101`		`- Err(vm.new_not_implemented_error("_remote_debugging is not available".to_owned()))`
	`101`	`+ Err(vm.new_not_implemented_error("_remote_debugging is not available"))`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
Original file line number	Diff line number	Diff line change
`@@ -1512,9 +1512,9 @@ mod _sqlite3 {`
`1512`	`1512`	`let _ = unsafe { self.isolation_level.swap(value) };`
`1513`	`1513`	`Ok(())`
`1514`	`1514`	`}`
`1515`		`- PySetterValue::Delete => Err(vm.new_attribute_error(`
`1516`		`- "'isolation_level' attribute cannot be deleted".to_owned(),`
`1517`		`- )),`
	`1515`	`+ PySetterValue::Delete => {`
	`1516`	`+ Err(vm.new_attribute_error("'isolation_level' attribute cannot be deleted"))`
	`1517`	`+ }`
`1518`	`1518`	`}`
`1519`	`1519`	`}`
`1520`	`1520`
Original file line number	Diff line number	Diff line change
`@@ -102,13 +102,13 @@ mod math {`
`102`	`102`	`)));`
`103`	`103`	`}`
`104`	`104`	`if b == 1.0 {`
`105`		`- return Err(vm.new_value_error("math domain error".to_owned()));`
	`105`	`+ return Err(vm.new_value_error("math domain error"));`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`// Handle BigInt specially for large values (only for actual int type, not float)`
`109`	`109`	`if let Some(i) = x.downcast_ref::<PyInt>() {`
`110`	`110`	`return pymath::math::log_bigint(i.as_bigint(), base).map_err(\|err\| match err {`
`111`		`- pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),`
	`111`	`+ pymath::Error::EDOM => vm.new_value_error("expected a positive input"),`
`112`	`112`	`_ => pymath_exception(err, vm),`
`113`	`113`	`});`
`114`	`114`	`}`
`@@ -132,7 +132,7 @@ mod math {`
`132`	`132`	`// Handle BigInt specially for large values (only for actual int type, not float)`
`133`	`133`	`if let Some(i) = x.downcast_ref::<PyInt>() {`
`134`	`134`	`return pymath::math::log2_bigint(i.as_bigint()).map_err(\|err\| match err {`
`135`		`- pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),`
	`135`	`+ pymath::Error::EDOM => vm.new_value_error("expected a positive input"),`
`136`	`136`	`_ => pymath_exception(err, vm),`
`137`	`137`	`});`
`138`	`138`	`}`
`@@ -151,7 +151,7 @@ mod math {`
`151`	`151`	`// Handle BigInt specially for large values (only for actual int type, not float)`
`152`	`152`	`if let Some(i) = x.downcast_ref::<PyInt>() {`
`153`	`153`	`return pymath::math::log10_bigint(i.as_bigint()).map_err(\|err\| match err {`
`154`		`- pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),`
	`154`	`+ pymath::Error::EDOM => vm.new_value_error("expected a positive input"),`
`155`	`155`	`_ => pymath_exception(err, vm),`
`156`	`156`	`});`
`157`	`157`	`}`