From 4a9c1bbec4039551437326094b6c038aa3b37a8b Mon Sep 17 00:00:00 2001 From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com> Date: Wed, 25 Jun 2025 12:54:36 +0300 Subject: [PATCH 1/2] Remove redundent String conversion for errors --- stdlib/src/array.rs | 12 +++--- stdlib/src/binascii.rs | 4 +- stdlib/src/bisect.rs | 2 +- stdlib/src/bz2.rs | 10 ++--- stdlib/src/cmath.rs | 4 +- stdlib/src/compression.rs | 2 +- stdlib/src/contextvars.rs | 2 +- stdlib/src/csv.rs | 16 +++---- stdlib/src/dis.rs | 2 +- stdlib/src/fcntl.rs | 6 +-- stdlib/src/gc.rs | 24 +++++------ stdlib/src/hashlib.rs | 2 +- stdlib/src/json.rs | 2 +- stdlib/src/lzma.rs | 4 +- stdlib/src/math.rs | 66 ++++++++++++++--------------- stdlib/src/mmap.rs | 60 +++++++++++++------------- stdlib/src/overlapped.rs | 4 +- stdlib/src/posixsubprocess.rs | 2 +- stdlib/src/pystruct.rs | 2 +- stdlib/src/random.rs | 6 +-- stdlib/src/re.rs | 2 +- stdlib/src/resource.rs | 12 +++--- stdlib/src/select.rs | 20 ++++----- stdlib/src/socket.rs | 47 ++++++++++---------- stdlib/src/sqlite.rs | 51 +++++++++++----------- stdlib/src/ssl.rs | 28 ++++++------ stdlib/src/statistics.rs | 2 +- stdlib/src/termios.rs | 4 +- stdlib/src/unicodedata.rs | 6 +-- stdlib/src/zlib.rs | 8 ++-- vm/src/anystr.rs | 4 +- vm/src/builtins/asyncgenerator.rs | 12 +++--- vm/src/builtins/bool.rs | 2 +- vm/src/builtins/bytearray.rs | 8 ++-- vm/src/builtins/bytes.rs | 4 +- vm/src/builtins/code.rs | 2 +- vm/src/builtins/complex.rs | 14 +++--- vm/src/builtins/descriptor.rs | 6 +-- vm/src/builtins/dict.rs | 4 +- vm/src/builtins/float.rs | 24 +++++------ vm/src/builtins/frame.rs | 4 +- vm/src/builtins/function.rs | 10 ++--- vm/src/builtins/function/jitfunc.rs | 4 +- vm/src/builtins/genericalias.rs | 6 +-- vm/src/builtins/int.rs | 28 ++++++------ vm/src/builtins/iter.rs | 2 +- vm/src/builtins/list.rs | 6 +-- vm/src/builtins/memory.rs | 52 +++++++++++------------ vm/src/builtins/module.rs | 2 +- vm/src/builtins/namespace.rs | 2 +- vm/src/builtins/object.rs | 9 ++-- vm/src/builtins/range.rs | 6 +-- vm/src/builtins/set.rs | 2 +- vm/src/builtins/slice.rs | 6 +-- vm/src/builtins/str.rs | 23 +++++----- vm/src/builtins/super.rs | 12 +++--- vm/src/builtins/tuple.rs | 2 +- vm/src/builtins/type.rs | 16 +++---- vm/src/builtins/union.rs | 4 +- vm/src/builtins/weakref.rs | 2 +- vm/src/byte.rs | 4 +- vm/src/bytes_inner.rs | 20 ++++----- vm/src/cformat.rs | 34 +++++++-------- vm/src/codecs.rs | 18 ++++---- vm/src/convert/try_from.rs | 2 +- vm/src/coroutine.rs | 2 +- vm/src/dict_inner.rs | 6 +-- vm/src/exceptions.rs | 2 +- vm/src/format.rs | 6 +-- vm/src/frame.rs | 20 ++++----- vm/src/function/buffer.rs | 12 +++--- vm/src/function/fspath.rs | 2 +- vm/src/function/getset.rs | 2 +- vm/src/function/mod.rs | 2 +- vm/src/protocol/buffer.rs | 2 +- vm/src/protocol/object.rs | 2 +- vm/src/protocol/sequence.rs | 6 +-- vm/src/sliceable.rs | 16 +++---- vm/src/stdlib/ast/other.rs | 4 +- vm/src/stdlib/builtins.rs | 17 ++++---- vm/src/stdlib/collections.rs | 30 ++++++------- vm/src/stdlib/ctypes.rs | 14 +++--- vm/src/stdlib/ctypes/base.rs | 10 ++--- vm/src/stdlib/ctypes/function.rs | 28 ++++++------ vm/src/stdlib/ctypes/structure.rs | 8 ++-- vm/src/stdlib/functools.rs | 16 +++---- vm/src/stdlib/imp.rs | 2 +- vm/src/stdlib/itertools.rs | 16 +++---- vm/src/stdlib/marshal.rs | 12 +++--- vm/src/stdlib/msvcrt.rs | 4 +- vm/src/stdlib/nt.rs | 6 +-- vm/src/stdlib/operator.rs | 18 ++++---- vm/src/stdlib/os.rs | 22 +++++----- vm/src/stdlib/posix.rs | 47 ++++++++++---------- vm/src/stdlib/signal.rs | 11 +++-- vm/src/stdlib/sre.rs | 8 ++-- vm/src/stdlib/symtable.rs | 2 +- vm/src/stdlib/sys.rs | 18 ++++---- vm/src/stdlib/thread.rs | 6 +-- vm/src/stdlib/time.rs | 26 ++++++------ vm/src/stdlib/typing.rs | 14 +++--- vm/src/stdlib/weakref.rs | 2 +- vm/src/stdlib/winapi.rs | 8 ++-- vm/src/stdlib/winreg.rs | 8 ++-- vm/src/types/slot.rs | 24 +++++------ vm/src/vm/mod.rs | 2 +- vm/src/vm/vm_object.rs | 2 +- 107 files changed, 610 insertions(+), 623 deletions(-) diff --git a/stdlib/src/array.rs b/stdlib/src/array.rs index 865ef24c1b..699f7d1ac9 100644 --- a/stdlib/src/array.rs +++ b/stdlib/src/array.rs @@ -657,13 +657,13 @@ mod array { ) -> PyResult { let spec = spec.as_str().chars().exactly_one().map_err(|_| { vm.new_type_error( - "array() argument 1 must be a unicode character, not str".to_owned(), + "array() argument 1 must be a unicode character, not str", ) })?; if cls.is(PyArray::class(&vm.ctx)) && !kwargs.is_empty() { return Err( - vm.new_type_error("array.array() takes no keyword arguments".to_owned()) + vm.new_type_error("array.array() takes no keyword arguments") ); } @@ -857,7 +857,7 @@ mod array { fn _from_bytes(&self, b: &[u8], itemsize: usize, vm: &VirtualMachine) -> PyResult<()> { if b.len() % itemsize != 0 { return Err( - vm.new_value_error("bytes length not a multiple of item size".to_owned()) + vm.new_value_error("bytes length not a multiple of item size") ); } if b.len() / itemsize > 0 { @@ -877,7 +877,7 @@ mod array { fn fromfile(&self, f: PyObjectRef, n: isize, vm: &VirtualMachine) -> PyResult<()> { let itemsize = self.itemsize(); if n < 0 { - return Err(vm.new_value_error("negative count".to_owned())); + return Err(vm.new_value_error("negative count")); } let n = vm.check_repeat_or_overflow_error(itemsize, n)?; let n_bytes = n * itemsize; @@ -885,7 +885,7 @@ mod array { let b = vm.call_method(&f, "read", (n_bytes,))?; let b = b .downcast::() - .map_err(|_| vm.new_type_error("read() didn't return bytes".to_owned()))?; + .map_err(|_| vm.new_type_error("read() didn't return bytes"))?; let not_enough_bytes = b.len() != n_bytes; @@ -927,7 +927,7 @@ mod array { fn pop(zelf: &Py, i: OptionalArg, vm: &VirtualMachine) -> PyResult { let mut w = zelf.try_resizable(vm)?; if w.len() == 0 { - Err(vm.new_index_error("pop from empty array".to_owned())) + Err(vm.new_index_error("pop from empty array")) } else { w.pop(i.unwrap_or(-1), vm) } diff --git a/stdlib/src/binascii.rs b/stdlib/src/binascii.rs index 24079e18a5..76fdd7365a 100644 --- a/stdlib/src/binascii.rs +++ b/stdlib/src/binascii.rs @@ -56,11 +56,11 @@ mod decl { let sep_char = if let OptionalArg::Present(sep_buf) = sep { sep_buf.with_ref(|sep_bytes| { if sep_bytes.len() != 1 { - return Err(vm.new_value_error("sep must be length 1.".to_owned())); + return Err(vm.new_value_error("sep must be length 1.")); } let sep_char = sep_bytes[0]; if !sep_char.is_ascii() { - return Err(vm.new_value_error("sep must be ASCII.".to_owned())); + return Err(vm.new_value_error("sep must be ASCII.")); } Ok(Some(sep_char)) })? diff --git a/stdlib/src/bisect.rs b/stdlib/src/bisect.rs index 4d67ee50b9..f314eee1b8 100644 --- a/stdlib/src/bisect.rs +++ b/stdlib/src/bisect.rs @@ -47,7 +47,7 @@ mod _bisect { let lo = handle_default(lo, vm)? .map(|value| { usize::try_from(value) - .map_err(|_| vm.new_value_error("lo must be non-negative".to_owned())) + .map_err(|_| vm.new_value_error("lo must be non-negative")) }) .unwrap_or(Ok(0))?; let hi = handle_default(hi, vm)? diff --git a/stdlib/src/bz2.rs b/stdlib/src/bz2.rs index eb334ede7b..f6c4be2143 100644 --- a/stdlib/src/bz2.rs +++ b/stdlib/src/bz2.rs @@ -105,7 +105,7 @@ mod _bz2 { #[pymethod(name = "__reduce__")] fn reduce(&self, vm: &VirtualMachine) -> PyResult<()> { - Err(vm.new_type_error("cannot pickle '_bz2.BZ2Decompressor' object".to_owned())) + Err(vm.new_type_error("cannot pickle '_bz2.BZ2Decompressor' object")) } // TODO: mro()? @@ -141,7 +141,7 @@ mod _bz2 { valid_level @ 1..=9 => bzip2::Compression::new(valid_level as u32), _ => { return Err( - vm.new_value_error("compresslevel must be between 1 and 9".to_owned()) + vm.new_value_error("compresslevel must be between 1 and 9") ); } }; @@ -164,7 +164,7 @@ mod _bz2 { fn compress(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult { let mut state = self.state.lock(); if state.flushed { - return Err(vm.new_value_error("Compressor has been flushed".to_owned())); + return Err(vm.new_value_error("Compressor has been flushed")); } // let CompressorState { flushed, encoder } = &mut *state; @@ -179,7 +179,7 @@ mod _bz2 { fn flush(&self, vm: &VirtualMachine) -> PyResult { let mut state = self.state.lock(); if state.flushed { - return Err(vm.new_value_error("Repeated call to flush()".to_owned())); + return Err(vm.new_value_error("Repeated call to flush()")); } // let CompressorState { flushed, encoder } = &mut *state; @@ -193,7 +193,7 @@ mod _bz2 { #[pymethod(name = "__reduce__")] fn reduce(&self, vm: &VirtualMachine) -> PyResult<()> { - Err(vm.new_type_error("cannot pickle '_bz2.BZ2Compressor' object".to_owned())) + Err(vm.new_type_error("cannot pickle '_bz2.BZ2Compressor' object")) } } } diff --git a/stdlib/src/cmath.rs b/stdlib/src/cmath.rs index 4611ea344e..e5d1d55a57 100644 --- a/stdlib/src/cmath.rs +++ b/stdlib/src/cmath.rs @@ -162,7 +162,7 @@ mod cmath { let abs_tol = args.abs_tol.map_or(0.0, Into::into); if rel_tol < 0.0 || abs_tol < 0.0 { - return Err(vm.new_value_error("tolerances must be non-negative".to_owned())); + return Err(vm.new_value_error("tolerances must be non-negative")); } if a == b { @@ -201,7 +201,7 @@ mod cmath { if !result.is_finite() && value.is_finite() { // CPython doesn't return `inf` when called with finite // values, it raises OverflowError instead. - Err(vm.new_overflow_error("math range error".to_owned())) + Err(vm.new_overflow_error("math range error")) } else { Ok(result) } diff --git a/stdlib/src/compression.rs b/stdlib/src/compression.rs index 0b65692299..5a79a397cb 100644 --- a/stdlib/src/compression.rs +++ b/stdlib/src/compression.rs @@ -369,6 +369,6 @@ pub struct EofError; impl ToPyException for EofError { fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef { - vm.new_eof_error("End of stream already reached".to_owned()) + vm.new_eof_error("End of stream already reached") } } diff --git a/stdlib/src/contextvars.rs b/stdlib/src/contextvars.rs index 4fd45842b9..64986be0fd 100644 --- a/stdlib/src/contextvars.rs +++ b/stdlib/src/contextvars.rs @@ -567,7 +567,7 @@ mod _contextvars { type Args = FuncArgs; fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_runtime_error("Tokens can only be created by ContextVars".to_owned())) + Err(vm.new_runtime_error("Tokens can only be created by ContextVars")) } fn py_new(_cls: PyTypeRef, _args: Self::Args, _vm: &VirtualMachine) -> PyResult { unreachable!() diff --git a/stdlib/src/csv.rs b/stdlib/src/csv.rs index a7d333d621..6c7ab69cec 100644 --- a/stdlib/src/csv.rs +++ b/stdlib/src/csv.rs @@ -270,11 +270,11 @@ mod _csv { vm: &VirtualMachine, ) -> PyResult<()> { let Some(name) = name.payload_if_subclass::(vm) else { - return Err(vm.new_type_error("argument 0 must be a string".to_string())); + return Err(vm.new_type_error("argument 0 must be a string")); }; let dialect = match dialect { OptionalArg::Present(d) => PyDialect::try_from_object(vm, d) - .map_err(|_| vm.new_type_error("argument 1 must be a dialect object".to_owned()))?, + .map_err(|_| vm.new_type_error("argument 1 must be a dialect object"))?, OptionalArg::Missing => opts.result(vm)?, }; let dialect = opts.update_py_dialect(dialect); @@ -328,7 +328,7 @@ mod _csv { vm: &VirtualMachine, ) -> PyResult { if !rest.args.is_empty() || !rest.kwargs.is_empty() { - return Err(vm.new_type_error("too many argument".to_string())); + return Err(vm.new_type_error("too many argument")); } let g = GLOBAL_HASHMAP.lock(); let t = g @@ -351,7 +351,7 @@ mod _csv { ))); } let Ok(new_size) = rest.args.first().unwrap().try_int(vm) else { - return Err(vm.new_type_error("limit must be an integer".to_string())); + return Err(vm.new_type_error("limit must be an integer")); }; *GLOBAL_FIELD_LIMIT.lock() = new_size.try_to_primitive::(vm)?; } @@ -392,7 +392,7 @@ mod _csv { Some(write_meth) => write_meth, None if file.is_callable() => file, None => { - return Err(vm.new_type_error("argument 1 must have a \"write\" method".to_owned())); + return Err(vm.new_type_error("argument 1 must have a \"write\" method")); } }; @@ -439,7 +439,7 @@ mod _csv { let num = obj.try_int(vm)?.try_to_primitive::(vm)?; num.try_into().map_err(|_| { vm.new_value_error( - "can not convert to QuoteStyle enum from input argument".to_string(), + "can not convert to QuoteStyle enum from input argument", ) }) } @@ -1016,7 +1016,7 @@ mod _csv { prev_end = end; let s = std::str::from_utf8(&buffer[range.clone()]) // not sure if this is possible - the input was all strings - .map_err(|_e| vm.new_unicode_decode_error("csv not utf8".to_owned()))?; + .map_err(|_e| vm.new_unicode_decode_error("csv not utf8"))?; // Rustpython TODO! // Incomplete implementation if let QuoteStyle::Nonnumeric = zelf.dialect.quoting { @@ -1125,7 +1125,7 @@ mod _csv { handle_res!(writer.terminator(&mut buffer[buffer_offset..])); } let s = std::str::from_utf8(&buffer[..buffer_offset]) - .map_err(|_| vm.new_unicode_decode_error("csv not utf8".to_owned()))?; + .map_err(|_| vm.new_unicode_decode_error("csv not utf8"))?; self.write.call((s,), vm) } diff --git a/stdlib/src/dis.rs b/stdlib/src/dis.rs index 69767ffbba..eb7e30df58 100644 --- a/stdlib/src/dis.rs +++ b/stdlib/src/dis.rs @@ -18,7 +18,7 @@ mod decl { { let _ = co_str; return Err(vm.new_runtime_error( - "dis.dis() with str argument requires `compiler` feature".to_owned(), + "dis.dis() with str argument requires `compiler` feature", )); } #[cfg(feature = "compiler")] diff --git a/stdlib/src/fcntl.rs b/stdlib/src/fcntl.rs index 7dff14ccd8..aaf1dd1036 100644 --- a/stdlib/src/fcntl.rs +++ b/stdlib/src/fcntl.rs @@ -70,7 +70,7 @@ mod fcntl { let s = arg.borrow_bytes(); arg_len = s.len(); buf.get_mut(..arg_len) - .ok_or_else(|| vm.new_value_error("fcntl string arg too long".to_owned()))? + .ok_or_else(|| vm.new_value_error("fcntl string arg too long"))? .copy_from_slice(&s) } let ret = unsafe { libc::fcntl(fd, cmd, buf.as_mut_ptr()) }; @@ -104,7 +104,7 @@ mod fcntl { let mut buf = [0u8; BUF_SIZE + 1]; // nul byte let mut fill_buf = |b: &[u8]| { if b.len() > BUF_SIZE { - return Err(vm.new_value_error("fcntl string arg too long".to_owned())); + return Err(vm.new_value_error("fcntl string arg too long")); } buf[..b.len()].copy_from_slice(b); Ok(b.len()) @@ -181,7 +181,7 @@ mod fcntl { } else if (cmd & libc::LOCK_EX) != 0 { try_into_l_type!(libc::F_WRLCK) } else { - return Err(vm.new_value_error("unrecognized lockf argument".to_owned())); + return Err(vm.new_value_error("unrecognized lockf argument")); }?; l.l_start = match start { OptionalArg::Present(s) => s.try_to_primitive(vm)?, diff --git a/stdlib/src/gc.rs b/stdlib/src/gc.rs index 6e906ebab2..0059e2424f 100644 --- a/stdlib/src/gc.rs +++ b/stdlib/src/gc.rs @@ -16,61 +16,61 @@ mod gc { #[pyfunction] fn enable(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn disable(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn get_count(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn get_debug(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn get_objects(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn get_refererts(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn get_referrers(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn get_stats(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn get_threshold(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn is_tracked(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn set_debug(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } #[pyfunction] fn set_threshold(_args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_not_implemented_error("".to_owned())) + Err(vm.new_not_implemented_error("")) } } diff --git a/stdlib/src/hashlib.rs b/stdlib/src/hashlib.rs index 5d0a4f6a1e..296342f05b 100644 --- a/stdlib/src/hashlib.rs +++ b/stdlib/src/hashlib.rs @@ -79,7 +79,7 @@ pub mod _hashlib { impl XofDigestArgs { fn length(&self, vm: &VirtualMachine) -> PyResult { usize::try_from(self.length) - .map_err(|_| vm.new_value_error("length must be non-negative".to_owned())) + .map_err(|_| vm.new_value_error("length must be non-negative")) } } diff --git a/stdlib/src/json.rs b/stdlib/src/json.rs index f970ef5dc2..afc9af234b 100644 --- a/stdlib/src/json.rs +++ b/stdlib/src/json.rs @@ -195,7 +195,7 @@ mod _json { type Args = (PyStrRef, isize); fn call(zelf: &Py, (pystr, idx): Self::Args, vm: &VirtualMachine) -> PyResult { if idx < 0 { - return Err(vm.new_value_error("idx cannot be negative".to_owned())); + return Err(vm.new_value_error("idx cannot be negative")); } let idx = idx as usize; let mut chars = pystr.as_str().chars(); diff --git a/stdlib/src/lzma.rs b/stdlib/src/lzma.rs index 21ba8b64c0..fa0e328337 100644 --- a/stdlib/src/lzma.rs +++ b/stdlib/src/lzma.rs @@ -151,7 +151,7 @@ mod _lzma { fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult { if args.format == FORMAT_RAW && args.memlimit.is_some() { return Err( - vm.new_value_error("Cannot specify memory limit with FORMAT_RAW".to_string()) + vm.new_value_error("Cannot specify memory limit with FORMAT_RAW") ); } let memlimit = args.memlimit.unwrap_or(u64::MAX); @@ -317,7 +317,7 @@ mod _lzma { vm: &VirtualMachine, ) -> PyResult { let real_check = int_to_check(check) - .ok_or_else(|| vm.new_type_error("Invalid check value".to_string()))?; + .ok_or_else(|| vm.new_type_error("Invalid check value"))?; if let Some(filters) = filters { let filters = parse_filter_chain_spec(filters, vm)?; Ok(Stream::new_stream_encoder(&filters, real_check) diff --git a/stdlib/src/math.rs b/stdlib/src/math.rs index 524660a434..d1cf035bc4 100644 --- a/stdlib/src/math.rs +++ b/stdlib/src/math.rs @@ -40,7 +40,7 @@ mod math { if !result.is_finite() && value.is_finite() { // CPython doesn't return `inf` when called with finite // values, it raises OverflowError instead. - Err(vm.new_overflow_error("math range error".to_owned())) + Err(vm.new_overflow_error("math range error")) } else { Ok(result) } @@ -87,7 +87,7 @@ mod math { let abs_tol = args.abs_tol.map_or(0.0, |value| value.into()); if rel_tol < 0.0 || abs_tol < 0.0 { - return Err(vm.new_value_error("tolerances must be non-negative".to_owned())); + return Err(vm.new_value_error("tolerances must be non-negative")); } if a == b { @@ -138,7 +138,7 @@ mod math { fn log(x: PyObjectRef, base: OptionalArg, vm: &VirtualMachine) -> PyResult { let base = base.map(|b| *b).unwrap_or(std::f64::consts::E); if base.is_sign_negative() { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } log2(x, vm).map(|log_x| log_x / base.log2()) } @@ -149,7 +149,7 @@ mod math { if x.is_nan() || x > -1.0_f64 { Ok(x.ln_1p()) } else { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } } @@ -171,7 +171,7 @@ mod math { if x.is_nan() || x > 0.0_f64 { Ok(x.log2()) } else { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } } Err(float_err) => { @@ -180,7 +180,7 @@ mod math { if x.is_positive() { Ok(int_log2(x)) } else { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } } else { // Return the float error, as it will be more intuitive to users @@ -203,13 +203,13 @@ mod math { if x < 0.0 && x.is_finite() && y.fract() != 0.0 && y.is_finite() || x == 0.0 && y < 0.0 && y != f64::NEG_INFINITY { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } let value = x.powf(y); if x.is_finite() && y.is_finite() && value.is_infinite() { - return Err(vm.new_overflow_error("math range error".to_string())); + return Err(vm.new_overflow_error("math range error")); } Ok(value) @@ -225,7 +225,7 @@ mod math { if value.is_zero() { return Ok(-0.0f64); } - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } Ok(value.sqrt()) } @@ -235,7 +235,7 @@ mod math { let value = x.as_bigint(); if value.is_negative() { - return Err(vm.new_value_error("isqrt() argument must be nonnegative".to_owned())); + return Err(vm.new_value_error("isqrt() argument must be nonnegative")); } Ok(value.sqrt()) } @@ -247,7 +247,7 @@ mod math { if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) { Ok(x.acos()) } else { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } } @@ -257,7 +257,7 @@ mod math { if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) { Ok(x.asin()) } else { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } } @@ -274,7 +274,7 @@ mod math { #[pyfunction] fn cos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult { if x.is_infinite() { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } call_math_func!(cos, x, vm) } @@ -379,7 +379,7 @@ mod math { if p.len() != q.len() { return Err(vm.new_value_error( - "both points must have the same number of dimensions".to_owned(), + "both points must have the same number of dimensions", )); } @@ -411,7 +411,7 @@ mod math { #[pyfunction] fn sin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult { if x.is_infinite() { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } call_math_func!(sin, x, vm) } @@ -419,7 +419,7 @@ mod math { #[pyfunction] fn tan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult { if x.is_infinite() { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } call_math_func!(tan, x, vm) } @@ -440,7 +440,7 @@ mod math { fn acosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult { let x = *x; if x.is_sign_negative() || x.is_zero() { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } else { Ok(x.acosh()) } @@ -455,7 +455,7 @@ mod math { fn atanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult { let x = *x; if x >= 1.0_f64 || x <= -1.0_f64 { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } else { Ok(x.atanh()) } @@ -646,7 +646,7 @@ mod math { // summands if xsave.is_finite() { return Err( - vm.new_overflow_error("intermediate overflow in fsum".to_owned()) + vm.new_overflow_error("intermediate overflow in fsum") ); } if xsave.is_infinite() { @@ -662,7 +662,7 @@ mod math { } if special_sum != 0.0 { return if inf_sum.is_nan() { - Err(vm.new_value_error("-inf + inf in fsum".to_owned())) + Err(vm.new_value_error("-inf + inf in fsum")) } else { Ok(special_sum) }; @@ -713,7 +713,7 @@ mod math { let one = BigInt::one(); if value.is_negative() { return Err( - vm.new_value_error("factorial() not defined for negative values".to_owned()) + vm.new_value_error("factorial() not defined for negative values") ); } else if *value <= one { return Ok(one); @@ -745,7 +745,7 @@ mod math { }; if n.is_negative() || v.is_negative() { - return Err(vm.new_value_error("perm() not defined for negative values".to_owned())); + return Err(vm.new_value_error("perm() not defined for negative values")); } if v > n { return Ok(BigInt::zero()); @@ -768,7 +768,7 @@ mod math { let zero = BigInt::zero(); if n.is_negative() || k.is_negative() { - return Err(vm.new_value_error("comb() not defined for negative values".to_owned())); + return Err(vm.new_value_error("comb() not defined for negative values")); } let temp = n - k; @@ -833,7 +833,7 @@ mod math { Some(steps) => { if steps < 0 { return Err( - vm.new_value_error("steps must be a non-negative integer".to_string()) + vm.new_value_error("steps must be a non-negative integer") ); } Ok(float_ops::nextafter_with_steps( @@ -867,7 +867,7 @@ mod math { let r = fmod(x, y); if r.is_nan() && !x.is_nan() && !y.is_nan() { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } Ok(r) @@ -880,7 +880,7 @@ mod math { if x.is_finite() && y.is_finite() { if y == 0.0 { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } let abs_x = x.abs(); @@ -897,7 +897,7 @@ mod math { return Ok(1.0_f64.copysign(x) * r); } if x.is_infinite() && !y.is_nan() { - return Err(vm.new_value_error("math domain error".to_owned())); + return Err(vm.new_value_error("math domain error")); } if x.is_nan() || y.is_nan() { return Ok(f64::NAN); @@ -905,7 +905,7 @@ mod math { if y.is_infinite() { Ok(x) } else { - Err(vm.new_value_error("math domain error".to_owned())) + Err(vm.new_value_error("math domain error")) } } @@ -956,7 +956,7 @@ mod math { } (None, None) => break, _ => { - return Err(vm.new_value_error("Inputs are not the same length".to_string())); + return Err(vm.new_value_error("Inputs are not the same length")); } } } @@ -979,10 +979,10 @@ mod math { if result.is_nan() { if !x.is_nan() && !y.is_nan() && !z.is_nan() { - return Err(vm.new_value_error("invalid operation in fma".to_string())); + return Err(vm.new_value_error("invalid operation in fma")); } } else if x.is_finite() && y.is_finite() && z.is_finite() { - return Err(vm.new_overflow_error("overflow in fma".to_string())); + return Err(vm.new_overflow_error("overflow in fma")); } Ok(result) @@ -991,7 +991,7 @@ mod math { fn pymath_error_to_exception(err: pymath::Error, vm: &VirtualMachine) -> PyBaseExceptionRef { match err { - pymath::Error::EDOM => vm.new_value_error("math domain error".to_owned()), - pymath::Error::ERANGE => vm.new_overflow_error("math range error".to_owned()), + pymath::Error::EDOM => vm.new_value_error("math domain error"), + pymath::Error::ERANGE => vm.new_overflow_error("math range error"), } } diff --git a/stdlib/src/mmap.rs b/stdlib/src/mmap.rs index 9319bab64c..d959640a8a 100644 --- a/stdlib/src/mmap.rs +++ b/stdlib/src/mmap.rs @@ -62,7 +62,7 @@ mod mmap { libc::MADV_DODUMP => Advice::DoDump, #[cfg(target_os = "linux")] libc::MADV_HWPOISON => Advice::HwPoison, - _ => return Err(vm.new_value_error("Not a valid Advice value".to_owned())), + _ => return Err(vm.new_value_error("Not a valid Advice value")), }) } @@ -83,7 +83,7 @@ mod mmap { 1 => Self::Read, 2 => Self::Write, 3 => Self::Copy, - _ => return Err(vm.new_value_error("Not a valid AccessMode value".to_owned())), + _ => return Err(vm.new_value_error("Not a valid AccessMode value")), }) } } @@ -266,7 +266,7 @@ mod mmap { s.try_to_primitive::(vm) .ok() .filter(|s| *s < len) - .ok_or_else(|| vm.new_value_error("madvise start out of bounds".to_owned())) + .ok_or_else(|| vm.new_value_error("madvise start out of bounds")) }) .transpose()? .unwrap_or(0); @@ -274,13 +274,13 @@ mod mmap { .length .map(|s| { s.try_to_primitive::(vm) - .map_err(|_| vm.new_value_error("madvise length invalid".to_owned())) + .map_err(|_| vm.new_value_error("madvise length invalid")) }) .transpose()? .unwrap_or(len); if isize::MAX as usize - start < length { - return Err(vm.new_overflow_error("madvise length too large".to_owned())); + return Err(vm.new_overflow_error("madvise length too large")); } let length = if start + length > len { @@ -313,14 +313,14 @@ mod mmap { let map_size = length; if map_size < 0 { return Err( - vm.new_overflow_error("memory mapped length must be positive".to_owned()) + vm.new_overflow_error("memory mapped length must be positive") ); } let mut map_size = map_size as usize; if offset < 0 { return Err( - vm.new_overflow_error("memory mapped offset must be positive".to_owned()) + vm.new_overflow_error("memory mapped offset must be positive") ); } @@ -328,7 +328,7 @@ mod mmap { && ((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ))) { return Err(vm.new_value_error( - "mmap can't specify both access and flags, prot.".to_owned(), + "mmap can't specify both access and flags, prot.", )); } @@ -356,21 +356,21 @@ mod mmap { if map_size == 0 { if file_len == 0 { - return Err(vm.new_value_error("cannot mmap an empty file".to_owned())); + return Err(vm.new_value_error("cannot mmap an empty file")); } if offset > file_len { return Err( - vm.new_value_error("mmap offset is greater than file size".to_owned()) + vm.new_value_error("mmap offset is greater than file size") ); } map_size = (file_len - offset) .try_into() - .map_err(|_| vm.new_value_error("mmap length is too large".to_owned()))?; + .map_err(|_| vm.new_value_error("mmap length is too large"))?; } else if offset > file_len || file_len - offset < map_size as libc::off_t { return Err( - vm.new_value_error("mmap length is greater than file size".to_owned()) + vm.new_value_error("mmap length is greater than file size") ); } } @@ -527,7 +527,7 @@ mod mmap { ) -> PyResult { if matches!(self.access, AccessMode::Read) { return Err( - vm.new_type_error("mmap can't modify a readonly memory map.".to_owned()) + vm.new_type_error("mmap can't modify a readonly memory map.") ); } @@ -541,7 +541,7 @@ mod mmap { let m = self.mmap.lock(); if m.is_none() { - return Err(vm.new_value_error("mmap closed or invalid".to_owned())); + return Err(vm.new_value_error("mmap closed or invalid")); } Ok(m) @@ -552,7 +552,7 @@ mod mmap { fn check_resizeable(&self, vm: &VirtualMachine) -> PyResult<()> { if self.exports.load() > 0 { return Err(vm.new_buffer_error( - "mmap can't resize with extant buffers exported.".to_owned(), + "mmap can't resize with extant buffers exported.", )); } @@ -561,7 +561,7 @@ mod mmap { } Err(vm.new_type_error( - "mmap can't resize a readonly or copy-on-write memory map.".to_owned(), + "mmap can't resize a readonly or copy-on-write memory map.", )) } @@ -577,7 +577,7 @@ mod mmap { } if self.exports.load() > 0 { - return Err(vm.new_buffer_error("cannot close exported pointers exist.".to_owned())); + return Err(vm.new_buffer_error("cannot close exported pointers exist.")); } let mut mmap = self.mmap.lock(); self.closed.store(true); @@ -642,7 +642,7 @@ mod mmap { fn flush(&self, options: FlushOptions, vm: &VirtualMachine) -> PyResult<()> { let (offset, size) = options .values(self.len()) - .ok_or_else(|| vm.new_value_error("flush values out of range".to_owned()))?; + .ok_or_else(|| vm.new_value_error("flush values out of range"))?; if self.access == AccessMode::Read || self.access == AccessMode::Copy { return Ok(()); @@ -708,7 +708,7 @@ mod mmap { let size = self.len(); let (dest, src, cnt) = args(dest, src, cnt, size, vm).ok_or_else(|| { - vm.new_value_error("source, destination, or count out of range".to_owned()) + vm.new_value_error("source, destination, or count out of range") })?; let dest_end = dest + cnt; @@ -762,7 +762,7 @@ mod mmap { fn read_byte(&self, vm: &VirtualMachine) -> PyResult { let pos = self.pos(); if pos >= self.len() { - return Err(vm.new_value_error("read byte out of range".to_owned())); + return Err(vm.new_value_error("read byte out of range")); } let b = match self.check_valid(vm)?.deref().as_ref().unwrap() { @@ -814,7 +814,7 @@ mod mmap { #[pymethod] fn resize(&self, _newsize: PyIntRef, vm: &VirtualMachine) -> PyResult<()> { self.check_resizeable(vm)?; - Err(vm.new_system_error("mmap: resizing not available--no mremap()".to_owned())) + Err(vm.new_system_error("mmap: resizing not available--no mremap()")) } #[pymethod] @@ -833,22 +833,22 @@ mod mmap { // relative to current position let pos = self.pos(); if (((isize::MAX as usize) - pos) as isize) < dist { - return Err(vm.new_value_error("seek out of range".to_owned())); + return Err(vm.new_value_error("seek out of range")); } pos as isize + dist } 2 => { // relative to end if (((isize::MAX as usize) - size) as isize) < dist { - return Err(vm.new_value_error("seek out of range".to_owned())); + return Err(vm.new_value_error("seek out of range")); } size as isize + dist } - _ => return Err(vm.new_value_error("unknown seek type".to_owned())), + _ => return Err(vm.new_value_error("unknown seek type")), }; if new_pos < 0 || (new_pos as usize) > size { - return Err(vm.new_value_error("seek out of range".to_owned())); + return Err(vm.new_value_error("seek out of range")); } self.pos.store(new_pos as usize); @@ -877,7 +877,7 @@ mod mmap { let data = bytes.borrow_buf(); if pos > size || size - pos < data.len() { - return Err(vm.new_value_error("data out of range".to_owned())); + return Err(vm.new_value_error("data out of range")); } let len = self.try_writable(vm, |mmap| { @@ -900,7 +900,7 @@ mod mmap { let size = self.len(); if pos >= size { - return Err(vm.new_value_error("write byte out of range".to_owned())); + return Err(vm.new_value_error("write byte out of range")); } self.try_writable(vm, |mmap| { @@ -943,7 +943,7 @@ mod mmap { fn getitem_by_index(&self, i: isize, vm: &VirtualMachine) -> PyResult { let i = i .wrapped_at(self.len()) - .ok_or_else(|| vm.new_index_error("mmap index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("mmap index out of range"))?; let b = match self.check_valid(vm)?.deref().as_ref().unwrap() { MmapObj::Read(mmap) => mmap[i], @@ -1020,7 +1020,7 @@ mod mmap { ) -> PyResult<()> { let i: usize = i .wrapped_at(self.len()) - .ok_or_else(|| vm.new_index_error("mmap index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("mmap index out of range"))?; let b = value_from_object(vm, &value)?; @@ -1042,7 +1042,7 @@ mod mmap { let bytes = bytes_from_object(vm, &value)?; if bytes.len() != slice_len { - return Err(vm.new_index_error("mmap slice assignment is wrong size".to_owned())); + return Err(vm.new_index_error("mmap slice assignment is wrong size")); } if slice_len == 0 { diff --git a/stdlib/src/overlapped.rs b/stdlib/src/overlapped.rs index 85a391c753..1021cca921 100644 --- a/stdlib/src/overlapped.rs +++ b/stdlib/src/overlapped.rs @@ -223,7 +223,7 @@ mod _overlapped { ) -> PyResult { let mut inner = zelf.inner.lock(); if !matches!(inner.data, OverlappedData::None) { - return Err(vm.new_value_error("operation already attempted".to_owned())); + return Err(vm.new_value_error("operation already attempted")); } #[cfg(target_pointer_width = "32")] @@ -368,7 +368,7 @@ mod _overlapped { vm: &VirtualMachine, ) -> PyResult { if !vm.is_none(&event_attributes) { - return Err(vm.new_value_error("EventAttributes must be None".to_owned())); + return Err(vm.new_value_error("EventAttributes must be None")); } let name = match name { diff --git a/stdlib/src/posixsubprocess.rs b/stdlib/src/posixsubprocess.rs index 346032fe79..83daddb356 100644 --- a/stdlib/src/posixsubprocess.rs +++ b/stdlib/src/posixsubprocess.rs @@ -35,7 +35,7 @@ mod _posixsubprocess { #[pyfunction] fn fork_exec(args: ForkExecArgs, vm: &VirtualMachine) -> PyResult { if args.preexec_fn.is_some() { - return Err(vm.new_not_implemented_error("preexec_fn not supported yet".to_owned())); + return Err(vm.new_not_implemented_error("preexec_fn not supported yet")); } let extra_groups = args .groups_list diff --git a/stdlib/src/pystruct.rs b/stdlib/src/pystruct.rs index e5f71cad13..382193da8b 100644 --- a/stdlib/src/pystruct.rs +++ b/stdlib/src/pystruct.rs @@ -39,7 +39,7 @@ pub(crate) mod _struct { ))), }) .ok_or_else(|| { - vm.new_unicode_decode_error("Struct format must be a ascii string".to_owned()) + vm.new_unicode_decode_error("Struct format must be a ascii string") })?; Ok(IntoStructFormatBytes(fmt)) } diff --git a/stdlib/src/random.rs b/stdlib/src/random.rs index a2aaff2612..be31d3011d 100644 --- a/stdlib/src/random.rs +++ b/stdlib/src/random.rs @@ -69,7 +69,7 @@ mod _random { #[pymethod] fn getrandbits(&self, k: isize, vm: &VirtualMachine) -> PyResult { match k { - ..0 => Err(vm.new_value_error("number of bits must be non-negative".to_owned())), + ..0 => Err(vm.new_value_error("number of bits must be non-negative")), 0 => Ok(BigInt::zero()), mut k => { let mut rng = self.rng.lock(); @@ -117,11 +117,11 @@ mod _random { let state: &[_; mt19937::N + 1] = state .as_slice() .try_into() - .map_err(|_| vm.new_value_error("state vector is the wrong size".to_owned()))?; + .map_err(|_| vm.new_value_error("state vector is the wrong size"))?; let (index, state) = state.split_last().unwrap(); let index: usize = index.try_to_value(vm)?; if index > mt19937::N { - return Err(vm.new_value_error("invalid state".to_owned())); + return Err(vm.new_value_error("invalid state")); } let state: [u32; mt19937::N] = state .iter() diff --git a/stdlib/src/re.rs b/stdlib/src/re.rs index 647f4c69ad..5af4567152 100644 --- a/stdlib/src/re.rs +++ b/stdlib/src/re.rs @@ -265,7 +265,7 @@ mod re { fn make_regex(vm: &VirtualMachine, pattern: &str, flags: PyRegexFlags) -> PyResult { let unicode = if flags.unicode && flags.ascii { - return Err(vm.new_value_error("ASCII and UNICODE flags are incompatible".to_owned())); + return Err(vm.new_value_error("ASCII and UNICODE flags are incompatible")); } else { !flags.ascii }; diff --git a/stdlib/src/resource.rs b/stdlib/src/resource.rs index 3255bb3f61..c9b956fa46 100644 --- a/stdlib/src/resource.rs +++ b/stdlib/src/resource.rs @@ -123,7 +123,7 @@ mod resource { }; res.map(Rusage::from).map_err(|e| { if e.kind() == io::ErrorKind::InvalidInput { - vm.new_value_error("invalid who parameter".to_owned()) + vm.new_value_error("invalid who parameter") } else { e.to_pyexception(vm) } @@ -139,7 +139,7 @@ mod resource { rlim_cur: cur & RLIM_INFINITY, rlim_max: max & RLIM_INFINITY, })), - _ => Err(vm.new_value_error("expected a tuple of 2 integers".to_owned())), + _ => Err(vm.new_value_error("expected a tuple of 2 integers")), } } } @@ -153,7 +153,7 @@ mod resource { fn getrlimit(resource: i32, vm: &VirtualMachine) -> PyResult { #[allow(clippy::unnecessary_cast)] if resource < 0 || resource >= RLIM_NLIMITS as i32 { - return Err(vm.new_value_error("invalid resource specified".to_owned())); + return Err(vm.new_value_error("invalid resource specified")); } let rlimit = unsafe { let mut rlimit = mem::MaybeUninit::::uninit(); @@ -169,7 +169,7 @@ mod resource { fn setrlimit(resource: i32, limits: Limits, vm: &VirtualMachine) -> PyResult<()> { #[allow(clippy::unnecessary_cast)] if resource < 0 || resource >= RLIM_NLIMITS as i32 { - return Err(vm.new_value_error("invalid resource specified".to_owned())); + return Err(vm.new_value_error("invalid resource specified")); } let res = unsafe { if libc::setrlimit(resource as _, &limits.0) == -1 { @@ -180,10 +180,10 @@ mod resource { }; res.map_err(|e| match e.kind() { io::ErrorKind::InvalidInput => { - vm.new_value_error("current limit exceeds maximum limit".to_owned()) + vm.new_value_error("current limit exceeds maximum limit") } io::ErrorKind::PermissionDenied => { - vm.new_value_error("not allowed to raise maximum limit".to_owned()) + vm.new_value_error("not allowed to raise maximum limit") } _ => e.to_pyexception(vm), }) diff --git a/stdlib/src/select.rs b/stdlib/src/select.rs index 1119f0cd9d..5a2c51c20a 100644 --- a/stdlib/src/select.rs +++ b/stdlib/src/select.rs @@ -246,7 +246,7 @@ mod decl { }); if let Some(timeout) = timeout { if timeout < 0.0 { - return Err(vm.new_value_error("timeout must be positive".to_owned())); + return Err(vm.new_value_error("timeout must be positive")); } } let deadline = timeout.map(|s| time::time(vm).unwrap() + s); @@ -354,7 +354,7 @@ mod decl { let float = float.to_f64(); if float.is_nan() { return Err( - vm.new_value_error("Invalid value NaN (not a number)".to_owned()) + vm.new_value_error("Invalid value NaN (not a number)") ); } if float.is_sign_negative() { @@ -368,7 +368,7 @@ mod decl { None } else { let n = int.as_bigint().to_u64().ok_or_else(|| { - vm.new_overflow_error("value out of range".to_owned()) + vm.new_overflow_error("value out of range") })?; Some(if MILLIS { Duration::from_millis(n) @@ -430,16 +430,16 @@ mod decl { use crate::builtins::PyInt; let int = obj .downcast::() - .map_err(|_| vm.new_type_error("argument must be an integer".to_owned()))?; + .map_err(|_| vm.new_type_error("argument must be an integer"))?; let val = int.as_bigint(); if val.is_negative() { - return Err(vm.new_value_error("negative event mask".to_owned())); + return Err(vm.new_value_error("negative event mask")); } // Try converting to i16, should raise OverflowError if too large let mask = i16::try_from(val).map_err(|_| { - vm.new_overflow_error("event mask value out of range".to_owned()) + vm.new_overflow_error("event mask value out of range") })?; Ok(EventMask(mask)) @@ -497,7 +497,7 @@ mod decl { let TimeoutArg(timeout) = timeout.unwrap_or_default(); let timeout_ms = match timeout { Some(d) => i32::try_from(d.as_millis()) - .map_err(|_| vm.new_overflow_error("value out of range".to_owned()))?, + .map_err(|_| vm.new_overflow_error("value out of range"))?, None => -1i32, }; let deadline = timeout.map(|d| Instant::now() + d); @@ -579,7 +579,7 @@ mod decl { type Args = EpollNewArgs; fn py_new(cls: PyTypeRef, args: EpollNewArgs, vm: &VirtualMachine) -> PyResult { if let ..=-2 | 0 = args.sizehint { - return Err(vm.new_value_error("negative sizehint".to_owned())); + 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())); @@ -626,7 +626,7 @@ mod decl { vm: &VirtualMachine, ) -> PyResult + '_> { PyRwLockReadGuard::try_map(self.epoll_fd.read(), |x| x.as_ref()).map_err(|_| { - vm.new_value_error("I/O operation on closed epoll object".to_owned()) + vm.new_value_error("I/O operation on closed epoll object") }) } @@ -680,7 +680,7 @@ mod decl { timeout .map(rustix::event::Timespec::try_from) .transpose() - .map_err(|_| vm.new_overflow_error("timeout is too large".to_owned()))?; + .map_err(|_| vm.new_overflow_error("timeout is too large"))?; let deadline = timeout.map(|d| Instant::now() + d); let maxevents = match maxevents { diff --git a/stdlib/src/socket.rs b/stdlib/src/socket.rs index f4f90a5dc4..71885f0b16 100644 --- a/stdlib/src/socket.rs +++ b/stdlib/src/socket.rs @@ -771,11 +771,11 @@ mod _socket { // should really just be to_index() but test_socket tests the error messages explicitly if obj.fast_isinstance(vm.ctx.types.float_type) { - return Err(vm.new_type_error("integer argument expected, got float".to_owned())); + return Err(vm.new_type_error("integer argument expected, got float")); } let int = obj .try_index_opt(vm) - .unwrap_or_else(|| Err(vm.new_type_error("an integer is required".to_owned())))?; + .unwrap_or_else(|| Err(vm.new_type_error("an integer is required")))?; int.try_to_primitive::(vm) .map(|sock| sock as RawSocket) } @@ -954,7 +954,7 @@ mod _socket { if tuple.len() != 2 { return Err(vm .new_type_error( - "AF_INET address must be a pair (host, post)".to_owned(), + "AF_INET address must be a pair (host, post)", ) .into()); } @@ -979,8 +979,7 @@ mod _socket { match tuple.len() { 2..=4 => {} _ => return Err(vm.new_type_error( - "AF_INET6 address must be a tuple (host, port[, flowinfo[, scopeid]])" - .to_owned(), + "AF_INET6 address must be a tuple (host, port[, flowinfo[, scopeid]])", ).into()), } let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(&tuple, vm)?; @@ -1219,7 +1218,7 @@ mod _socket { let flags = flags.unwrap_or(0); let bufsize = bufsize .to_usize() - .ok_or_else(|| vm.new_value_error("negative buffersize in recvfrom".to_owned()))?; + .ok_or_else(|| vm.new_value_error("negative buffersize in recvfrom"))?; let mut buffer = Vec::with_capacity(bufsize); let (n, addr) = self.sock_op(vm, SelectKind::Read, || { self.sock()? @@ -1242,11 +1241,11 @@ mod _socket { let buf = match nbytes { OptionalArg::Present(i) => { let i = i.to_usize().ok_or_else(|| { - vm.new_value_error("negative buffersize in recvfrom_into".to_owned()) + vm.new_value_error("negative buffersize in recvfrom_into") })?; buf.get_mut(..i).ok_or_else(|| { vm.new_value_error( - "nbytes is greater than the length of the buffer".to_owned(), + "nbytes is greater than the length of the buffer", ) })? } @@ -1317,7 +1316,7 @@ mod _socket { OptionalArg::Present(arg3) => { // should just be i32::try_from_obj but tests check for error message let int = arg2.try_index_opt(vm).unwrap_or_else(|| { - Err(vm.new_type_error("an integer is required".to_owned())) + Err(vm.new_type_error("an integer is required")) })?; let flags = int.try_to_primitive::(vm)?; (flags, arg3) @@ -1370,7 +1369,7 @@ mod _socket { |obj| -> PyResult<(i32, i32, ArgBytesLike)> { let seq: Vec = obj.try_into_value(vm)?; let [lvl, typ, data]: [PyObjectRef; 3] = seq.try_into().map_err(|_| { - vm.new_type_error("expected a sequence of length 3".to_owned()) + vm.new_type_error("expected a sequence of length 3") })?; Ok(( lvl.try_into_value(vm)?, @@ -1426,7 +1425,7 @@ mod _socket { for (lvl, typ, buf) in cmsgs { if pmhdr.is_null() { return Err(vm.new_runtime_error( - "unexpected NULL result from CMSG_FIRSTHDR/CMSG_NXTHDR".to_owned(), + "unexpected NULL result from CMSG_FIRSTHDR/CMSG_NXTHDR", )); } let data = &*buf.borrow_buf(); @@ -1590,7 +1589,7 @@ mod _socket { }, _ => { return Err(vm - .new_type_error("expected the value arg xor the optlen arg".to_owned()) + .new_type_error("expected the value arg xor the optlen arg") .into()); } }; @@ -1609,7 +1608,7 @@ mod _socket { c::SHUT_RDWR => Shutdown::Both, _ => { return Err(vm - .new_value_error("`how` must be SHUT_RD, SHUT_WR, or SHUT_RDWR".to_owned()) + .new_value_error("`how` must be SHUT_RD, SHUT_WR, or SHUT_RDWR") .into()); } }; @@ -1646,7 +1645,7 @@ mod _socket { fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult { let tuple = PyTupleRef::try_from_object(vm, obj)?; if tuple.len() != 2 { - Err(vm.new_type_error("Address tuple should have only 2 values".to_owned())) + Err(vm.new_type_error("Address tuple should have only 2 values")) } else { Self::from_tuple(&tuple, vm) } @@ -1659,7 +1658,7 @@ mod _socket { let port = i32::try_from_borrowed_object(vm, &tuple[1])?; let port = port .to_u16() - .ok_or_else(|| vm.new_overflow_error("port must be 0-65535.".to_owned()))?; + .ok_or_else(|| vm.new_overflow_error("port must be 0-65535."))?; Ok(Address { host, port }) } fn from_tuple_ipv6( @@ -1678,7 +1677,7 @@ mod _socket { .transpose()? .unwrap_or(0); if flowinfo > 0xfffff { - return Err(vm.new_overflow_error("flowinfo must be 0-1048575.".to_owned())); + return Err(vm.new_overflow_error("flowinfo must be 0-1048575.")); } Ok((addr, flowinfo, scopeid)) } @@ -1781,7 +1780,7 @@ mod _socket { vm: &VirtualMachine, ) -> PyResult { let port = port.to_u16().ok_or_else(|| { - vm.new_overflow_error("getservbyport: port must be 0-65535.".to_owned()) + vm.new_overflow_error("getservbyport: port must be 0-65535.") })?; let cstr_proto = protocolname .as_ref() @@ -2027,13 +2026,13 @@ mod _socket { match af_inet { c::AF_INET => { let packed_ip = <&[u8; 4]>::try_from(&*packed_ip).map_err(|_| { - vm.new_value_error("invalid length of packed IP address string".to_owned()) + vm.new_value_error("invalid length of packed IP address string") })?; Ok(Ipv4Addr::from(*packed_ip).to_string()) } c::AF_INET6 => { let packed_ip = <&[u8; 16]>::try_from(&*packed_ip).map_err(|_| { - vm.new_value_error("invalid length of packed IP address string".to_owned()) + vm.new_value_error("invalid length of packed IP address string") })?; Ok(get_ipv6_addr_str(Ipv6Addr::from(*packed_ip))) } @@ -2062,7 +2061,7 @@ mod _socket { 2..=4 => {} _ => { return Err(vm - .new_type_error("illegal sockaddr argument".to_owned()) + .new_type_error("illegal sockaddr argument") .into()); } } @@ -2294,7 +2293,7 @@ mod _socket { .codec_registry .encode_text(pyname, "idna", None, vm)?; let name = std::str::from_utf8(name.as_bytes()) - .map_err(|_| vm.new_runtime_error("idna output is not utf8".to_owned()))?; + .map_err(|_| vm.new_runtime_error("idna output is not utf8"))?; let mut res = dns_lookup::getaddrinfo(Some(name), None, Some(hints)) .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?; Ok(res.next().unwrap().map(|ainfo| ainfo.sockaddr)?) @@ -2311,7 +2310,7 @@ mod _socket { } }; if invalid { - return Err(vm.new_value_error("negative file descriptor".to_owned())); + return Err(vm.new_value_error("negative file descriptor")); } Ok(unsafe { sock_from_raw_unchecked(fileno) }) } @@ -2517,13 +2516,13 @@ mod _socket { #[pyfunction(name = "CMSG_LEN")] fn cmsg_len(length: usize, vm: &VirtualMachine) -> PyResult { checked_cmsg_len(length) - .ok_or_else(|| vm.new_overflow_error("CMSG_LEN() argument out of range".to_owned())) + .ok_or_else(|| vm.new_overflow_error("CMSG_LEN() argument out of range")) } #[cfg(all(unix, not(target_os = "redox")))] #[pyfunction(name = "CMSG_SPACE")] fn cmsg_space(length: usize, vm: &VirtualMachine) -> PyResult { checked_cmsg_space(length) - .ok_or_else(|| vm.new_overflow_error("CMSG_SPACE() argument out of range".to_owned())) + .ok_or_else(|| vm.new_overflow_error("CMSG_SPACE() argument out of range")) } } diff --git a/stdlib/src/sqlite.rs b/stdlib/src/sqlite.rs index 00ebec75a9..3e318ed06a 100644 --- a/stdlib/src/sqlite.rs +++ b/stdlib/src/sqlite.rs @@ -1016,7 +1016,7 @@ mod _sqlite { } = args; if zelf.is(&target) { return Err( - vm.new_value_error("target cannot be the same connection instance".to_owned()) + vm.new_value_error("target cannot be the same connection instance") ); } @@ -1165,7 +1165,7 @@ mod _sqlite { let data = Box::into_raw(Box::new(data)); if !callable.is_callable() { - return Err(vm.new_type_error("parameter must be callable".to_owned())); + return Err(vm.new_type_error("parameter must be callable")); } let ret = unsafe { @@ -1889,12 +1889,12 @@ mod _sqlite { return self.data.getitem_by_index(vm, i); } } - Err(vm.new_index_error("No item with that key".to_owned())) + Err(vm.new_index_error("No item with that key")) } else if let Some(slice) = needle.payload::() { let list = self.data.getitem_by_slice(vm, slice.to_saturated(vm)?)?; Ok(vm.ctx.new_tuple(list).into()) } else { - Err(vm.new_index_error("Index must be int or string".to_owned())) + Err(vm.new_index_error("Index must be int or string")) } } } @@ -1908,7 +1908,7 @@ mod _sqlite { .inner(vm)? .description .clone() - .ok_or_else(|| vm.new_value_error("no description in Cursor".to_owned()))?; + .ok_or_else(|| vm.new_value_error("no description in Cursor"))?; Self { data: args.1, @@ -2070,7 +2070,7 @@ mod _sqlite { let blob_len = inner.blob.bytes(); let overflow_err = - || vm.new_overflow_error("seek offset results in overflow".to_owned()); + || vm.new_overflow_error("seek offset results in overflow"); match origin { libc::SEEK_SET => {} @@ -2080,13 +2080,13 @@ mod _sqlite { libc::SEEK_END => offset = offset.checked_add(blob_len).ok_or_else(overflow_err)?, _ => { return Err(vm.new_value_error( - "'origin' should be os.SEEK_SET, os.SEEK_CUR, or os.SEEK_END".to_owned(), + "'origin' should be os.SEEK_SET, os.SEEK_CUR, or os.SEEK_END", )); } } if offset < 0 || offset > blob_len { - Err(vm.new_value_error("offset out of blob range".to_owned())) + Err(vm.new_value_error("offset out of blob range")) } else { inner.offset = offset; Ok(()) @@ -2123,7 +2123,7 @@ mod _sqlite { index += length; } if index < 0 || index >= length { - Err(vm.new_index_error("Blob index out of range".to_owned())) + Err(vm.new_index_error("Blob index out of range")) } else { Ok(index) } @@ -2139,7 +2139,7 @@ mod _sqlite { if length <= max_write as usize { Ok(length as c_int) } else { - Err(vm.new_value_error("data longer than blob length".to_owned())) + Err(vm.new_value_error("data longer than blob length")) } } @@ -2176,7 +2176,7 @@ mod _sqlite { } Ok(vm.ctx.new_bytes(buf).into()) } else { - Err(vm.new_type_error("Blob indices must be integers".to_owned())) + Err(vm.new_type_error("Blob indices must be integers")) } } @@ -2187,7 +2187,7 @@ mod _sqlite { vm: &VirtualMachine, ) -> PyResult<()> { let Some(value) = value else { - return Err(vm.new_type_error("Blob doesn't support deletion".to_owned())); + return Err(vm.new_type_error("Blob doesn't support deletion")); }; let inner = self.inner(vm)?; @@ -2206,13 +2206,13 @@ mod _sqlite { self.check(ret, vm) } else if let Some(_slice) = needle.payload::() { Err(vm.new_not_implemented_error( - "Blob slice assignment is not implemented".to_owned(), + "Blob slice assignment is not implemented", )) // let blob_len = inner.blob.bytes(); // let slice = slice.to_saturated(vm)?; // let (range, step, length) = slice.adjust_indices(blob_len as usize); } else { - Err(vm.new_type_error("Blob indices must be integers".to_owned())) + Err(vm.new_type_error("Blob indices must be integers")) } } @@ -2872,7 +2872,7 @@ mod _sqlite { let text = ptr_to_vec(sqlite3_value_text(val), sqlite3_value_bytes(val), db, vm)?; let text = String::from_utf8(text).map_err(|_| { - vm.new_value_error("invalid utf-8 with SQLITE_TEXT".to_owned()) + vm.new_value_error("invalid utf-8 with SQLITE_TEXT") })?; vm.ctx.new_str(text).into() } @@ -2893,10 +2893,10 @@ mod _sqlite { fn ptr_to_str<'a>(p: *const libc::c_char, vm: &VirtualMachine) -> PyResult<&'a str> { if p.is_null() { - return Err(vm.new_memory_error("string pointer is null".to_owned())); + return Err(vm.new_memory_error("string pointer is null")); } unsafe { CStr::from_ptr(p).to_str() } - .map_err(|_| vm.new_value_error("Invalid UIF-8 codepoint".to_owned())) + .map_err(|_| vm.new_value_error("Invalid UIF-8 codepoint")) } fn ptr_to_string( @@ -2906,7 +2906,7 @@ mod _sqlite { vm: &VirtualMachine, ) -> PyResult { let s = ptr_to_vec(p, nbytes, db, vm)?; - String::from_utf8(s).map_err(|_| vm.new_value_error("invalid utf-8".to_owned())) + String::from_utf8(s).map_err(|_| vm.new_value_error("invalid utf-8")) } fn ptr_to_vec( @@ -2917,12 +2917,12 @@ mod _sqlite { ) -> PyResult> { if p.is_null() { if !db.is_null() && unsafe { sqlite3_errcode(db) } == SQLITE_NOMEM { - Err(vm.new_memory_error("sqlite out of memory".to_owned())) + Err(vm.new_memory_error("sqlite out of memory")) } else { Ok(vec![]) } } else if nbytes < 0 { - Err(vm.new_system_error("negative size with ptr".to_owned())) + Err(vm.new_system_error("negative size with ptr")) } else { Ok(unsafe { std::slice::from_raw_parts(p.cast(), nbytes as usize) }.to_vec()) } @@ -2931,19 +2931,19 @@ mod _sqlite { fn str_to_ptr_len(s: &PyStr, vm: &VirtualMachine) -> PyResult<(*const libc::c_char, i32)> { let s = s .to_str() - .ok_or_else(|| vm.new_unicode_encode_error("surrogates not allowed".to_owned()))?; + .ok_or_else(|| vm.new_unicode_encode_error("surrogates not allowed"))?; let len = c_int::try_from(s.len()) - .map_err(|_| vm.new_overflow_error("TEXT longer than INT_MAX bytes".to_owned()))?; + .map_err(|_| vm.new_overflow_error("TEXT longer than INT_MAX bytes"))?; let ptr = s.as_ptr().cast(); Ok((ptr, len)) } fn buffer_to_ptr_len(buffer: &PyBuffer, vm: &VirtualMachine) -> PyResult<(*const c_void, i32)> { let bytes = buffer.as_contiguous().ok_or_else(|| { - vm.new_buffer_error("underlying buffer is not C-contiguous".to_owned()) + vm.new_buffer_error("underlying buffer is not C-contiguous") })?; let len = c_int::try_from(bytes.len()) - .map_err(|_| vm.new_overflow_error("BLOB longer than INT_MAX bytes".to_owned()))?; + .map_err(|_| vm.new_overflow_error("BLOB longer than INT_MAX bytes"))?; let ptr = bytes.as_ptr().cast(); Ok((ptr, len)) } @@ -3007,8 +3007,7 @@ mod _sqlite { .map(|&x| x.as_ptr().cast()) .ok_or_else(|| { vm.new_value_error( - "isolation_level string must be '', 'DEFERRED', 'IMMEDIATE', or 'EXCLUSIVE'" - .to_owned(), + "isolation_level string must be '', 'DEFERRED', 'IMMEDIATE', or 'EXCLUSIVE'", ) }) } diff --git a/stdlib/src/ssl.rs b/stdlib/src/ssl.rs index 16e6cf5b34..6f5d0589e0 100644 --- a/stdlib/src/ssl.rs +++ b/stdlib/src/ssl.rs @@ -428,7 +428,7 @@ mod _ssl { #[pyfunction(name = "RAND_bytes")] fn rand_bytes(n: i32, vm: &VirtualMachine) -> PyResult> { if n < 0 { - return Err(vm.new_value_error("num must be positive".to_owned())); + return Err(vm.new_value_error("num must be positive")); } let mut buf = vec![0; n as usize]; openssl::rand::rand_bytes(&mut buf).map_err(|e| convert_openssl_error(vm, e))?; @@ -438,7 +438,7 @@ mod _ssl { #[pyfunction(name = "RAND_pseudo_bytes")] fn rand_pseudo_bytes(n: i32, vm: &VirtualMachine) -> PyResult<(Vec, bool)> { if n < 0 { - return Err(vm.new_value_error("num must be positive".to_owned())); + return Err(vm.new_value_error("num must be positive")); } let mut buf = vec![0; n as usize]; let ret = unsafe { sys::RAND_bytes(buf.as_mut_ptr(), n) }; @@ -473,14 +473,14 @@ mod _ssl { fn py_new(cls: PyTypeRef, proto_version: Self::Args, vm: &VirtualMachine) -> PyResult { let proto = SslVersion::try_from(proto_version) - .map_err(|_| vm.new_value_error("invalid protocol version".to_owned()))?; + .map_err(|_| vm.new_value_error("invalid protocol version"))?; let method = match proto { // SslVersion::Ssl3 => unsafe { ssl::SslMethod::from_ptr(sys::SSLv3_method()) }, SslVersion::Tls => ssl::SslMethod::tls(), // TODO: Tls1_1, Tls1_2 ? SslVersion::TlsClient => ssl::SslMethod::tls_client(), SslVersion::TlsServer => ssl::SslMethod::tls_server(), - _ => return Err(vm.new_value_error("invalid protocol version".to_owned())), + _ => return Err(vm.new_value_error("invalid protocol version")), }; let mut builder = SslContextBuilder::new(method).map_err(|e| convert_openssl_error(vm, e))?; @@ -551,7 +551,7 @@ mod _ssl { vm: &VirtualMachine, ) -> PyResult<()> { let value = value - .ok_or_else(|| vm.new_attribute_error("cannot delete attribute".to_owned()))?; + .ok_or_else(|| vm.new_attribute_error("cannot delete attribute"))?; *self.post_handshake_auth.lock() = value.is_true(vm)?; Ok(()) } @@ -597,12 +597,11 @@ mod _ssl { fn set_verify_mode(&self, cert: i32, vm: &VirtualMachine) -> PyResult<()> { let mut ctx = self.builder(); let cert_req = CertRequirements::try_from(cert) - .map_err(|_| vm.new_value_error("invalid value for verify_mode".to_owned()))?; + .map_err(|_| vm.new_value_error("invalid value for verify_mode"))?; let mode = match cert_req { CertRequirements::None if self.check_hostname.load() => { return Err(vm.new_value_error( - "Cannot set verify_mode to CERT_NONE when check_hostname is enabled." - .to_owned(), + "Cannot set verify_mode to CERT_NONE when check_hostname is enabled.", )); } CertRequirements::None => SslVerifyMode::NONE, @@ -671,7 +670,7 @@ mod _ssl { #[cfg(not(ossl102))] { Err(vm.new_not_implemented_error( - "The NPN extension requires OpenSSL 1.0.1 or later.".to_owned(), + "The NPN extension requires OpenSSL 1.0.1 or later.", )) } } @@ -684,7 +683,7 @@ mod _ssl { ) -> PyResult<()> { if let (None, None, None) = (&args.cafile, &args.capath, &args.cadata) { return Err( - vm.new_type_error("cafile, capath and cadata cannot be all omitted".to_owned()) + vm.new_type_error("cafile, capath and cadata cannot be all omitted") ); } if let Some(cafile) = &args.cafile { @@ -697,7 +696,7 @@ mod _ssl { #[cold] fn invalid_cadata(vm: &VirtualMachine) -> PyBaseExceptionRef { vm.new_type_error( - "cadata should be an ASCII string or a bytes-like object".to_owned(), + "cadata should be an ASCII string or a bytes-like object", ) } @@ -763,7 +762,7 @@ mod _ssl { // TODO: requires passing a callback to C if password.is_some() { return Err( - vm.new_not_implemented_error("password arg not yet supported".to_owned()) + vm.new_not_implemented_error("password arg not yet supported") ); } let mut ctx = self.builder(); @@ -800,8 +799,7 @@ mod _ssl { let hostname = hostname.as_str(); if hostname.is_empty() || hostname.starts_with('.') { return Err(vm.new_value_error( - "server_hostname cannot be an empty string or start with a leading dot." - .to_owned(), + "server_hostname cannot be an empty string or start with a leading dot.", )); } let ip = hostname.parse::(); @@ -996,7 +994,7 @@ mod _ssl { let binary = binary.unwrap_or(false); let stream = self.stream.read(); if !stream.ssl().is_init_finished() { - return Err(vm.new_value_error("handshake not done yet".to_owned())); + return Err(vm.new_value_error("handshake not done yet")); } stream .ssl() diff --git a/stdlib/src/statistics.rs b/stdlib/src/statistics.rs index 72e5d129a0..141493c125 100644 --- a/stdlib/src/statistics.rs +++ b/stdlib/src/statistics.rs @@ -127,6 +127,6 @@ mod _statistics { vm: &VirtualMachine, ) -> PyResult { normal_dist_inv_cdf(*p, *mu, *sigma) - .ok_or_else(|| vm.new_value_error("inv_cdf undefined for these parameters".to_owned())) + .ok_or_else(|| vm.new_value_error("inv_cdf undefined for these parameters")) } } diff --git a/stdlib/src/termios.rs b/stdlib/src/termios.rs index 55cd45e651..899e5a7af9 100644 --- a/stdlib/src/termios.rs +++ b/stdlib/src/termios.rs @@ -199,7 +199,7 @@ mod termios { let [iflag, oflag, cflag, lflag, ispeed, ospeed, cc] = <&[PyObjectRef; 7]>::try_from(&*attributes.borrow_vec()) .map_err(|_| { - vm.new_type_error("tcsetattr, arg 3: must be 7 element list".to_owned()) + vm.new_type_error("tcsetattr, arg 3: must be 7 element list") })? .clone(); let mut termios = Termios::from_fd(fd).map_err(|e| termios_error(e, vm))?; @@ -225,7 +225,7 @@ mod termios { i.try_to_primitive(vm)? } else { return Err(vm.new_type_error( - "tcsetattr: elements of attributes must be characters or integers".to_owned(), + "tcsetattr: elements of attributes must be characters or integers", )); }; } diff --git a/stdlib/src/unicodedata.rs b/stdlib/src/unicodedata.rs index 9024294f93..5bec3ccf7a 100644 --- a/stdlib/src/unicodedata.rs +++ b/stdlib/src/unicodedata.rs @@ -51,7 +51,7 @@ impl<'a> TryFromBorrowedObject<'a> for NormalizeForm { "NFKC" => NormalizeForm::Nfkc, "NFD" => NormalizeForm::Nfd, "NFKD" => NormalizeForm::Nfkd, - _ => return Err(vm.new_value_error("invalid normalization form".to_owned())), + _ => return Err(vm.new_value_error("invalid normalization form")), }) }, vm, @@ -102,7 +102,7 @@ mod unicodedata { .code_points() .exactly_one() .map_err(|_| { - vm.new_type_error("argument must be an unicode character, not str".to_owned()) + vm.new_type_error("argument must be an unicode character, not str") })?; Ok(self.check_age(c).then_some(c)) @@ -149,7 +149,7 @@ mod unicodedata { } } } - default.ok_or_else(|| vm.new_value_error("character name not found!".to_owned())) + default.ok_or_else(|| vm.new_value_error("character name not found!")) } #[pymethod] diff --git a/stdlib/src/zlib.rs b/stdlib/src/zlib.rs index 0e25f4bf23..de6ffd1002 100644 --- a/stdlib/src/zlib.rs +++ b/stdlib/src/zlib.rs @@ -129,7 +129,7 @@ mod zlib { // 0 => ... 9..=15 => Ok(InitOptions::Standard { header, wbits }), 25..=31 => Ok(InitOptions::Gzip { wbits: wbits - 16 }), - _ => Err(vm.new_value_error("Invalid initialization option".to_owned())), + _ => Err(vm.new_value_error("Invalid initialization option")), } } @@ -293,7 +293,7 @@ mod zlib { fn decompress(&self, args: DecompressArgs, vm: &VirtualMachine) -> PyResult> { let max_length: usize = args.raw_max_length().unwrap_or(0).try_into().map_err(|_| { - vm.new_value_error("max_length must be non-negative".to_owned()) + vm.new_value_error("max_length must be non-negative") })?; let max_length = (max_length != 0).then_some(max_length); let data = &*args.data(); @@ -312,7 +312,7 @@ mod zlib { fn flush(&self, length: OptionalArg, vm: &VirtualMachine) -> PyResult> { let length = match length { OptionalArg::Present(ArgSize { value }) if value <= 0 => { - return Err(vm.new_value_error("length must be greater than zero".to_owned())); + return Err(vm.new_value_error("length must be greater than zero")); } OptionalArg::Present(ArgSize { value }) => value as usize, OptionalArg::Missing => DEF_BUF_SIZE, @@ -358,7 +358,7 @@ mod zlib { .. } = args; let level = - level.ok_or_else(|| vm.new_value_error("invalid initialization option".to_owned()))?; + level.ok_or_else(|| vm.new_value_error("invalid initialization option"))?; #[allow(unused_mut)] let mut compress = InitOptions::new(wbits.value, vm)?.compress(level); if let Some(zdict) = zdict { diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs index 03582215ba..ef6d24c100 100644 --- a/vm/src/anystr.rs +++ b/vm/src/anystr.rs @@ -176,7 +176,7 @@ pub trait AnyStr { SW: Fn(&Self, isize, &VirtualMachine) -> Vec, { if args.sep.as_ref().is_some_and(|sep| sep.is_empty()) { - return Err(vm.new_value_error("empty separator".to_owned())); + return Err(vm.new_value_error("empty separator")); } let splits = if let Some(pattern) = args.sep { let Some(pattern) = pattern.as_ref() else { @@ -331,7 +331,7 @@ pub trait AnyStr { S: std::iter::Iterator, { if sub.is_empty() { - return Err(vm.new_value_error("empty separator".to_owned())); + return Err(vm.new_value_error("empty separator")); } let mut sp = split(); diff --git a/vm/src/builtins/asyncgenerator.rs b/vm/src/builtins/asyncgenerator.rs index 3aee327e5b..60a477141f 100644 --- a/vm/src/builtins/asyncgenerator.rs +++ b/vm/src/builtins/asyncgenerator.rs @@ -207,14 +207,14 @@ impl PyAsyncGenASend { let val = match self.state.load() { AwaitableState::Closed => { return Err(vm.new_runtime_error( - "cannot reuse already awaited __anext__()/asend()".to_owned(), + "cannot reuse already awaited __anext__()/asend()", )); } AwaitableState::Iter => val, // already running, all good AwaitableState::Init => { if self.ag.running_async.load() { return Err(vm.new_runtime_error( - "anext(): asynchronous generator is already running".to_owned(), + "anext(): asynchronous generator is already running", )); } self.ag.running_async.store(true); @@ -244,7 +244,7 @@ impl PyAsyncGenASend { ) -> PyResult { if let AwaitableState::Closed = self.state.load() { return Err( - vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()".to_owned()) + vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()") ); } @@ -302,7 +302,7 @@ impl PyAsyncGenAThrow { match self.state.load() { AwaitableState::Closed => { Err(vm - .new_runtime_error("cannot reuse already awaited aclose()/athrow()".to_owned())) + .new_runtime_error("cannot reuse already awaited aclose()/athrow()")) } AwaitableState::Init => { if self.ag.running_async.load() { @@ -320,7 +320,7 @@ impl PyAsyncGenAThrow { } if !vm.is_none(&val) { return Err(vm.new_runtime_error( - "can't send non-None value to a just-started async generator".to_owned(), + "can't send non-None value to a just-started async generator", )); } self.state.store(AwaitableState::Iter); @@ -398,7 +398,7 @@ impl PyAsyncGenAThrow { fn yield_close(&self, vm: &VirtualMachine) -> PyBaseExceptionRef { self.ag.running_async.store(false); self.state.store(AwaitableState::Closed); - vm.new_runtime_error("async generator ignored GeneratorExit".to_owned()) + vm.new_runtime_error("async generator ignored GeneratorExit") } fn check_error(&self, exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyBaseExceptionRef { self.ag.running_async.store(false); diff --git a/vm/src/builtins/bool.rs b/vm/src/builtins/bool.rs index 006fc4d1eb..a909e3eb5c 100644 --- a/vm/src/builtins/bool.rs +++ b/vm/src/builtins/bool.rs @@ -66,7 +66,7 @@ impl PyObjectRef { let len_val = int_obj.as_bigint(); if len_val.sign() == Sign::Minus { - return Err(vm.new_value_error("__len__() should return >= 0".to_owned())); + return Err(vm.new_value_error("__len__() should return >= 0")); } !len_val.is_zero() } diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs index ce2232d8eb..d66dba44d7 100644 --- a/vm/src/builtins/bytearray.rs +++ b/vm/src/builtins/bytearray.rs @@ -414,7 +414,7 @@ impl PyByteArray { #[pymethod] fn index(&self, options: ByteInnerFindOptions, vm: &VirtualMachine) -> PyResult { let index = self.inner().find(options, |h, n| h.find(n), vm)?; - index.ok_or_else(|| vm.new_value_error("substring not found".to_owned())) + index.ok_or_else(|| vm.new_value_error("substring not found")) } #[pymethod] @@ -426,7 +426,7 @@ impl PyByteArray { #[pymethod] fn rindex(&self, options: ByteInnerFindOptions, vm: &VirtualMachine) -> PyResult { let index = self.inner().find(options, |h, n| h.rfind(n), vm)?; - index.ok_or_else(|| vm.new_value_error("substring not found".to_owned())) + index.ok_or_else(|| vm.new_value_error("substring not found")) } #[pymethod] @@ -586,7 +586,7 @@ impl Py { let elements = &mut self.try_resizable(vm)?.elements; let index = elements .wrap_index(index.unwrap_or(-1)) - .ok_or_else(|| vm.new_index_error("index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("index out of range"))?; Ok(elements.remove(index)) } @@ -612,7 +612,7 @@ impl Py { let elements = &mut self.try_resizable(vm)?.elements; let index = elements .find_byte(value) - .ok_or_else(|| vm.new_value_error("value not found in bytearray".to_owned()))?; + .ok_or_else(|| vm.new_value_error("value not found in bytearray"))?; elements.remove(index); Ok(()) } diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs index 77b9f9d526..86efaff6ce 100644 --- a/vm/src/builtins/bytes.rs +++ b/vm/src/builtins/bytes.rs @@ -337,7 +337,7 @@ impl PyBytes { #[pymethod] fn index(&self, options: ByteInnerFindOptions, vm: &VirtualMachine) -> PyResult { let index = self.inner.find(options, |h, n| h.find(n), vm)?; - index.ok_or_else(|| vm.new_value_error("substring not found".to_owned())) + index.ok_or_else(|| vm.new_value_error("substring not found")) } #[pymethod] @@ -349,7 +349,7 @@ impl PyBytes { #[pymethod] fn rindex(&self, options: ByteInnerFindOptions, vm: &VirtualMachine) -> PyResult { let index = self.inner.find(options, |h, n| h.rfind(n), vm)?; - index.ok_or_else(|| vm.new_value_error("substring not found".to_owned())) + index.ok_or_else(|| vm.new_value_error("substring not found")) } #[pymethod] diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs index 4bb209f6db..28e501e842 100644 --- a/vm/src/builtins/code.rs +++ b/vm/src/builtins/code.rs @@ -237,7 +237,7 @@ impl Representable for PyCode { impl PyCode { #[pyslot] fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult { - Err(vm.new_type_error("Cannot directly create code object".to_owned())) + Err(vm.new_type_error("Cannot directly create code object")) } #[pygetset] diff --git a/vm/src/builtins/complex.rs b/vm/src/builtins/complex.rs index 9eecb55225..e91209c326 100644 --- a/vm/src/builtins/complex.rs +++ b/vm/src/builtins/complex.rs @@ -112,7 +112,7 @@ fn to_op_complex(value: &PyObject, vm: &VirtualMachine) -> PyResult PyResult { if v2.is_zero() { - return Err(vm.new_zero_division_error("complex division by zero".to_owned())); + return Err(vm.new_zero_division_error("complex division by zero")); } Ok(v1.fdiv(v2)) @@ -132,7 +132,7 @@ fn inner_pow(v1: Complex64, v2: Complex64, vm: &VirtualMachine) -> PyResult(vm) { if args.imag.is_present() { return Err(vm.new_type_error( - "complex() can't take second arg if first is a string".to_owned(), + "complex() can't take second arg if first is a string", )); } let (re, im) = s .to_str() .and_then(rustpython_literal::complex::parse_str) .ok_or_else(|| { - vm.new_value_error("complex() arg is a malformed string".to_owned()) + vm.new_value_error("complex() arg is a malformed string") })?; return Self::from(Complex64 { re, im }) .into_ref_with_type(vm, cls) @@ -205,7 +205,7 @@ impl Constructor for PyComplex { c } else if obj.class().fast_issubclass(vm.ctx.types.str_type) { return Err( - vm.new_type_error("complex() second arg can't be a string".to_owned()) + vm.new_type_error("complex() second arg can't be a string") ); } else { return Err(vm.new_type_error(format!( @@ -265,7 +265,7 @@ impl PyComplex { let is_finite = im.is_finite() && re.is_finite(); let abs_result = re.hypot(im); if is_finite && abs_result.is_infinite() { - Err(vm.new_overflow_error("absolute value too large".to_string())) + Err(vm.new_overflow_error("absolute value too large")) } else { Ok(abs_result) } @@ -366,7 +366,7 @@ impl PyComplex { vm: &VirtualMachine, ) -> PyResult> { if mod_val.flatten().is_some() { - Err(vm.new_value_error("complex modulo not allowed".to_owned())) + Err(vm.new_value_error("complex modulo not allowed")) } else { self.op(other, |a, b| inner_pow(a, b, vm), vm) } diff --git a/vm/src/builtins/descriptor.rs b/vm/src/builtins/descriptor.rs index 0346a998b7..52fea6e7d2 100644 --- a/vm/src/builtins/descriptor.rs +++ b/vm/src/builtins/descriptor.rs @@ -199,7 +199,7 @@ impl PyMemberDef { match self.setter { MemberSetter::Setter(setter) => match setter { Some(setter) => (setter)(vm, obj, value), - None => Err(vm.new_attribute_error("readonly attribute".to_string())), + None => Err(vm.new_attribute_error("readonly attribute")), }, MemberSetter::Offset(offset) => set_slot_at_object(obj, offset, self, value, vm), } @@ -234,7 +234,7 @@ fn calculate_qualname(descr: &PyDescriptorOwned, vm: &VirtualMachine) -> PyResul if let Some(qualname) = vm.get_attribute_opt(descr.typ.clone().into(), "__qualname__")? { let str = qualname.downcast::().map_err(|_| { vm.new_type_error( - ".__objclass__.__qualname__ is not a unicode object".to_owned(), + ".__objclass__.__qualname__ is not a unicode object", ) })?; Ok(Some(format!("{}.{}", str, descr.name))) @@ -307,7 +307,7 @@ fn set_slot_at_object( PySetterValue::Assign(v) => { if !v.class().is(vm.ctx.types.bool_type) { return Err( - vm.new_type_error("attribute value type must be bool".to_owned()) + vm.new_type_error("attribute value type must be bool") ); } diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs index f78543a5f5..2b1aa3ad04 100644 --- a/vm/src/builtins/dict.rs +++ b/vm/src/builtins/dict.rs @@ -78,7 +78,7 @@ impl PyDict { let iter = other.get_iter(vm)?; loop { fn err(vm: &VirtualMachine) -> PyBaseExceptionRef { - vm.new_value_error("Iterator must have exactly two elements".to_owned()) + vm.new_value_error("Iterator must have exactly two elements") } let element = match iter.next(vm)? { PyIterReturn::Return(obj) => obj, @@ -103,7 +103,7 @@ impl PyDict { dict.insert(vm, &*key, value)?; } if dict_other.entries.has_changed_size(dict_size) { - return Err(vm.new_runtime_error("dict mutated during update".to_owned())); + return Err(vm.new_runtime_error("dict mutated during update")); } Ok(()) } diff --git a/vm/src/builtins/float.rs b/vm/src/builtins/float.rs index 85f2a07bb9..cba519a9bc 100644 --- a/vm/src/builtins/float.rs +++ b/vm/src/builtins/float.rs @@ -80,12 +80,12 @@ impl_try_from_object_float!(f32, f64); fn inner_div(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult { float_ops::div(v1, v2) - .ok_or_else(|| vm.new_zero_division_error("float division by zero".to_owned())) + .ok_or_else(|| vm.new_zero_division_error("float division by zero")) } fn inner_mod(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult { float_ops::mod_(v1, v2) - .ok_or_else(|| vm.new_zero_division_error("float mod by zero".to_owned())) + .ok_or_else(|| vm.new_zero_division_error("float mod by zero")) } pub fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult { @@ -94,11 +94,11 @@ pub fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult { None => { if value.is_infinite() { Err(vm.new_overflow_error( - "OverflowError: cannot convert float infinity to integer".to_owned(), + "OverflowError: cannot convert float infinity to integer", )) } else if value.is_nan() { Err(vm - .new_value_error("ValueError: cannot convert float NaN to integer".to_owned())) + .new_value_error("ValueError: cannot convert float NaN to integer")) } else { // unreachable unless BigInt has a bug unreachable!( @@ -112,11 +112,11 @@ pub fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult { fn inner_floordiv(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult { float_ops::floordiv(v1, v2) - .ok_or_else(|| vm.new_zero_division_error("float floordiv by zero".to_owned())) + .ok_or_else(|| vm.new_zero_division_error("float floordiv by zero")) } fn inner_divmod(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<(f64, f64)> { - float_ops::divmod(v1, v2).ok_or_else(|| vm.new_zero_division_error("float divmod()".to_owned())) + float_ops::divmod(v1, v2).ok_or_else(|| vm.new_zero_division_error("float divmod()")) } pub fn float_pow(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult { @@ -220,7 +220,7 @@ impl PyFloat { fn getformat(spec: PyStrRef, vm: &VirtualMachine) -> PyResult { if !matches!(spec.as_str(), "double" | "float") { return Err(vm.new_value_error( - "__getformat__() argument 1 must be 'double' or 'float'".to_owned(), + "__getformat__() argument 1 must be 'double' or 'float'", )); } @@ -357,7 +357,7 @@ impl PyFloat { vm: &VirtualMachine, ) -> PyResult { if mod_val.flatten().is_some() { - Err(vm.new_type_error("floating point pow() does not accept a 3rd argument".to_owned())) + Err(vm.new_type_error("floating point pow() does not accept a 3rd argument")) } else { self.complex_op(other, |a, b| float_pow(a, b, vm), vm) } @@ -424,7 +424,7 @@ impl PyFloat { None => i32::MIN, }; let float = float_ops::round_float_digits(self.value, ndigits).ok_or_else(|| { - vm.new_overflow_error("overflow occurred during round".to_owned()) + vm.new_overflow_error("overflow occurred during round") })?; vm.ctx.new_float(float).into() } else { @@ -482,9 +482,9 @@ impl PyFloat { .map(|(numer, denom)| (vm.ctx.new_bigint(&numer), vm.ctx.new_bigint(&denom))) .ok_or_else(|| { if value.is_infinite() { - vm.new_overflow_error("cannot convert Infinity to integer ratio".to_owned()) + vm.new_overflow_error("cannot convert Infinity to integer ratio") } else if value.is_nan() { - vm.new_value_error("cannot convert NaN to integer ratio".to_owned()) + vm.new_value_error("cannot convert NaN to integer ratio") } else { unreachable!("finite float must able to convert to integer ratio") } @@ -494,7 +494,7 @@ impl PyFloat { #[pyclassmethod] fn fromhex(cls: PyTypeRef, string: PyStrRef, vm: &VirtualMachine) -> PyResult { let result = crate::literal::float::from_hex(string.as_str().trim()).ok_or_else(|| { - vm.new_value_error("invalid hexadecimal floating-point string".to_owned()) + vm.new_value_error("invalid hexadecimal floating-point string") })?; PyType::call(&cls, vec![vm.ctx.new_float(result).into()].into(), vm) } diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs index 1b73850190..51bca2bc5a 100644 --- a/vm/src/builtins/frame.rs +++ b/vm/src/builtins/frame.rs @@ -94,7 +94,7 @@ impl Frame { let zelf: FrameRef = zelf.downcast().unwrap_or_else(|_| unreachable!()); let value: PyIntRef = value.downcast().map_err(|_| { - vm.new_type_error("attribute value type must be bool".to_owned()) + vm.new_type_error("attribute value type must be bool") })?; let mut trace_lines = zelf.trace_lines.lock(); @@ -103,7 +103,7 @@ impl Frame { Ok(()) } PySetterValue::Delete => { - Err(vm.new_type_error("can't delete numeric/char attribute".to_owned())) + Err(vm.new_type_error("can't delete numeric/char attribute")) } } } diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs index b1334d22a4..a9e577c573 100644 --- a/vm/src/builtins/function.rs +++ b/vm/src/builtins/function.rs @@ -493,14 +493,14 @@ impl PyFunction { PySetterValue::Assign(value) => { let Ok(qualname) = value.downcast::() else { return Err(vm.new_type_error( - "__qualname__ must be set to a string object".to_string(), + "__qualname__ must be set to a string object", )); }; *self.qualname.lock() = qualname; } PySetterValue::Delete => { return Err( - vm.new_type_error("__qualname__ must be set to a string object".to_string()) + vm.new_type_error("__qualname__ must be set to a string object") ); } } @@ -524,7 +524,7 @@ impl PyFunction { } PySetterValue::Delete => { return Err( - vm.new_type_error("__type_params__ must be set to a tuple object".to_string()) + vm.new_type_error("__type_params__ must be set to a tuple object") ); } } @@ -618,7 +618,7 @@ impl Constructor for PyFunction { PyTupleTyped::::try_from_object(vm, closure_tuple.into())?; Some(typed_closure) } else if !args.code.freevars.is_empty() { - return Err(vm.new_type_error("arg 5 (closure) must be tuple".to_owned())); + return Err(vm.new_type_error("arg 5 (closure) must be tuple")); } else { None }; @@ -862,7 +862,7 @@ impl PyCell { #[pygetset] fn cell_contents(&self, vm: &VirtualMachine) -> PyResult { self.get() - .ok_or_else(|| vm.new_value_error("Cell is empty".to_owned())) + .ok_or_else(|| vm.new_value_error("Cell is empty")) } #[pygetset(setter)] fn set_cell_contents(&self, x: PySetterValue) { diff --git a/vm/src/builtins/function/jitfunc.rs b/vm/src/builtins/function/jitfunc.rs index a46d9aa0f3..c528c9bb31 100644 --- a/vm/src/builtins/function/jitfunc.rs +++ b/vm/src/builtins/function/jitfunc.rs @@ -102,7 +102,7 @@ pub fn get_jit_arg_types(func: &Py, vm: &VirtualMachine) -> PyResult Ok(arg_types) } else { - Err(vm.new_type_error("Function annotations aren't a dict".to_owned())) + Err(vm.new_type_error("Function annotations aren't a dict")) } } @@ -121,7 +121,7 @@ pub fn jit_ret_type(func: &Py, vm: &VirtualMachine) -> PyResult PyResult { if !args.kwargs.is_empty() { - return Err(vm.new_type_error("GenericAlias() takes no keyword arguments".to_owned())); + return Err(vm.new_type_error("GenericAlias() takes no keyword arguments")); } let (origin, arguments): (_, PyObjectRef) = args.bind(vm)?; PyGenericAlias::new(origin, arguments, vm) @@ -194,13 +194,13 @@ impl PyGenericAlias { #[pymethod(magic)] fn instancecheck(_zelf: PyRef, _obj: PyObjectRef, vm: &VirtualMachine) -> PyResult { Err(vm - .new_type_error("isinstance() argument 2 cannot be a parameterized generic".to_owned())) + .new_type_error("isinstance() argument 2 cannot be a parameterized generic")) } #[pymethod(magic)] fn subclasscheck(_zelf: PyRef, _obj: PyObjectRef, vm: &VirtualMachine) -> PyResult { Err(vm - .new_type_error("issubclass() argument 2 cannot be a parameterized generic".to_owned())) + .new_type_error("issubclass() argument 2 cannot be a parameterized generic")) } #[pymethod(magic)] diff --git a/vm/src/builtins/int.rs b/vm/src/builtins/int.rs index 80aaae03eb..176fee246c 100644 --- a/vm/src/builtins/int.rs +++ b/vm/src/builtins/int.rs @@ -121,7 +121,7 @@ fn inner_pow(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult { fn inner_mod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult { if int2.is_zero() { - Err(vm.new_zero_division_error("integer modulo by zero".to_owned())) + Err(vm.new_zero_division_error("integer modulo by zero")) } else { Ok(vm.ctx.new_int(int1.mod_floor(int2)).into()) } @@ -129,7 +129,7 @@ fn inner_mod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult { fn inner_floordiv(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult { if int2.is_zero() { - Err(vm.new_zero_division_error("integer division by zero".to_owned())) + Err(vm.new_zero_division_error("integer division by zero")) } else { Ok(vm.ctx.new_int(int1.div_floor(int2)).into()) } @@ -137,7 +137,7 @@ fn inner_floordiv(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult fn inner_divmod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult { if int2.is_zero() { - return Err(vm.new_zero_division_error("integer division or modulo by zero".to_owned())); + return Err(vm.new_zero_division_error("integer division or modulo by zero")); } let (div, modulo) = int1.div_mod_floor(int2); Ok(vm.new_tuple((div, modulo)).into()) @@ -150,7 +150,7 @@ fn inner_lshift(base: &BigInt, bits: &BigInt, vm: &VirtualMachine) -> PyResult { |base, bits| base << bits, |bits, vm| { bits.to_usize().ok_or_else(|| { - vm.new_overflow_error("the number is too large to convert to int".to_owned()) + vm.new_overflow_error("the number is too large to convert to int") }) }, vm, @@ -179,7 +179,7 @@ where S: Fn(&BigInt, &VirtualMachine) -> PyResult, { if bits.is_negative() { - Err(vm.new_value_error("negative shift count".to_owned())) + Err(vm.new_value_error("negative shift count")) } else if base.is_zero() { Ok(vm.ctx.new_int(0).into()) } else { @@ -189,7 +189,7 @@ where fn inner_truediv(i1: &BigInt, i2: &BigInt, vm: &VirtualMachine) -> PyResult { if i2.is_zero() { - return Err(vm.new_zero_division_error("division by zero".to_owned())); + return Err(vm.new_zero_division_error("division by zero")); } let float = true_div(i1, i2); @@ -210,7 +210,7 @@ impl Constructor for PyInt { fn py_new(cls: PyTypeRef, options: Self::Args, vm: &VirtualMachine) -> PyResult { if cls.is(vm.ctx.types.bool_type) { return Err( - vm.new_type_error("int.__new__(bool) is not safe, use bool.__new__()".to_owned()) + vm.new_type_error("int.__new__(bool) is not safe, use bool.__new__()") ); } @@ -222,7 +222,7 @@ impl Constructor for PyInt { .to_u32() .filter(|&v| v == 0 || (2..=36).contains(&v)) .ok_or_else(|| { - vm.new_value_error("int() base must be >= 2 and <= 36, or 0".to_owned()) + vm.new_value_error("int() base must be >= 2 and <= 36, or 0") })?; try_int_radix(&val, base, vm) } else { @@ -240,7 +240,7 @@ impl Constructor for PyInt { val.try_int(vm).map(|x| x.as_bigint().clone()) } } else if let OptionalArg::Present(_) = options.base { - Err(vm.new_type_error("int() missing string argument".to_owned())) + Err(vm.new_type_error("int() missing string argument")) } else { Ok(Zero::zero()) }?; @@ -411,7 +411,7 @@ impl PyInt { None => return Ok(vm.ctx.not_implemented()), }; if modulus.is_zero() { - return Err(vm.new_value_error("pow() 3rd argument cannot be 0".to_owned())); + return Err(vm.new_value_error("pow() 3rd argument cannot be 0")); } self.general_op( @@ -435,7 +435,7 @@ impl PyInt { } let a = inverse(a % modulus, modulus).ok_or_else(|| { vm.new_value_error( - "base is not invertible for the given modulus".to_owned(), + "base is not invertible for the given modulus", ) })?; let b = -b; @@ -634,7 +634,7 @@ impl PyInt { match value.sign() { Sign::Minus if !signed => { return Err( - vm.new_overflow_error("can't convert negative int to unsigned".to_owned()) + vm.new_overflow_error("can't convert negative int to unsigned") ); } Sign::NoSign => return Ok(vec![0u8; byte_len].into()), @@ -650,7 +650,7 @@ impl PyInt { let origin_len = origin_bytes.len(); if origin_len > byte_len { - return Err(vm.new_overflow_error("int too big to convert".to_owned())); + return Err(vm.new_overflow_error("int too big to convert")); } let mut append_bytes = match value.sign() { @@ -882,7 +882,7 @@ pub(crate) fn get_value(obj: &PyObject) -> &BigInt { pub fn try_to_float(int: &BigInt, vm: &VirtualMachine) -> PyResult { bigint_to_finite_float(int) - .ok_or_else(|| vm.new_overflow_error("int too large to convert to float".to_owned())) + .ok_or_else(|| vm.new_overflow_error("int too large to convert to float")) } pub(crate) fn init(context: &Context) { diff --git a/vm/src/builtins/iter.rs b/vm/src/builtins/iter.rs index 0bd1994801..31062b5c14 100644 --- a/vm/src/builtins/iter.rs +++ b/vm/src/builtins/iter.rs @@ -64,7 +64,7 @@ impl PositionIterInternal { self.position = f(obj, i); Ok(()) } else { - Err(vm.new_type_error("an integer is required.".to_owned())) + Err(vm.new_type_error("an integer is required.")) } } else { Ok(()) diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs index 4962ae51e3..a5b7f78f8f 100644 --- a/vm/src/builtins/list.rs +++ b/vm/src/builtins/list.rs @@ -279,9 +279,9 @@ impl PyList { i += elements.len() as isize; } if elements.is_empty() { - Err(vm.new_index_error("pop from empty list".to_owned())) + Err(vm.new_index_error("pop from empty list")) } else if i < 0 || i as usize >= elements.len() { - Err(vm.new_index_error("pop index out of range".to_owned())) + Err(vm.new_index_error("pop index out of range")) } else { Ok(elements.remove(i as usize)) } @@ -324,7 +324,7 @@ impl PyList { res?; if !elements.is_empty() { - return Err(vm.new_value_error("list modified during sort".to_owned())); + return Err(vm.new_value_error("list modified during sort")); } Ok(()) diff --git a/vm/src/builtins/memory.rs b/vm/src/builtins/memory.rs index 801d94fb36..5cf1d6d3f5 100644 --- a/vm/src/builtins/memory.rs +++ b/vm/src/builtins/memory.rs @@ -134,7 +134,7 @@ impl PyMemoryView { fn try_not_released(&self, vm: &VirtualMachine) -> PyResult<()> { if self.released.load() { - Err(vm.new_value_error("operation forbidden on released memoryview object".to_owned())) + Err(vm.new_value_error("operation forbidden on released memoryview object")) } else { Ok(()) } @@ -143,13 +143,13 @@ impl PyMemoryView { fn getitem_by_idx(&self, i: isize, vm: &VirtualMachine) -> PyResult { if self.desc.ndim() != 1 { return Err(vm.new_not_implemented_error( - "multi-dimensional sub-views are not implemented".to_owned(), + "multi-dimensional sub-views are not implemented", )); } let (shape, stride, suboffset) = self.desc.dim_desc[0]; let index = i .wrapped_at(shape) - .ok_or_else(|| vm.new_index_error("index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("index out of range"))?; let index = index as isize * stride + suboffset; let pos = (index + self.start as isize) as usize; self.unpack_single(pos, vm) @@ -171,12 +171,12 @@ impl PyMemoryView { fn setitem_by_idx(&self, i: isize, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { if self.desc.ndim() != 1 { - return Err(vm.new_not_implemented_error("sub-views are not implemented".to_owned())); + return Err(vm.new_not_implemented_error("sub-views are not implemented")); } let (shape, stride, suboffset) = self.desc.dim_desc[0]; let index = i .wrapped_at(shape) - .ok_or_else(|| vm.new_index_error("index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("index out of range"))?; let index = index as isize * stride + suboffset; let pos = (index + self.start as isize) as usize; self.pack_single(pos, value, vm) @@ -223,7 +223,7 @@ impl PyMemoryView { match indexes.len().cmp(&self.desc.ndim()) { Ordering::Less => { return Err( - vm.new_not_implemented_error("sub-views are not implemented".to_owned()) + vm.new_not_implemented_error("sub-views are not implemented") ); } Ordering::Greater => { @@ -492,7 +492,7 @@ impl Py { vm: &VirtualMachine, ) -> PyResult<()> { if self.desc.ndim() != 1 { - return Err(vm.new_not_implemented_error("sub-view are not implemented".to_owned())); + return Err(vm.new_not_implemented_error("sub-view are not implemented")); } let mut dest = self.new_view(); @@ -502,7 +502,7 @@ impl Py { if self.is(&src) { return if !is_equiv_structure(&self.desc, &dest.desc) { Err(vm.new_value_error( - "memoryview assignment: lvalue and rvalue have different structures".to_owned(), + "memoryview assignment: lvalue and rvalue have different structures", )) } else { // assign self[:] to self @@ -522,7 +522,7 @@ impl Py { if !is_equiv_structure(&src.desc, &dest.desc) { return Err(vm.new_value_error( - "memoryview assignment: lvalue and rvalue have different structures".to_owned(), + "memoryview assignment: lvalue and rvalue have different structures", )); } @@ -666,7 +666,7 @@ impl PyMemoryView { return zelf.unpack_single(0, vm); } } - return Err(vm.new_type_error("invalid indexing of 0-dim memory".to_owned())); + return Err(vm.new_type_error("invalid indexing of 0-dim memory")); } match SubscriptNeedle::try_from_object(vm, needle)? { @@ -679,9 +679,9 @@ impl PyMemoryView { #[pymethod(magic)] fn delitem(&self, _needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { if self.desc.readonly { - return Err(vm.new_type_error("cannot modify read-only memory".to_owned())); + return Err(vm.new_type_error("cannot modify read-only memory")); } - Err(vm.new_type_error("cannot delete memory".to_owned())) + Err(vm.new_type_error("cannot delete memory")) } #[pymethod(magic)] @@ -741,7 +741,7 @@ impl PyMemoryView { let itemsize = format_spec.size(); if self.desc.len % itemsize != 0 { return Err( - vm.new_type_error("memoryview: length is not a multiple of itemsize".to_owned()) + vm.new_type_error("memoryview: length is not a multiple of itemsize") ); } @@ -766,7 +766,7 @@ impl PyMemoryView { self.try_not_released(vm)?; if !self.desc.is_contiguous() { return Err(vm.new_type_error( - "memoryview: casts are restricted to C-contiguous views".to_owned(), + "memoryview: casts are restricted to C-contiguous views", )); } @@ -775,7 +775,7 @@ impl PyMemoryView { if let OptionalArg::Present(shape) = shape { if self.desc.is_zero_in_shape() { return Err(vm.new_type_error( - "memoryview: cannot cast view with zeros in shape or strides".to_owned(), + "memoryview: cannot cast view with zeros in shape or strides", )); } @@ -798,7 +798,7 @@ impl PyMemoryView { // TODO: MAX_NDIM if self.desc.ndim() != 1 && shape_ndim != 1 { return Err( - vm.new_type_error("memoryview: cast must be 1D -> ND or ND -> 1D".to_owned()) + vm.new_type_error("memoryview: cast must be 1D -> ND or ND -> 1D") ); } @@ -820,7 +820,7 @@ impl PyMemoryView { if x > isize::MAX as usize / product_shape { return Err(vm.new_value_error( - "memoryview.cast(): product(shape) > SSIZE_MAX".to_owned(), + "memoryview.cast(): product(shape) > SSIZE_MAX", )); } product_shape *= x; @@ -834,7 +834,7 @@ impl PyMemoryView { if product_shape != other.desc.len { return Err(vm.new_type_error( - "memoryview: product(shape) * itemsize != buffer size".to_owned(), + "memoryview: product(shape) * itemsize != buffer size", )); } @@ -858,10 +858,10 @@ impl Py { ) -> PyResult<()> { self.try_not_released(vm)?; if self.desc.readonly { - return Err(vm.new_type_error("cannot modify read-only memory".to_owned())); + return Err(vm.new_type_error("cannot modify read-only memory")); } if value.is(&vm.ctx.none) { - return Err(vm.new_type_error("cannot delete memory".to_owned())); + return Err(vm.new_type_error("cannot delete memory")); } if self.desc.ndim() == 0 { @@ -873,7 +873,7 @@ impl Py { return self.pack_single(0, value, vm); } } - return Err(vm.new_type_error("invalid indexing of 0-dim memory".to_owned())); + return Err(vm.new_type_error("invalid indexing of 0-dim memory")); } match SubscriptNeedle::try_from_object(vm, needle)? { SubscriptNeedle::Index(i) => self.setitem_by_idx(i, value, vm), @@ -889,7 +889,7 @@ impl Py { #[pymethod(magic)] fn reduce(&self, vm: &VirtualMachine) -> PyResult { - Err(vm.new_type_error("cannot pickle 'memoryview' object".to_owned())) + Err(vm.new_type_error("cannot pickle 'memoryview' object")) } } @@ -930,11 +930,11 @@ impl TryFromObject for SubscriptNeedle { return Ok(Self::MultiIndex(v)); } else if tuple.iter().all(|x| x.payload_is::()) { return Err(vm.new_not_implemented_error( - "multi-dimensional slicing is not implemented".to_owned(), + "multi-dimensional slicing is not implemented", )); } } - Err(vm.new_type_error("memoryview: invalid slice key".to_owned())) + Err(vm.new_type_error("memoryview: invalid slice key")) } } } @@ -949,7 +949,7 @@ static BUFFER_METHODS: BufferMethods = BufferMethods { impl AsBuffer for PyMemoryView { fn as_buffer(zelf: &Py, vm: &VirtualMachine) -> PyResult { if zelf.released.load() { - Err(vm.new_value_error("operation forbidden on released memoryview object".to_owned())) + Err(vm.new_value_error("operation forbidden on released memoryview object")) } else { Ok(PyBuffer::new( zelf.to_owned().into(), @@ -1039,7 +1039,7 @@ impl Hashable for PyMemoryView { zelf.try_not_released(vm)?; if !zelf.desc.readonly { return Err( - vm.new_value_error("cannot hash writable memoryview object".to_owned()) + vm.new_value_error("cannot hash writable memoryview object") ); } Ok(zelf.contiguous_or_collect(|bytes| vm.state.hash_secret.hash_bytes(bytes))) diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs index e662df2485..0abf38415e 100644 --- a/vm/src/builtins/module.rs +++ b/vm/src/builtins/module.rs @@ -174,7 +174,7 @@ impl PyModule { let dict_attr = zelf.as_object().get_attr(identifier!(vm, __dict__), vm)?; let dict = dict_attr .downcast::() - .map_err(|_| vm.new_type_error(".__dict__ is not a dictionary".to_owned()))?; + .map_err(|_| vm.new_type_error(".__dict__ is not a dictionary"))?; let attrs = dict.into_iter().map(|(k, _v)| k).collect(); Ok(attrs) } diff --git a/vm/src/builtins/namespace.rs b/vm/src/builtins/namespace.rs index 38146baa72..90f42651dc 100644 --- a/vm/src/builtins/namespace.rs +++ b/vm/src/builtins/namespace.rs @@ -58,7 +58,7 @@ impl Initializer for PyNamespace { fn init(zelf: PyRef, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> { if !args.args.is_empty() { - return Err(vm.new_type_error("no positional arguments expected".to_owned())); + return Err(vm.new_type_error("no positional arguments expected")); } for (name, value) in args.kwargs.into_iter() { let name = vm.ctx.new_str(name); diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs index 6b1b0bb130..21a6a90b97 100644 --- a/vm/src/builtins/object.rs +++ b/vm/src/builtins/object.rs @@ -122,7 +122,7 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine) }; let slot_names = type_slot_names(obj.class(), vm) - .map_err(|_| vm.new_type_error("cannot pickle object".to_owned()))?; + .map_err(|_| vm.new_type_error("cannot pickle object"))?; if required { let mut basicsize = obj.class().slots.basicsize; @@ -426,8 +426,7 @@ impl PyBaseObject { Ok(()) } else { Err(vm.new_type_error( - "__class__ assignment only supported for mutable types or ModuleType subclasses" - .to_owned(), + "__class__ assignment only supported for mutable types or ModuleType subclasses", )) } } @@ -491,11 +490,11 @@ impl PyBaseObject { pub fn object_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult { obj.dict() - .ok_or_else(|| vm.new_attribute_error("This object has no __dict__".to_owned())) + .ok_or_else(|| vm.new_attribute_error("This object has no __dict__")) } pub fn object_set_dict(obj: PyObjectRef, dict: PyDictRef, vm: &VirtualMachine) -> PyResult<()> { obj.set_dict(dict) - .map_err(|_| vm.new_attribute_error("This object has no __dict__".to_owned())) + .map_err(|_| vm.new_attribute_error("This object has no __dict__")) } pub fn init(ctx: &Context) { diff --git a/vm/src/builtins/range.rs b/vm/src/builtins/range.rs index 55f9b814d0..55dad35cc2 100644 --- a/vm/src/builtins/range.rs +++ b/vm/src/builtins/range.rs @@ -200,7 +200,7 @@ impl PyRange { ) -> PyResult> { let step = step.map_or_else(|| vm.ctx.new_int(1), |step| step.into()); if step.as_bigint().is_zero() { - return Err(vm.new_value_error("range() arg 3 must not be zero".to_owned())); + return Err(vm.new_value_error("range() arg 3 must not be zero")); } PyRange { start: start.try_index(vm)?, @@ -304,7 +304,7 @@ impl PyRange { } RangeIndex::Int(index) => match self.get(index.as_bigint()) { Some(value) => Ok(vm.ctx.new_int(value).into()), - None => Err(vm.new_index_error("range object index out of range".to_owned())), + None => Err(vm.new_index_error("range object index out of range")), }, } } @@ -675,7 +675,7 @@ fn range_state(length: &BigInt, state: PyObjectRef, vm: &VirtualMachine) -> PyRe } Ok(index.to_usize().unwrap_or(0)) } else { - Err(vm.new_type_error("an integer is required.".to_owned())) + Err(vm.new_type_error("an integer is required.")) } } diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs index 43e6ee1f7d..25444f14dd 100644 --- a/vm/src/builtins/set.rs +++ b/vm/src/builtins/set.rs @@ -1308,7 +1308,7 @@ impl IterNext for PySetIterator { let next = if let IterStatus::Active(dict) = &internal.status { if dict.has_changed_size(&zelf.size) { internal.status = IterStatus::Exhausted; - return Err(vm.new_runtime_error("set changed size during iteration".to_owned())); + return Err(vm.new_runtime_error("set changed size during iteration")); } match dict.next_entry(internal.position) { Some((position, key, _)) => { diff --git a/vm/src/builtins/slice.rs b/vm/src/builtins/slice.rs index 4194360f4a..2847bff4a9 100644 --- a/vm/src/builtins/slice.rs +++ b/vm/src/builtins/slice.rs @@ -67,7 +67,7 @@ impl PySlice { let slice: PySlice = match args.args.len() { 0 => { return Err( - vm.new_type_error("slice() must have at least one arguments.".to_owned()) + vm.new_type_error("slice() must have at least one arguments.") ); } 1 => { @@ -106,7 +106,7 @@ impl PySlice { step = this_step.as_bigint().clone(); if step.is_zero() { - return Err(vm.new_value_error("slice step cannot be zero.".to_owned())); + return Err(vm.new_value_error("slice step cannot be zero.")); } } @@ -177,7 +177,7 @@ impl PySlice { fn indices(&self, length: ArgIndex, vm: &VirtualMachine) -> PyResult { let length = length.as_bigint(); if length.is_negative() { - return Err(vm.new_value_error("length should not be negative.".to_owned())); + return Err(vm.new_value_error("length should not be negative.")); } let (start, stop, step) = self.inner_indices(length, vm)?; Ok(vm.new_tuple((start, stop, step))) diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs index d19997c24b..c8983325c1 100644 --- a/vm/src/builtins/str.rs +++ b/vm/src/builtins/str.rs @@ -619,7 +619,7 @@ impl PyStr { UnicodeEscape::new_repr(self.as_wtf8()) .str_repr() .to_string() - .ok_or_else(|| vm.new_overflow_error("string is too long to generate repr".to_owned())) + .ok_or_else(|| vm.new_overflow_error("string is too long to generate repr")) } #[pymethod] @@ -1165,13 +1165,13 @@ impl PyStr { #[pymethod] fn index(&self, args: FindArgs, vm: &VirtualMachine) -> PyResult { self._find(args, |r, s| Some(Self::_to_char_idx(r, r.find(s)?))) - .ok_or_else(|| vm.new_value_error("substring not found".to_owned())) + .ok_or_else(|| vm.new_value_error("substring not found")) } #[pymethod] fn rindex(&self, args: FindArgs, vm: &VirtualMachine) -> PyResult { self._find(args, |r, s| Some(Self::_to_char_idx(r, r.rfind(s)?))) - .ok_or_else(|| vm.new_value_error("substring not found".to_owned())) + .ok_or_else(|| vm.new_value_error("substring not found")) } #[pymethod] @@ -1268,7 +1268,7 @@ impl PyStr { let fillchar = fillchar.map_or(Ok(' '.into()), |ref s| { s.as_wtf8().code_points().exactly_one().map_err(|_| { vm.new_type_error( - "The fill character must be exactly one character long".to_owned(), + "The fill character must be exactly one character long", ) }) })?; @@ -1343,13 +1343,13 @@ impl PyStr { .and_then(std::char::from_u32) .ok_or_else(|| { vm.new_value_error( - "character mapping must be in range(0x110000)".to_owned(), + "character mapping must be in range(0x110000)", ) })?; translated.push(ch); } else if !vm.is_none(&value) { return Err(vm.new_type_error( - "character mapping must return integer, None or str".to_owned(), + "character mapping must return integer, None or str", )); } } @@ -1386,13 +1386,12 @@ impl PyStr { Ok(new_dict.to_pyobject(vm)) } else { Err(vm.new_value_error( - "the first two maketrans arguments must have equal length".to_owned(), + "the first two maketrans arguments must have equal length", )) } } _ => Err(vm.new_type_error( - "first maketrans argument must be a string if there is a second argument" - .to_owned(), + "first maketrans argument must be a string if there is a second argument", )), } } else { @@ -1413,19 +1412,19 @@ impl PyStr { new_dict.set_item(&*num_value.to_pyobject(vm), val, vm)?; } else { return Err(vm.new_value_error( - "string keys in translate table must be of length 1".to_owned(), + "string keys in translate table must be of length 1", )); } } else { return Err(vm.new_type_error( - "keys in translate table must be strings or integers".to_owned(), + "keys in translate table must be strings or integers", )); } } Ok(new_dict.to_pyobject(vm)) } _ => Err(vm.new_value_error( - "if you give only one argument to maketrans it must be a dict".to_owned(), + "if you give only one argument to maketrans it must be a dict", )), } } diff --git a/vm/src/builtins/super.rs b/vm/src/builtins/super.rs index e2c5aa1a39..1e5a7fe3fe 100644 --- a/vm/src/builtins/super.rs +++ b/vm/src/builtins/super.rs @@ -81,10 +81,10 @@ impl Initializer for PySuper { } else { let frame = vm .current_frame() - .ok_or_else(|| vm.new_runtime_error("super(): no current frame".to_owned()))?; + .ok_or_else(|| vm.new_runtime_error("super(): no current frame"))?; if frame.code.arg_count == 0 { - return Err(vm.new_runtime_error("super(): no arguments".to_owned())); + return Err(vm.new_runtime_error("super(): no arguments")); } let obj = frame.fastlocals.lock()[0] .clone() @@ -99,14 +99,14 @@ impl Initializer for PySuper { None } }) - .ok_or_else(|| vm.new_runtime_error("super(): arg[0] deleted".to_owned()))?; + .ok_or_else(|| vm.new_runtime_error("super(): arg[0] deleted"))?; let mut typ = None; for (i, var) in frame.code.freevars.iter().enumerate() { if var.as_str() == "__class__" { let i = frame.code.cellvars.len() + i; let class = frame.cells_frees[i].get().ok_or_else(|| { - vm.new_runtime_error("super(): empty __class__ cell".to_owned()) + vm.new_runtime_error("super(): empty __class__ cell") })?; typ = Some(class.downcast().map_err(|o| { vm.new_type_error(format!( @@ -119,7 +119,7 @@ impl Initializer for PySuper { } let typ = typ.ok_or_else(|| { vm.new_type_error( - "super must be called with 1 argument or from inside class method".to_owned(), + "super must be called with 1 argument or from inside class method", ) })?; @@ -253,7 +253,7 @@ fn super_check(ty: PyTypeRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult } } Err(vm - .new_type_error("super(type, obj): obj must be an instance or subtype of type".to_owned())) + .new_type_error("super(type, obj): obj must be an instance or subtype of type")) } pub fn init(context: &Context) { diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs index 1dc7861071..a6ae9a5a46 100644 --- a/vm/src/builtins/tuple.rs +++ b/vm/src/builtins/tuple.rs @@ -312,7 +312,7 @@ impl PyTuple { return Ok(index); } } - Err(vm.new_value_error("tuple.index(x): x not in tuple".to_owned())) + Err(vm.new_value_error("tuple.index(x): x not in tuple")) } fn _contains(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult { diff --git a/vm/src/builtins/type.rs b/vm/src/builtins/type.rs index 45df7b5f64..8e0ee3223c 100644 --- a/vm/src/builtins/type.rs +++ b/vm/src/builtins/type.rs @@ -738,7 +738,7 @@ impl PyType { #[pygetset(magic, setter)] fn set_dict(&self, _value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { Err(vm.new_not_implemented_error( - "Setting __dict__ attribute on a type isn't yet implemented".to_owned(), + "Setting __dict__ attribute on a type isn't yet implemented", )) } @@ -769,7 +769,7 @@ impl PyType { )) })?; if name.as_bytes().contains(&0) { - return Err(vm.new_value_error("type name must not contain null characters".to_owned())); + return Err(vm.new_value_error("type name must not contain null characters")); } *self.heaptype_ext.as_ref().unwrap().name.write() = name; @@ -812,7 +812,7 @@ impl Constructor for PyType { args.clone().bind(vm)?; if name.as_bytes().contains(&0) { - return Err(vm.new_value_error("type name must not contain null characters".to_owned())); + return Err(vm.new_value_error("type name must not contain null characters")); } let (metatype, base, bases) = if bases.is_empty() { @@ -829,11 +829,10 @@ impl Constructor for PyType { { Err(vm.new_type_error( "type() doesn't support MRO entry resolution; \ - use types.new_class()" - .to_owned(), + use types.new_class()", )) } else { - Err(vm.new_type_error("bases must be types".to_owned())) + Err(vm.new_type_error("bases must be types")) } }) }) @@ -1463,8 +1462,7 @@ fn calculate_meta_class( return Err(vm.new_type_error( "metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass \ - of the metaclasses of all its bases" - .to_owned(), + of the metaclasses of all its bases", )); } Ok(winner) @@ -1513,7 +1511,7 @@ fn best_base<'a>(bases: &'a [PyTypeRef], vm: &VirtualMachine) -> PyResult<&'a Py base = Some(base_i.deref()); } else { return Err( - vm.new_type_error("multiple bases have instance layout conflict".to_string()) + vm.new_type_error("multiple bases have instance layout conflict") ); } } diff --git a/vm/src/builtins/union.rs b/vm/src/builtins/union.rs index 83e2c86f08..405da60f70 100644 --- a/vm/src/builtins/union.rs +++ b/vm/src/builtins/union.rs @@ -102,7 +102,7 @@ impl PyUnion { .any(|x| x.class().is(vm.ctx.types.generic_alias_type)) { Err(vm.new_type_error( - "isinstance() argument 2 cannot be a parameterized generic".to_owned(), + "isinstance() argument 2 cannot be a parameterized generic", )) } else { obj.is_instance(zelf.args().as_object(), vm) @@ -117,7 +117,7 @@ impl PyUnion { .any(|x| x.class().is(vm.ctx.types.generic_alias_type)) { Err(vm.new_type_error( - "issubclass() argument 2 cannot be a parameterized generic".to_owned(), + "issubclass() argument 2 cannot be a parameterized generic", )) } else { obj.is_subclass(zelf.args().as_object(), vm) diff --git a/vm/src/builtins/weakref.rs b/vm/src/builtins/weakref.rs index 9b2f248aa9..b8de184fb3 100644 --- a/vm/src/builtins/weakref.rs +++ b/vm/src/builtins/weakref.rs @@ -64,7 +64,7 @@ impl Hashable for PyWeak { hash::SENTINEL => { let obj = zelf .upgrade() - .ok_or_else(|| vm.new_type_error("weak object has gone away".to_owned()))?; + .ok_or_else(|| vm.new_type_error("weak object has gone away"))?; let hash = obj.hash(vm)?; match Radium::compare_exchange( &zelf.hash, diff --git a/vm/src/byte.rs b/vm/src/byte.rs index 42455bd27c..54cd82bfa0 100644 --- a/vm/src/byte.rs +++ b/vm/src/byte.rs @@ -15,7 +15,7 @@ pub fn bytes_from_object(vm: &VirtualMachine, obj: &PyObject) -> PyResult PyResult { obj.try_index(vm)? .as_bigint() .to_u8() - .ok_or_else(|| vm.new_value_error("byte must be in range(0, 256)".to_owned())) + .ok_or_else(|| vm.new_value_error("byte must be in range(0, 256)")) } diff --git a/vm/src/bytes_inner.rs b/vm/src/bytes_inner.rs index e2fb95a28a..27e477e69c 100644 --- a/vm/src/bytes_inner.rs +++ b/vm/src/bytes_inner.rs @@ -68,10 +68,10 @@ impl ByteInnerNewOptions { fn get_value_from_size(size: PyIntRef, vm: &VirtualMachine) -> PyResult { let size = size.as_bigint().to_isize().ok_or_else(|| { - vm.new_overflow_error("cannot fit 'int' into an index-sized integer".to_owned()) + vm.new_overflow_error("cannot fit 'int' into an index-sized integer") })?; let size = if size < 0 { - return Err(vm.new_value_error("negative count".to_owned())); + return Err(vm.new_value_error("negative count")); } else { size as usize }; @@ -164,7 +164,7 @@ impl ByteInnerNewOptions { Err(vm.new_type_error(ENCODING_WITHOUT_STRING.to_owned())) } (OptionalArg::Missing, _, OptionalArg::Present(_)) => { - Err(vm.new_type_error("errors without a string argument".to_owned())) + Err(vm.new_type_error("errors without a string argument")) } (OptionalArg::Present(_), OptionalArg::Missing, OptionalArg::Present(_)) => { Err(vm.new_type_error(STRING_WITHOUT_ENCODING.to_owned())) @@ -245,7 +245,7 @@ impl ByteInnerTranslateOptions { .filter(|v| v.elements.len() == 256) .ok_or_else(|| { vm.new_value_error( - "translation table must be 256 characters long".to_owned(), + "translation table must be 256 characters long", ) })?; Ok(bytes.elements.to_vec()) @@ -273,7 +273,7 @@ impl PyBytesInner { } fn new_repr_overflow_error(vm: &VirtualMachine) -> PyBaseExceptionRef { - vm.new_overflow_error("bytes object is too large to make repr".to_owned()) + vm.new_overflow_error("bytes object is too large to make repr") } pub fn repr_with_name(&self, class_name: &str, vm: &VirtualMachine) -> PyResult { @@ -583,7 +583,7 @@ impl PyBytesInner { ) -> PyResult> { if from.len() != to.len() { return Err( - vm.new_value_error("the two maketrans arguments must have equal length".to_owned()) + vm.new_value_error("the two maketrans arguments must have equal length") ); } let mut res = vec![]; @@ -873,7 +873,7 @@ impl PyBytesInner { if to.len() as isize - from.len() as isize > (isize::MAX - self.elements.len() as isize) / count as isize { - return Err(vm.new_overflow_error("replace bytes is too long".to_owned())); + return Err(vm.new_overflow_error("replace bytes is too long")); } let result_len = (self.elements.len() as isize + count as isize * (to.len() as isize - from.len() as isize)) @@ -1024,7 +1024,7 @@ pub trait ByteOr: ToPrimitive { fn byte_or(&self, vm: &VirtualMachine) -> PyResult { match self.to_u8() { Some(value) => Ok(value), - None => Err(vm.new_value_error("byte must be in range(0, 256)".to_owned())), + None => Err(vm.new_value_error("byte must be in range(0, 256)")), } } } @@ -1254,11 +1254,11 @@ pub fn bytes_to_hex( }; if sep.len() != 1 { - return Err(vm.new_value_error("sep must be length 1.".to_owned())); + return Err(vm.new_value_error("sep must be length 1.")); } let sep = sep[0]; if sep > 127 { - return Err(vm.new_value_error("sep must be ASCII.".to_owned())); + return Err(vm.new_value_error("sep must be ASCII.")); } Ok(hex_impl(bytes, sep, bytes_per_sep)) diff --git a/vm/src/cformat.rs b/vm/src/cformat.rs index 2904b9432e..6568c0054a 100644 --- a/vm/src/cformat.rs +++ b/vm/src/cformat.rs @@ -104,7 +104,7 @@ fn spec_format_bytes( if let Some(i) = obj.payload::() { let ch = i .try_to_primitive::(vm) - .map_err(|_| vm.new_overflow_error("%c arg not in range(256)".to_owned()))?; + .map_err(|_| vm.new_overflow_error("%c arg not in range(256)"))?; return Ok(spec.format_char(ch)); } if let Some(b) = obj.payload::() { @@ -118,7 +118,7 @@ fn spec_format_bytes( } } Err(vm - .new_type_error("%c requires an integer in range(256) or a single byte".to_owned())) + .new_type_error("%c requires an integer in range(256) or a single byte")) } } } @@ -194,7 +194,7 @@ fn spec_format_string( .to_u32() .and_then(CodePoint::from_u32) .ok_or_else(|| { - vm.new_overflow_error("%c arg not in range(0x110000)".to_owned()) + vm.new_overflow_error("%c arg not in range(0x110000)") })?; return Ok(spec.format_char(ch)); } @@ -203,7 +203,7 @@ fn spec_format_string( return Ok(spec.format_char(ch)); } } - Err(vm.new_type_error("%c requires int or char".to_owned())) + Err(vm.new_type_error("%c requires int or char")) } } } @@ -218,10 +218,10 @@ fn try_update_quantity_from_element( let i = i.try_to_primitive::(vm)?.unsigned_abs(); Ok(CFormatQuantity::Amount(i as usize)) } else { - Err(vm.new_type_error("* wants int".to_owned())) + Err(vm.new_type_error("* wants int")) } } - None => Err(vm.new_type_error("not enough arguments for format string".to_owned())), + None => Err(vm.new_type_error("not enough arguments for format string")), } } @@ -240,10 +240,10 @@ fn try_conversion_flag_from_tuple( }; Ok(flags) } else { - Err(vm.new_type_error("* wants int".to_owned())) + Err(vm.new_type_error("* wants int")) } } - None => Err(vm.new_type_error("not enough arguments for format string".to_owned())), + None => Err(vm.new_type_error("not enough arguments for format string")), } } @@ -277,7 +277,7 @@ fn try_update_precision_from_tuple<'a, I: Iterator>( } fn specifier_error(vm: &VirtualMachine) -> PyBaseExceptionRef { - vm.new_type_error("format requires a mapping".to_owned()) + vm.new_type_error("format requires a mapping") } pub(crate) fn cformat_bytes( @@ -313,7 +313,7 @@ pub(crate) fn cformat_bytes( } Ok(result) } else { - Err(vm.new_type_error("not all arguments converted during bytes formatting".to_owned())) + Err(vm.new_type_error("not all arguments converted during bytes formatting")) }; } @@ -333,7 +333,7 @@ pub(crate) fn cformat_bytes( } Ok(result) } else { - Err(vm.new_type_error("format requires a mapping".to_owned())) + Err(vm.new_type_error("format requires a mapping")) }; } @@ -360,7 +360,7 @@ pub(crate) fn cformat_bytes( let value = match value_iter.next() { Some(obj) => Ok(obj.clone()), None => { - Err(vm.new_type_error("not enough arguments for format string".to_owned())) + Err(vm.new_type_error("not enough arguments for format string")) } }?; let part_result = spec_format_bytes(vm, &spec, value)?; @@ -371,7 +371,7 @@ pub(crate) fn cformat_bytes( // check that all arguments were converted if value_iter.next().is_some() && !is_mapping { - Err(vm.new_type_error("not all arguments converted during bytes formatting".to_owned())) + Err(vm.new_type_error("not all arguments converted during bytes formatting")) } else { Ok(result) } @@ -410,7 +410,7 @@ pub(crate) fn cformat_string( Ok(result) } else { Err(vm - .new_type_error("not all arguments converted during string formatting".to_owned())) + .new_type_error("not all arguments converted during string formatting")) }; } @@ -429,7 +429,7 @@ pub(crate) fn cformat_string( } Ok(result) } else { - Err(vm.new_type_error("format requires a mapping".to_owned())) + Err(vm.new_type_error("format requires a mapping")) }; } @@ -456,7 +456,7 @@ pub(crate) fn cformat_string( let value = match value_iter.next() { Some(obj) => Ok(obj.clone()), None => { - Err(vm.new_type_error("not enough arguments for format string".to_owned())) + Err(vm.new_type_error("not enough arguments for format string")) } }?; let part_result = spec_format_string(vm, &spec, value, idx)?; @@ -467,7 +467,7 @@ pub(crate) fn cformat_string( // check that all arguments were converted if value_iter.next().is_some() && !is_mapping { - Err(vm.new_type_error("not all arguments converted during string formatting".to_owned())) + Err(vm.new_type_error("not all arguments converted during string formatting")) } else { Ok(result) } diff --git a/vm/src/codecs.rs b/vm/src/codecs.rs index 6d7e009c4a..623ab72949 100644 --- a/vm/src/codecs.rs +++ b/vm/src/codecs.rs @@ -86,7 +86,7 @@ impl PyCodec { .ok() .filter(|tuple| tuple.len() == 2) .ok_or_else(|| { - vm.new_type_error("encoder must return a tuple (object, integer)".to_owned()) + vm.new_type_error("encoder must return a tuple (object, integer)") })?; // we don't actually care about the integer Ok(res[0].clone()) @@ -108,7 +108,7 @@ impl PyCodec { .ok() .filter(|tuple| tuple.len() == 2) .ok_or_else(|| { - vm.new_type_error("decoder must return a tuple (object,integer)".to_owned()) + vm.new_type_error("decoder must return a tuple (object,integer)") })?; // we don't actually care about the integer Ok(res[0].clone()) @@ -145,7 +145,7 @@ impl TryFromObject for PyCodec { .ok() .and_then(|tuple| PyCodec::from_tuple(tuple).ok()) .ok_or_else(|| { - vm.new_type_error("codec search functions must return 4-tuples".to_owned()) + vm.new_type_error("codec search functions must return 4-tuples") }) } } @@ -203,7 +203,7 @@ impl CodecsRegistry { pub fn register(&self, search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { if !search_function.is_callable() { - return Err(vm.new_type_error("argument must be callable".to_owned())); + return Err(vm.new_type_error("argument must be callable")); } self.inner.write().search_path.push(search_function); Ok(()) @@ -787,7 +787,7 @@ impl<'a> DecodeErrorHandler> for StandardError { Ignore => errors::Ignore.handle_decode_error(ctx, byte_range, reason), Replace => errors::Replace.handle_decode_error(ctx, byte_range, reason), XmlCharRefReplace => Err(ctx.vm.new_type_error( - "don't know how to handle UnicodeDecodeError in error callback".to_owned(), + "don't know how to handle UnicodeDecodeError in error callback", )), BackslashReplace => { errors::BackslashReplace.handle_decode_error(ctx, byte_range, reason) @@ -858,7 +858,7 @@ impl<'a> EncodeErrorHandler> for ErrorsHandler<'_> { let res = handler.call((encode_exc.clone(),), vm)?; let tuple_err = || { vm.new_type_error( - "encoding error handler must return (str/bytes, int) tuple".to_owned(), + "encoding error handler must return (str/bytes, int) tuple", ) }; let (replace, restart) = match res.payload::().map(|tup| tup.as_slice()) { @@ -914,12 +914,12 @@ impl<'a> DecodeErrorHandler> for ErrorsHandler<'_> { if !new_data.is(&data_bytes) { let new_data: PyBytesRef = new_data .downcast() - .map_err(|_| vm.new_type_error("object attribute must be bytes".to_owned()))?; + .map_err(|_| vm.new_type_error("object attribute must be bytes"))?; ctx.data = PyDecodeData::Modified(new_data); } let data = &*ctx.data; let tuple_err = - || vm.new_type_error("decoding error handler must return (str, int) tuple".to_owned()); + || vm.new_type_error("decoding error handler must return (str, int) tuple"); match res.payload::().map(|tup| tup.as_slice()) { Some([replace, restart]) => { let replace = replace @@ -1091,7 +1091,7 @@ fn bad_err_type(err: PyObjectRef, vm: &VirtualMachine) -> PyBaseExceptionRef { fn strict_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult { let err = err .downcast() - .unwrap_or_else(|_| vm.new_type_error("codec must pass exception instance".to_owned())); + .unwrap_or_else(|_| vm.new_type_error("codec must pass exception instance")); Err(err) } diff --git a/vm/src/convert/try_from.rs b/vm/src/convert/try_from.rs index 941e1fef2a..44d666c294 100644 --- a/vm/src/convert/try_from.rs +++ b/vm/src/convert/try_from.rs @@ -130,7 +130,7 @@ impl TryFromObject for std::time::Duration { let sec = int? .as_bigint() .to_u64() - .ok_or_else(|| vm.new_value_error("value out of range".to_owned()))?; + .ok_or_else(|| vm.new_value_error("value out of range"))?; Ok(Duration::from_secs(sec)) } else { Err(vm.new_type_error(format!( diff --git a/vm/src/coroutine.rs b/vm/src/coroutine.rs index 56eb520b2c..c4b01805d4 100644 --- a/vm/src/coroutine.rs +++ b/vm/src/coroutine.rs @@ -121,7 +121,7 @@ impl Coro { && e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) { let err = vm - .new_runtime_error("async generator raised StopAsyncIteration".to_owned()); + .new_runtime_error("async generator raised StopAsyncIteration"); err.set_cause(Some(e)); Err(err) } else { diff --git a/vm/src/dict_inner.rs b/vm/src/dict_inner.rs index d24d8ddbbb..98d955ec8c 100644 --- a/vm/src/dict_inner.rs +++ b/vm/src/dict_inner.rs @@ -845,7 +845,7 @@ impl DictKey for str { } fn key_as_isize(&self, vm: &VirtualMachine) -> PyResult { - Err(vm.new_type_error("'str' object cannot be interpreted as an integer".to_owned())) + Err(vm.new_type_error("'str' object cannot be interpreted as an integer")) } } @@ -902,7 +902,7 @@ impl DictKey for Wtf8 { } fn key_as_isize(&self, vm: &VirtualMachine) -> PyResult { - Err(vm.new_type_error("'str' object cannot be interpreted as an integer".to_owned())) + Err(vm.new_type_error("'str' object cannot be interpreted as an integer")) } } @@ -959,7 +959,7 @@ impl DictKey for [u8] { } fn key_as_isize(&self, vm: &VirtualMachine) -> PyResult { - Err(vm.new_type_error("'str' object cannot be interpreted as an integer".to_owned())) + Err(vm.new_type_error("'str' object cannot be interpreted as an integer")) } } diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs index 04a40dbf9a..94c22c878c 100644 --- a/vm/src/exceptions.rs +++ b/vm/src/exceptions.rs @@ -592,7 +592,7 @@ impl PyBaseException { Ok(tb) => Some(tb), Err(_) => { return Err( - vm.new_type_error("__traceback__ must be a traceback or None".to_owned()) + vm.new_type_error("__traceback__ must be a traceback or None") ); } } diff --git a/vm/src/format.rs b/vm/src/format.rs index 77e2f3c5f0..0b01806e0b 100644 --- a/vm/src/format.rs +++ b/vm/src/format.rs @@ -13,11 +13,11 @@ impl IntoPyException for FormatSpecError { fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef { match self { FormatSpecError::DecimalDigitsTooMany => { - vm.new_value_error("Too many decimal digits in format string".to_owned()) + vm.new_value_error("Too many decimal digits in format string") } - FormatSpecError::PrecisionTooBig => vm.new_value_error("Precision too big".to_owned()), + FormatSpecError::PrecisionTooBig => vm.new_value_error("Precision too big"), FormatSpecError::InvalidFormatSpecifier => { - vm.new_value_error("Invalid format specifier".to_owned()) + vm.new_value_error("Invalid format specifier") } FormatSpecError::UnspecifiedFormat(c1, c2) => { let msg = format!("Cannot specify '{c1}' with '{c2}'."); diff --git a/vm/src/frame.rs b/vm/src/frame.rs index 2ffd033546..ce3accc386 100644 --- a/vm/src/frame.rs +++ b/vm/src/frame.rs @@ -1265,7 +1265,7 @@ impl ExecutingFrame<'_> { let type_params: PyTupleRef = self .pop_value() .downcast() - .map_err(|_| vm.new_type_error("Type params must be a tuple.".to_owned()))?; + .map_err(|_| vm.new_type_error("Type params must be a tuple."))?; let value = self.pop_value(); let type_alias = _typing::TypeAliasType::new(name, type_params, value); self.push_value(type_alias.into_ref(&vm.ctx).into()); @@ -1544,7 +1544,7 @@ impl ExecutingFrame<'_> { Self::iterate_mapping_keys(vm, &obj, "keyword argument", |key| { // Check for keyword argument restrictions if key.downcast_ref::().is_none() { - return Err(vm.new_type_error("keywords must be strings".to_owned())); + return Err(vm.new_type_error("keywords must be strings")); } if map_obj.contains_key(&*key, vm) { let key_repr = &key.repr(vm)?; @@ -1610,7 +1610,7 @@ impl ExecutingFrame<'_> { Self::iterate_mapping_keys(vm, &kw_obj, "argument after **", |key| { let key_str = key .payload_if_subclass::(vm) - .ok_or_else(|| vm.new_type_error("keywords must be strings".to_owned()))?; + .ok_or_else(|| vm.new_type_error("keywords must be strings"))?; let value = kw_obj.get_item(&*key, vm)?; kwargs.insert(key_str.as_str().to_owned(), value); Ok(()) @@ -1690,7 +1690,7 @@ impl ExecutingFrame<'_> { // if the cause arg is an exception, we overwrite it let ctor = ExceptionCtor::try_from_object(vm, val).map_err(|_| { vm.new_type_error( - "exception causes must derive from BaseException".to_owned(), + "exception causes must derive from BaseException", ) })?; Some(ctor.instantiate(vm)?) @@ -1705,7 +1705,7 @@ impl ExecutingFrame<'_> { } bytecode::RaiseKind::Reraise => vm .topmost_exception() - .ok_or_else(|| vm.new_runtime_error("No active exception to reraise".to_owned()))?, + .ok_or_else(|| vm.new_runtime_error("No active exception to reraise"))?, }; #[cfg(debug_assertions)] debug!("Exception raised: {exception:?} with cause: {cause:?}"); @@ -1880,7 +1880,7 @@ impl ExecutingFrame<'_> { let type_params: PyTupleRef = if flags.contains(bytecode::MakeFunctionFlags::TYPE_PARAMS) { self.pop_value() .downcast() - .map_err(|_| vm.new_type_error("Type params must be a tuple.".to_owned()))? + .map_err(|_| vm.new_type_error("Type params must be a tuple."))? } else { vm.ctx.empty_tuple.clone() }; @@ -2026,7 +2026,7 @@ impl ExecutingFrame<'_> { let displayhook = vm .sys_module .get_attr("displayhook", vm) - .map_err(|_| vm.new_runtime_error("lost sys.displayhook".to_owned()))?; + .map_err(|_| vm.new_runtime_error("lost sys.displayhook"))?; displayhook.call((expr,), vm)?; Ok(None) @@ -2112,15 +2112,13 @@ impl ExecutingFrame<'_> { .is_subclass(vm.ctx.exceptions.base_exception_type.into(), vm)? { return Err(vm.new_type_error( - "catching classes that do not inherit from BaseException is not allowed" - .to_owned(), + "catching classes that do not inherit from BaseException is not allowed", )); } } } else if !b.is_subclass(vm.ctx.exceptions.base_exception_type.into(), vm)? { return Err(vm.new_type_error( - "catching classes that do not inherit from BaseException is not allowed" - .to_owned(), + "catching classes that do not inherit from BaseException is not allowed", )); } diff --git a/vm/src/function/buffer.rs b/vm/src/function/buffer.rs index b8ef771929..ede139122a 100644 --- a/vm/src/function/buffer.rs +++ b/vm/src/function/buffer.rs @@ -20,7 +20,7 @@ impl PyObject { ) -> PyResult { let buffer = PyBuffer::try_from_borrowed_object(vm, self)?; buffer.as_contiguous().map(|x| f(&x)).ok_or_else(|| { - vm.new_type_error("non-contiguous buffer is not a bytes-like object".to_owned()) + vm.new_type_error("non-contiguous buffer is not a bytes-like object") }) } @@ -34,7 +34,7 @@ impl PyObject { .as_contiguous_mut() .map(|mut x| f(&mut x)) .ok_or_else(|| { - vm.new_type_error("buffer is not a read-write bytes-like object".to_owned()) + vm.new_type_error("buffer is not a read-write bytes-like object") }) } } @@ -82,7 +82,7 @@ impl<'a> TryFromBorrowedObject<'a> for ArgBytesLike { if buffer.desc.is_contiguous() { Ok(Self(buffer)) } else { - Err(vm.new_type_error("non-contiguous buffer is not a bytes-like object".to_owned())) + Err(vm.new_type_error("non-contiguous buffer is not a bytes-like object")) } } } @@ -122,9 +122,9 @@ impl<'a> TryFromBorrowedObject<'a> for ArgMemoryBuffer { fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult { let buffer = PyBuffer::try_from_borrowed_object(vm, obj)?; if !buffer.desc.is_contiguous() { - Err(vm.new_type_error("non-contiguous buffer is not a bytes-like object".to_owned())) + Err(vm.new_type_error("non-contiguous buffer is not a bytes-like object")) } else if buffer.desc.readonly { - Err(vm.new_type_error("buffer is not a read-write bytes-like object".to_owned())) + Err(vm.new_type_error("buffer is not a read-write bytes-like object")) } else { Ok(Self(buffer)) } @@ -177,7 +177,7 @@ impl TryFromObject for ArgAsciiBuffer { Ok(ArgAsciiBuffer::String(string)) } else { Err(vm.new_value_error( - "string argument should contain only ASCII characters".to_owned(), + "string argument should contain only ASCII characters", )) } } diff --git a/vm/src/function/fspath.rs b/vm/src/function/fspath.rs index 28145e490a..c23111e76d 100644 --- a/vm/src/function/fspath.rs +++ b/vm/src/function/fspath.rs @@ -101,7 +101,7 @@ impl FsPath { pub fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ffi::OsStr> { rustpython_common::os::bytes_as_os_str(b) - .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8".to_owned())) + .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8")) } } diff --git a/vm/src/function/getset.rs b/vm/src/function/getset.rs index 66e668ace6..e7a6ae5bde 100644 --- a/vm/src/function/getset.rs +++ b/vm/src/function/getset.rs @@ -36,7 +36,7 @@ where { #[inline] fn from_setter_value(vm: &VirtualMachine, obj: PySetterValue) -> PyResult { - let obj = obj.ok_or_else(|| vm.new_type_error("can't delete attribute".to_owned()))?; + let obj = obj.ok_or_else(|| vm.new_type_error("can't delete attribute"))?; T::try_from_object(vm, obj) } } diff --git a/vm/src/function/mod.rs b/vm/src/function/mod.rs index 8e517f6ed5..3f84be6a1f 100644 --- a/vm/src/function/mod.rs +++ b/vm/src/function/mod.rs @@ -40,7 +40,7 @@ impl<'a> TryFromBorrowedObject<'a> for ArgByteOrder { "big" => Ok(Self::Big), "little" => Ok(Self::Little), _ => { - Err(vm.new_value_error("byteorder must be either 'little' or 'big'".to_owned())) + Err(vm.new_value_error("byteorder must be either 'little' or 'big'")) } }, vm, diff --git a/vm/src/protocol/buffer.rs b/vm/src/protocol/buffer.rs index 0166920b22..60f7c9ab44 100644 --- a/vm/src/protocol/buffer.rs +++ b/vm/src/protocol/buffer.rs @@ -391,7 +391,7 @@ pub trait BufferResizeGuard { fn try_resizable_opt(&self) -> Option>; fn try_resizable(&self, vm: &VirtualMachine) -> PyResult> { self.try_resizable_opt().ok_or_else(|| { - vm.new_buffer_error("Existing exports of data: object cannot be re-sized".to_owned()) + vm.new_buffer_error("Existing exports of data: object cannot be re-sized") }) } } diff --git a/vm/src/protocol/object.rs b/vm/src/protocol/object.rs index 4f0d816b8a..e938a876b1 100644 --- a/vm/src/protocol/object.rs +++ b/vm/src/protocol/object.rs @@ -96,7 +96,7 @@ impl PyObject { if self.payload_is::() { vm.call_special_method(self, identifier!(vm, __aiter__), ()) } else { - Err(vm.new_type_error("wrong argument type".to_owned())) + Err(vm.new_type_error("wrong argument type")) } } diff --git a/vm/src/protocol/sequence.rs b/vm/src/protocol/sequence.rs index 0681c3e664..fbd8d63409 100644 --- a/vm/src/protocol/sequence.rs +++ b/vm/src/protocol/sequence.rs @@ -303,7 +303,7 @@ impl PySequence<'_> { let elem = elem?; if vm.bool_eq(&elem, target)? { if n == isize::MAX as usize { - return Err(vm.new_overflow_error("index exceeds C integer size".to_string())); + return Err(vm.new_overflow_error("index exceeds C integer size")); } n += 1; } @@ -320,7 +320,7 @@ impl PySequence<'_> { for elem in iter { if index == isize::MAX { - return Err(vm.new_overflow_error("index exceeds C integer size".to_string())); + return Err(vm.new_overflow_error("index exceeds C integer size")); } index += 1; @@ -330,7 +330,7 @@ impl PySequence<'_> { } } - Err(vm.new_value_error("sequence.index(x): x not in sequence".to_string())) + Err(vm.new_value_error("sequence.index(x): x not in sequence")) } pub fn extract(&self, mut f: F, vm: &VirtualMachine) -> PyResult> diff --git a/vm/src/sliceable.rs b/vm/src/sliceable.rs index 1140abb398..e6cf78f492 100644 --- a/vm/src/sliceable.rs +++ b/vm/src/sliceable.rs @@ -34,7 +34,7 @@ where let pos = self .as_ref() .wrap_index(index) - .ok_or_else(|| vm.new_index_error("assignment index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("assignment index out of range"))?; self.do_set(pos, value); Ok(()) } @@ -48,7 +48,7 @@ where let (range, step, slice_len) = slice.adjust_indices(self.as_ref().len()); if slice_len != items.len() { Err(vm - .new_buffer_error("Existing exports of data: object cannot be re-sized".to_owned())) + .new_buffer_error("Existing exports of data: object cannot be re-sized")) } else if step == 1 { self.do_set_range(range, items); Ok(()) @@ -90,7 +90,7 @@ where let pos = self .as_ref() .wrap_index(index) - .ok_or_else(|| vm.new_index_error("assignment index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("assignment index out of range"))?; self.do_delete(pos); Ok(()) } @@ -206,7 +206,7 @@ pub trait SliceableSequenceOp { fn getitem_by_index(&self, vm: &VirtualMachine, index: isize) -> PyResult { let pos = self .wrap_index(index) - .ok_or_else(|| vm.new_index_error("index out of range".to_owned()))?; + .ok_or_else(|| vm.new_index_error("index out of range"))?; Ok(self.do_get(pos)) } } @@ -268,7 +268,7 @@ impl SequenceIndex { // TODO: number protocol i.try_to_primitive(vm) .map_err(|_| { - vm.new_index_error("cannot fit 'int' into an index-sized integer".to_owned()) + vm.new_index_error("cannot fit 'int' into an index-sized integer") }) .map(Self::Int) } else if let Some(slice) = obj.payload::() { @@ -277,7 +277,7 @@ impl SequenceIndex { // TODO: __index__ for indices is no more supported? i?.try_to_primitive(vm) .map_err(|_| { - vm.new_index_error("cannot fit 'int' into an index-sized integer".to_owned()) + vm.new_index_error("cannot fit 'int' into an index-sized integer") }) .map(Self::Int) } else { @@ -356,7 +356,7 @@ impl SaturatedSlice { pub fn with_slice(slice: &PySlice, vm: &VirtualMachine) -> PyResult { let step = to_isize_index(vm, slice.step_ref(vm))?.unwrap_or(1); if step == 0 { - return Err(vm.new_value_error("slice step cannot be zero".to_owned())); + return Err(vm.new_value_error("slice step cannot be zero")); } let start = to_isize_index(vm, slice.start_ref(vm))? .unwrap_or_else(|| if step.is_negative() { isize::MAX } else { 0 }); @@ -462,7 +462,7 @@ fn to_isize_index(vm: &VirtualMachine, obj: &PyObject) -> PyResult } let result = obj.try_index_opt(vm).unwrap_or_else(|| { Err(vm.new_type_error( - "slice indices must be integers or None or have an __index__ method".to_owned(), + "slice indices must be integers or None or have an __index__ method", )) })?; let value = result.as_bigint(); diff --git a/vm/src/stdlib/ast/other.rs b/vm/src/stdlib/ast/other.rs index f7d6981332..df70bc53f3 100644 --- a/vm/src/stdlib/ast/other.rs +++ b/vm/src/stdlib/ast/other.rs @@ -21,7 +21,7 @@ impl Node for ruff::ConversionFlag { bytecode::ConversionFlag::Ascii => Self::Ascii, bytecode::ConversionFlag::Repr => Self::Repr, }) - .ok_or_else(|| vm.new_value_error("invalid conversion flag".to_owned())) + .ok_or_else(|| vm.new_value_error("invalid conversion flag")) } } @@ -38,7 +38,7 @@ impl Node for ruff::name::Name { ) -> PyResult { match object.downcast::() { Ok(name) => Ok(Self::new(name)), - Err(_) => Err(vm.new_value_error("expected str for name".to_owned())), + Err(_) => Err(vm.new_value_error("expected str for name")), } } } diff --git a/vm/src/stdlib/builtins.rs b/vm/src/stdlib/builtins.rs index 60f6dd8dd9..7e99604fc2 100644 --- a/vm/src/stdlib/builtins.rs +++ b/vm/src/stdlib/builtins.rs @@ -92,7 +92,7 @@ mod builtins { .try_to_primitive::(vm)? .to_u32() .and_then(CodePoint::from_u32) - .ok_or_else(|| vm.new_value_error("chr() arg not in range(0x110000)".to_owned()))?; + .ok_or_else(|| vm.new_value_error("chr() arg not in range(0x110000)"))?; Ok(value) } @@ -118,7 +118,7 @@ mod builtins { #[cfg(not(feature = "ast"))] { _ = args; // to disable unused warning - return Err(vm.new_type_error("AST Not Supported".to_owned())); + return Err(vm.new_type_error("AST Not Supported")); } #[cfg(feature = "ast")] { @@ -135,7 +135,7 @@ mod builtins { vm.state.settings.optimize } else { optimize.try_into().map_err(|_| { - vm.new_value_error("compile() optimize value invalid".to_owned()) + vm.new_value_error("compile() optimize value invalid") })? }; @@ -183,7 +183,7 @@ mod builtins { let flags = args.flags.map_or(Ok(0), |v| v.try_to_primitive(vm))?; if !(flags & !ast::PY_COMPILE_FLAGS_MASK).is_zero() { - return Err(vm.new_value_error("compile() unrecognized flags".to_owned())); + return Err(vm.new_value_error("compile() unrecognized flags")); } let allow_incomplete = !(flags & ast::PY_CF_ALLOW_INCOMPLETE_INPUT).is_zero(); @@ -414,7 +414,7 @@ mod builtins { .get_attr(vm.ctx.intern_str("breakpointhook"), vm) { Ok(hook) => hook.as_ref().call(args, vm), - Err(_) => Err(vm.new_runtime_error("lost sys.breakpointhook".to_owned())), + Err(_) => Err(vm.new_runtime_error("lost sys.breakpointhook")), } } @@ -832,7 +832,7 @@ mod builtins { fn vars(obj: OptionalArg, vm: &VirtualMachine) -> PyResult { if let OptionalArg::Present(obj) = obj { obj.get_attr(identifier!(vm, __dict__), vm).map_err(|_| { - vm.new_type_error("vars() argument must have __dict__ attribute".to_owned()) + vm.new_type_error("vars() argument must have __dict__ attribute") }) } else { Ok(vm.current_locals()?.into()) @@ -873,7 +873,7 @@ mod builtins { }; let entries: PyTupleRef = entries .downcast() - .map_err(|_| vm.new_type_error("__mro_entries__ must return a tuple".to_owned()))?; + .map_err(|_| vm.new_type_error("__mro_entries__ must return a tuple"))?; let new_bases = new_bases.get_or_insert_with(|| bases[..i].to_vec()); new_bases.extend_from_slice(&entries); } @@ -903,8 +903,7 @@ mod builtins { } else if !metaclass.fast_issubclass(base_class) { return Err(vm.new_type_error( "metaclass conflict: the metaclass of a derived class must be a (non-strict) \ - subclass of the metaclasses of all its bases" - .to_owned(), + subclass of the metaclasses of all its bases", )); } } diff --git a/vm/src/stdlib/collections.rs b/vm/src/stdlib/collections.rs index e8f934f36e..d5880869aa 100644 --- a/vm/src/stdlib/collections.rs +++ b/vm/src/stdlib/collections.rs @@ -110,7 +110,7 @@ mod _collections { let count = self.mut_count(vm, &obj)?; if start_state != self.state.load() { - return Err(vm.new_runtime_error("deque mutated during iteration".to_owned())); + return Err(vm.new_runtime_error("deque mutated during iteration")); } Ok(count) } @@ -173,7 +173,7 @@ mod _collections { let (start, stop) = range.saturate(self.len(), vm)?; let index = self.mut_index_range(vm, &needle, start..stop)?; if start_state != self.state.load() { - Err(vm.new_runtime_error("deque mutated during iteration".to_owned())) + Err(vm.new_runtime_error("deque mutated during iteration")) } else if let Some(index) = index.into() { Ok(index) } else { @@ -192,7 +192,7 @@ mod _collections { let mut deque = self.borrow_deque_mut(); if self.maxlen == Some(deque.len()) { - return Err(vm.new_index_error("deque already at its maximum size".to_owned())); + return Err(vm.new_index_error("deque already at its maximum size")); } let idx = if idx < 0 { @@ -217,7 +217,7 @@ mod _collections { self.state.fetch_add(1); self.borrow_deque_mut() .pop_back() - .ok_or_else(|| vm.new_index_error("pop from an empty deque".to_owned())) + .ok_or_else(|| vm.new_index_error("pop from an empty deque")) } #[pymethod] @@ -225,7 +225,7 @@ mod _collections { self.state.fetch_add(1); self.borrow_deque_mut() .pop_front() - .ok_or_else(|| vm.new_index_error("pop from an empty deque".to_owned())) + .ok_or_else(|| vm.new_index_error("pop from an empty deque")) } #[pymethod] @@ -234,13 +234,13 @@ mod _collections { let index = self.mut_index(vm, &obj)?; if start_state != self.state.load() { - Err(vm.new_index_error("deque mutated during remove().".to_owned())) + Err(vm.new_index_error("deque mutated during remove().")) } else if let Some(index) = index.into() { let mut deque = self.borrow_deque_mut(); self.state.fetch_add(1); Ok(deque.remove(index).unwrap()) } else { - Err(vm.new_value_error("deque.remove(x): x not in deque".to_owned())) + Err(vm.new_value_error("deque.remove(x): x not in deque")) } } @@ -282,7 +282,7 @@ mod _collections { let deque = self.borrow_deque(); idx.wrapped_at(deque.len()) .and_then(|i| deque.get(i).cloned()) - .ok_or_else(|| vm.new_index_error("deque index out of range".to_owned())) + .ok_or_else(|| vm.new_index_error("deque index out of range")) } #[pymethod(magic)] @@ -291,7 +291,7 @@ mod _collections { idx.wrapped_at(deque.len()) .and_then(|i| deque.get_mut(i)) .map(|x| *x = value) - .ok_or_else(|| vm.new_index_error("deque index out of range".to_owned())) + .ok_or_else(|| vm.new_index_error("deque index out of range")) } #[pymethod(magic)] @@ -299,7 +299,7 @@ mod _collections { let mut deque = self.borrow_deque_mut(); idx.wrapped_at(deque.len()) .and_then(|i| deque.remove(i).map(drop)) - .ok_or_else(|| vm.new_index_error("deque index out of range".to_owned())) + .ok_or_else(|| vm.new_index_error("deque index out of range")) } #[pymethod(magic)] @@ -311,7 +311,7 @@ mod _collections { let start_state = self.state.load(); let ret = self.mut_contains(vm, needle)?; if start_state != self.state.load() { - Err(vm.new_runtime_error("deque mutated during iteration".to_owned())) + Err(vm.new_runtime_error("deque mutated during iteration")) } else { Ok(ret) } @@ -443,11 +443,11 @@ mod _collections { if !vm.is_none(&obj) { let maxlen: isize = obj .payload::() - .ok_or_else(|| vm.new_type_error("an integer is required.".to_owned()))? + .ok_or_else(|| vm.new_type_error("an integer is required."))? .try_to_primitive(vm)?; if maxlen.is_negative() { - return Err(vm.new_value_error("maxlen must be non-negative.".to_owned())); + return Err(vm.new_value_error("maxlen must be non-negative.")); } Some(maxlen as usize) } else { @@ -651,7 +651,7 @@ mod _collections { fn next(zelf: &Py, vm: &VirtualMachine) -> PyResult { zelf.internal.lock().next(|deque, pos| { if zelf.state != deque.state.load() { - return Err(vm.new_runtime_error("Deque mutated during iteration".to_owned())); + return Err(vm.new_runtime_error("Deque mutated during iteration")); } let deque = deque.borrow_deque(); Ok(PyIterReturn::from_result( @@ -717,7 +717,7 @@ mod _collections { fn next(zelf: &Py, vm: &VirtualMachine) -> PyResult { zelf.internal.lock().next(|deque, pos| { if deque.state.load() != zelf.state { - return Err(vm.new_runtime_error("Deque mutated during iteration".to_owned())); + return Err(vm.new_runtime_error("Deque mutated during iteration")); } let deque = deque.borrow_deque(); let r = deque diff --git a/vm/src/stdlib/ctypes.rs b/vm/src/stdlib/ctypes.rs index 235e089e3a..fffee79761 100644 --- a/vm/src/stdlib/ctypes.rs +++ b/vm/src/stdlib/ctypes.rs @@ -160,10 +160,10 @@ pub(crate) mod _ctypes { }) } } else { - Err(vm.new_type_error("class must define a '_type_' string attribute".to_string())) + Err(vm.new_type_error("class must define a '_type_' string attribute")) } } else { - Err(vm.new_attribute_error("class must define a '_type_' attribute".to_string())) + Err(vm.new_attribute_error("class must define a '_type_' attribute")) } } @@ -179,7 +179,7 @@ pub(crate) mod _ctypes { let size_of_return = size_of_method.call(vec![], vm)?; Ok(usize::try_from_object(vm, size_of_return)?) } - _ => Err(vm.new_type_error("this type has no size".to_string())), + _ => Err(vm.new_type_error("this type has no size")), } } @@ -248,26 +248,26 @@ pub(crate) mod _ctypes { let simple = obj.downcast_ref::().unwrap(); Ok(simple.value.as_ptr() as usize) } else { - Err(vm.new_type_error("expected a ctypes instance".to_string())) + Err(vm.new_type_error("expected a ctypes instance")) } } #[pyfunction] fn byref(_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> { // TODO: RUSTPYTHON - Err(vm.new_value_error("not implemented".to_string())) + Err(vm.new_value_error("not implemented")) } #[pyfunction] fn alignment(_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> { // TODO: RUSTPYTHON - Err(vm.new_value_error("not implemented".to_string())) + Err(vm.new_value_error("not implemented")) } #[pyfunction] fn resize(_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> { // TODO: RUSTPYTHON - Err(vm.new_value_error("not implemented".to_string())) + Err(vm.new_value_error("not implemented")) } #[pyfunction] diff --git a/vm/src/stdlib/ctypes/base.rs b/vm/src/stdlib/ctypes/base.rs index 8d7fd6849d..1fdf21df38 100644 --- a/vm/src/stdlib/ctypes/base.rs +++ b/vm/src/stdlib/ctypes/base.rs @@ -63,7 +63,7 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe Ok(value.clone()) } else { Err(vm.new_type_error( - "one character bytes, bytearray or integer expected".to_string(), + "one character bytes, bytearray or integer expected", )) } } @@ -72,7 +72,7 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe if b { Ok(value.clone()) } else { - Err(vm.new_type_error("one character unicode string expected".to_string())) + Err(vm.new_type_error("one character unicode string expected")) } } else { Err(vm.new_type_error(format!( @@ -137,7 +137,7 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe { Ok(value.clone()) } else { - Err(vm.new_type_error("cannot be converted to pointer".to_string())) + Err(vm.new_type_error("cannot be converted to pointer")) } } } @@ -234,7 +234,7 @@ impl PyCSimple { pub fn value(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { let zelf: &Py = instance .downcast_ref() - .ok_or_else(|| vm.new_type_error("cannot get value of instance".to_string()))?; + .ok_or_else(|| vm.new_type_error("cannot get value of instance"))?; Ok(unsafe { (*zelf.value.as_ptr()).clone() }) } @@ -242,7 +242,7 @@ impl PyCSimple { fn set_value(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { let zelf: PyRef = instance .downcast() - .map_err(|_| vm.new_type_error("cannot set value of instance".to_string()))?; + .map_err(|_| vm.new_type_error("cannot set value of instance"))?; let content = set_primitive(zelf._type_.as_str(), &value, vm)?; zelf.value.store(content); Ok(()) diff --git a/vm/src/stdlib/ctypes/function.rs b/vm/src/stdlib/ctypes/function.rs index dc9ff6051b..7d110dfaea 100644 --- a/vm/src/stdlib/ctypes/function.rs +++ b/vm/src/stdlib/ctypes/function.rs @@ -47,7 +47,7 @@ impl Function { let converted = ffi_type_from_str(&arg._type_); return match converted { Some(t) => Ok(t), - None => Err(vm.new_type_error("Invalid type".to_string())), // TODO: add type name + None => Err(vm.new_type_error("Invalid type")), // TODO: add type name }; } if let Some(arg) = arg.payload_if_subclass::(vm) { @@ -57,12 +57,12 @@ impl Function { ty_attributes .get(vm.ctx.intern_str("_type_")) .ok_or_else(|| { - vm.new_type_error("Expected a ctypes simple type".to_string()) + vm.new_type_error("Expected a ctypes simple type") })?; let ty_str = ty_pystr .downcast_ref::() .ok_or_else(|| { - vm.new_type_error("Expected a ctypes simple type".to_string()) + vm.new_type_error("Expected a ctypes simple type") })? .to_string(); let converted = ffi_type_from_str(&ty_str); @@ -71,15 +71,15 @@ impl Function { // TODO: Use Ok(Type::void()) } - None => Err(vm.new_type_error("Invalid type".to_string())), // TODO: add type name + None => Err(vm.new_type_error("Invalid type")), // TODO: add type name } } else { - Err(vm.new_type_error("Expected a ctypes simple type".to_string())) + Err(vm.new_type_error("Expected a ctypes simple type")) } }) .collect::>>()?; let c_function_name = CString::new(function) - .map_err(|_| vm.new_value_error("Function name contains null bytes".to_string()))?; + .map_err(|_| vm.new_value_error("Function name contains null bytes"))?; let pointer: Symbol<'_, FP> = unsafe { library .get(c_function_name.as_bytes()) @@ -90,7 +90,7 @@ impl Function { let return_type = match ret_type { // TODO: Fix this Some(_t) => { - return Err(vm.new_not_implemented_error("Return type not implemented".to_string())); + return Err(vm.new_not_implemented_error("Return type not implemented")); } None => Type::c_int(), }; @@ -118,7 +118,7 @@ impl Function { if let Some(d) = arg.payload_if_subclass::(vm) { return Ok(d.to_arg(vm).unwrap()); } - Err(vm.new_type_error("Expected a ctypes simple type".to_string())) + Err(vm.new_type_error("Expected a ctypes simple type")) }) .collect::>>()?; // TODO: FIX return @@ -152,14 +152,14 @@ impl Constructor for PyCFuncPtr { fn py_new(_cls: PyTypeRef, (tuple, _args): Self::Args, vm: &VirtualMachine) -> PyResult { let name = tuple .first() - .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements".to_string()))? + .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))? .downcast_ref::() - .ok_or(vm.new_type_error("Expected a string".to_string()))? + .ok_or(vm.new_type_error("Expected a string"))? .to_string(); let handler = tuple .into_iter() .nth(1) - .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements".to_string()))? + .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))? .clone(); Ok(Self { _flags_: AtomicCell::new(0), @@ -182,16 +182,16 @@ impl Callable for PyCFuncPtr { .get_lib( handle .to_usize() - .ok_or(vm.new_value_error("Invalid handle".to_string()))?, + .ok_or(vm.new_value_error("Invalid handle"))?, ) - .ok_or_else(|| vm.new_value_error("Library not found".to_string()))?; + .ok_or_else(|| vm.new_value_error("Library not found"))?; let inner_lib = library.lib.lock(); let name = zelf.name.read(); let res_type = zelf._restype_.read(); let func = Function::load( inner_lib .as_ref() - .ok_or_else(|| vm.new_value_error("Library not found".to_string()))?, + .ok_or_else(|| vm.new_value_error("Library not found"))?, &name, &args.args, &res_type, diff --git a/vm/src/stdlib/ctypes/structure.rs b/vm/src/stdlib/ctypes/structure.rs index 0d1b405703..199d8af9bd 100644 --- a/vm/src/stdlib/ctypes/structure.rs +++ b/vm/src/stdlib/ctypes/structure.rs @@ -23,23 +23,23 @@ impl Constructor for PyCStructure { let fields_attr = cls .get_class_attr(vm.ctx.interned_str("_fields_").unwrap()) .ok_or_else(|| { - vm.new_attribute_error("Structure must have a _fields_ attribute".to_string()) + vm.new_attribute_error("Structure must have a _fields_ attribute") })?; // downcast into list let fields = fields_attr.downcast_ref::().ok_or_else(|| { - vm.new_type_error("Structure _fields_ attribute must be a list".to_string()) + vm.new_type_error("Structure _fields_ attribute must be a list") })?; let fields = fields.borrow_vec(); let mut field_data = HashMap::new(); for field in fields.iter() { let field = field .downcast_ref::() - .ok_or_else(|| vm.new_type_error("Field must be a tuple".to_string()))?; + .ok_or_else(|| vm.new_type_error("Field must be a tuple"))?; let name = field .first() .unwrap() .downcast_ref::() - .ok_or_else(|| vm.new_type_error("Field name must be a string".to_string()))?; + .ok_or_else(|| vm.new_type_error("Field name must be a string"))?; let typ = field.get(1).unwrap().clone(); field_data.insert(name.as_str().to_string(), typ); } diff --git a/vm/src/stdlib/functools.rs b/vm/src/stdlib/functools.rs index c1634265c4..72fee9d2e2 100644 --- a/vm/src/stdlib/functools.rs +++ b/vm/src/stdlib/functools.rs @@ -103,7 +103,7 @@ mod _functools { #[pymethod(magic)] fn setstate(zelf: &Py, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { let state_tuple = state.downcast::().map_err(|_| { - vm.new_type_error("argument to __setstate__ must be a tuple".to_owned()) + vm.new_type_error("argument to __setstate__ must be a tuple") })?; if state_tuple.len() != 4 { @@ -119,12 +119,12 @@ mod _functools { let dict = &state_tuple[3]; if !func.is_callable() { - return Err(vm.new_type_error("invalid partial state".to_owned())); + return Err(vm.new_type_error("invalid partial state")); } // Validate that args is a tuple (or subclass) if !args.fast_isinstance(vm.ctx.types.tuple_type) { - return Err(vm.new_type_error("invalid partial state".to_owned())); + return Err(vm.new_type_error("invalid partial state")); } // Always convert to base tuple, even if it's a subclass let args_tuple = match args.clone().downcast::() { @@ -143,7 +143,7 @@ mod _functools { let dict = kwds .clone() .downcast::() - .map_err(|_| vm.new_type_error("invalid partial state".to_owned()))?; + .map_err(|_| vm.new_type_error("invalid partial state"))?; if dict.class().is(vm.ctx.types.dict_type) { // It's already a base dict dict @@ -180,7 +180,7 @@ mod _functools { let dict_obj = dict .clone() .downcast::() - .map_err(|_| vm.new_type_error("invalid partial state".to_owned()))?; + .map_err(|_| vm.new_type_error("invalid partial state"))?; // Clear existing dict and update with new values instance_dict.clear(); @@ -197,11 +197,11 @@ mod _functools { fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult { let (func, args_slice) = args.args.split_first().ok_or_else(|| { - vm.new_type_error("partial expected at least 1 argument, got 0".to_owned()) + vm.new_type_error("partial expected at least 1 argument, got 0") })?; if !func.is_callable() { - return Err(vm.new_type_error("the first argument must be callable".to_owned())); + return Err(vm.new_type_error("the first argument must be callable")); } // Handle nested partial objects @@ -247,7 +247,7 @@ mod _functools { for (key, value) in &*inner.keywords { let key_str = key .downcast::() - .map_err(|_| vm.new_type_error("keywords must be strings".to_owned()))?; + .map_err(|_| vm.new_type_error("keywords must be strings"))?; final_kwargs.insert(key_str.as_str().to_owned(), value); } diff --git a/vm/src/stdlib/imp.rs b/vm/src/stdlib/imp.rs index 5c3f4bf61d..378a100364 100644 --- a/vm/src/stdlib/imp.rs +++ b/vm/src/stdlib/imp.rs @@ -17,7 +17,7 @@ mod lock { #[pyfunction] fn release_lock(vm: &VirtualMachine) -> PyResult<()> { if !IMP_LOCK.is_locked() { - Err(vm.new_runtime_error("Global import lock not held".to_owned())) + Err(vm.new_runtime_error("Global import lock not held")) } else { unsafe { IMP_LOCK.unlock() }; Ok(()) diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs index addfc991ff..959d25b509 100644 --- a/vm/src/stdlib/itertools.rs +++ b/vm/src/stdlib/itertools.rs @@ -253,7 +253,7 @@ mod decl { let start = start.into_option().unwrap_or_else(|| vm.new_pyobj(0)); let step = step.into_option().unwrap_or_else(|| vm.new_pyobj(1)); if !PyNumber::check(&start) || !PyNumber::check(&step) { - return Err(vm.new_type_error("a number is required".to_owned())); + return Err(vm.new_type_error("a number is required")); } Self { @@ -397,7 +397,7 @@ mod decl { let times = self .times .as_ref() - .ok_or_else(|| vm.new_type_error("length of unsized object.".to_owned()))?; + .ok_or_else(|| vm.new_type_error("length of unsized object."))?; Ok(*times.read()) } @@ -1489,7 +1489,7 @@ mod decl { let r = r.as_bigint(); if r.is_negative() { - return Err(vm.new_value_error("r must be non-negative".to_owned())); + return Err(vm.new_value_error("r must be non-negative")); } let r = r.to_usize().unwrap(); @@ -1620,7 +1620,7 @@ mod decl { let pool: Vec<_> = iterable.try_to_value(vm)?; let r = r.as_bigint(); if r.is_negative() { - return Err(vm.new_value_error("r must be non-negative".to_owned())); + return Err(vm.new_value_error("r must be non-negative")); } let r = r.to_usize().unwrap(); @@ -1724,11 +1724,11 @@ mod decl { Some(r) => { let val = r .payload::() - .ok_or_else(|| vm.new_type_error("Expected int as r".to_owned()))? + .ok_or_else(|| vm.new_type_error("Expected int as r"))? .as_bigint(); if val.is_negative() { - return Err(vm.new_value_error("r must be non-negative".to_owned())); + return Err(vm.new_value_error("r must be non-negative")); } val.to_usize().unwrap() } @@ -1982,10 +1982,10 @@ mod decl { ) -> PyResult { let n = n.as_bigint(); if n.lt(&BigInt::one()) { - return Err(vm.new_value_error("n must be at least one".to_owned())); + return Err(vm.new_value_error("n must be at least one")); } let n = n.to_usize().ok_or( - vm.new_overflow_error("Python int too large to convert to usize".to_owned()), + vm.new_overflow_error("Python int too large to convert to usize"), )?; let iterable = iterable_ref.get_iter(vm)?; diff --git a/vm/src/stdlib/marshal.rs b/vm/src/stdlib/marshal.rs index 17d8ccd3e1..0faa0d11aa 100644 --- a/vm/src/stdlib/marshal.rs +++ b/vm/src/stdlib/marshal.rs @@ -103,7 +103,7 @@ mod decl { .unwrap_or_else(Err) .map_err(|DumpError| { vm.new_not_implemented_error( - "TODO: not implemented yet or marshal unsupported type".to_owned(), + "TODO: not implemented yet or marshal unsupported type", ) })?; Ok(PyBytes::from(buf)) @@ -204,7 +204,7 @@ mod decl { #[pyfunction] fn loads(pybuffer: PyBuffer, vm: &VirtualMachine) -> PyResult { let buf = pybuffer.as_contiguous().ok_or_else(|| { - vm.new_buffer_error("Buffer provided to marshal.loads() is not contiguous".to_owned()) + vm.new_buffer_error("Buffer provided to marshal.loads() is not contiguous") })?; marshal::deserialize_value(&mut &buf[..], PyMarshalBag(vm)).map_err(|e| match e { marshal::MarshalError::Eof => vm.new_exception_msg( @@ -212,16 +212,16 @@ mod decl { "marshal data too short".to_owned(), ), marshal::MarshalError::InvalidBytecode => { - vm.new_value_error("Couldn't deserialize python bytecode".to_owned()) + vm.new_value_error("Couldn't deserialize python bytecode") } marshal::MarshalError::InvalidUtf8 => { - vm.new_value_error("invalid utf8 in marshalled string".to_owned()) + vm.new_value_error("invalid utf8 in marshalled string") } marshal::MarshalError::InvalidLocation => { - vm.new_value_error("invalid location in marshalled object".to_owned()) + vm.new_value_error("invalid location in marshalled object") } marshal::MarshalError::BadType => { - vm.new_value_error("bad marshal data (unknown type code)".to_owned()) + vm.new_value_error("bad marshal data (unknown type code)") } }) } diff --git a/vm/src/stdlib/msvcrt.rs b/vm/src/stdlib/msvcrt.rs index 463f4566ae..beebc3dc0f 100644 --- a/vm/src/stdlib/msvcrt.rs +++ b/vm/src/stdlib/msvcrt.rs @@ -58,7 +58,7 @@ mod msvcrt { #[pyfunction] fn putch(b: PyRef, vm: &VirtualMachine) -> PyResult<()> { let &c = b.as_bytes().iter().exactly_one().map_err(|_| { - vm.new_type_error("putch() argument must be a byte string of length 1".to_owned()) + vm.new_type_error("putch() argument must be a byte string of length 1") })?; unsafe { suppress_iph!(_putch(c.into())) }; Ok(()) @@ -66,7 +66,7 @@ mod msvcrt { #[pyfunction] fn putwch(s: PyStrRef, vm: &VirtualMachine) -> PyResult<()> { let c = s.as_str().chars().exactly_one().map_err(|_| { - vm.new_type_error("putch() argument must be a string of length 1".to_owned()) + vm.new_type_error("putch() argument must be a string of length 1") })?; unsafe { suppress_iph!(_putwch(c as u16)) }; Ok(()) diff --git a/vm/src/stdlib/nt.rs b/vm/src/stdlib/nt.rs index cdab9e2f71..db11248ee8 100644 --- a/vm/src/stdlib/nt.rs +++ b/vm/src/stdlib/nt.rs @@ -180,7 +180,7 @@ pub(crate) mod module { OptionalArg::Present(0) => Console::STD_INPUT_HANDLE, OptionalArg::Present(1) | OptionalArg::Missing => Console::STD_OUTPUT_HANDLE, OptionalArg::Present(2) => Console::STD_ERROR_HANDLE, - _ => return Err(vm.new_value_error("bad file descriptor".to_owned())), + _ => return Err(vm.new_value_error("bad file descriptor")), }; let h = unsafe { Console::GetStdHandle(stdhandle) }; if h.is_null() { @@ -230,11 +230,11 @@ pub(crate) mod module { let first = argv .first() - .ok_or_else(|| vm.new_value_error("execv() arg 2 must not be empty".to_owned()))?; + .ok_or_else(|| vm.new_value_error("execv() arg 2 must not be empty"))?; if first.is_empty() { return Err( - vm.new_value_error("execv() arg 2 first element cannot be empty".to_owned()) + vm.new_value_error("execv() arg 2 first element cannot be empty") ); } diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs index 2404b0c337..f315cd7091 100644 --- a/vm/src/stdlib/operator.rs +++ b/vm/src/stdlib/operator.rs @@ -206,7 +206,7 @@ mod _operator { return Ok(index); } } - Err(vm.new_value_error("sequence.index(x): x not in sequence".to_owned())) + Err(vm.new_value_error("sequence.index(x): x not in sequence")) } #[pyfunction] @@ -325,7 +325,7 @@ mod _operator { (Either::A(a), Either::A(b)) => { if !a.as_str().is_ascii() || !b.as_str().is_ascii() { return Err(vm.new_type_error( - "comparing strings with non-ASCII characters is not supported".to_owned(), + "comparing strings with non-ASCII characters is not supported", )); } constant_time_eq(a.as_bytes(), b.as_bytes()) @@ -333,7 +333,7 @@ mod _operator { (Either::B(a), Either::B(b)) => a.with_ref(|a| b.with_ref(|b| constant_time_eq(a, b))), _ => { return Err(vm.new_type_error( - "unsupported operand types(s) or combination of types".to_owned(), + "unsupported operand types(s) or combination of types", )); } }; @@ -390,17 +390,17 @@ mod _operator { let n_attr = args.args.len(); // Check we get no keyword and at least one positional. if !args.kwargs.is_empty() { - return Err(vm.new_type_error("attrgetter() takes no keyword arguments".to_owned())); + return Err(vm.new_type_error("attrgetter() takes no keyword arguments")); } if n_attr == 0 { - return Err(vm.new_type_error("attrgetter expected 1 argument, got 0.".to_owned())); + return Err(vm.new_type_error("attrgetter expected 1 argument, got 0.")); } let mut attrs = Vec::with_capacity(n_attr); for o in args.args { if let Ok(r) = o.try_into_value(vm) { attrs.push(r); } else { - return Err(vm.new_type_error("attribute name must be a string".to_owned())); + return Err(vm.new_type_error("attribute name must be a string")); } } PyAttrGetter { attrs } @@ -467,10 +467,10 @@ mod _operator { fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult { // Check we get no keyword and at least one positional. if !args.kwargs.is_empty() { - return Err(vm.new_type_error("itemgetter() takes no keyword arguments".to_owned())); + return Err(vm.new_type_error("itemgetter() takes no keyword arguments")); } if args.args.is_empty() { - return Err(vm.new_type_error("itemgetter expected 1 argument, got 0.".to_owned())); + return Err(vm.new_type_error("itemgetter expected 1 argument, got 0.")); } PyItemGetter { items: args.args } .into_ref_with_type(vm, cls) @@ -556,7 +556,7 @@ mod _operator { .into_ref_with_type(vm, cls) .map(Into::into) } else { - Err(vm.new_type_error("method name must be a string".to_owned())) + Err(vm.new_type_error("method name must be a string")) } } } diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs index 08a5051fe7..cd15c5a141 100644 --- a/vm/src/stdlib/os.rs +++ b/vm/src/stdlib/os.rs @@ -108,7 +108,7 @@ impl FromArgs for DirFd { }; if AVAILABLE == 0 && fd != DEFAULT_DIR_FD { return Err(vm - .new_not_implemented_error("dir_fd unavailable on this platform".to_owned()) + .new_not_implemented_error("dir_fd unavailable on this platform") .into()); } Ok(Self([fd; AVAILABLE])) @@ -122,7 +122,7 @@ pub(super) struct FollowSymlinks( fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a ffi::OsStr> { rustpython_common::os::bytes_as_os_str(b) - .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8".to_owned())) + .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8")) } #[pymodule(sub)] @@ -344,7 +344,7 @@ pub(super) mod _os { { let _ = fno; return Err(vm.new_not_implemented_error( - "can't pass fd to listdir on this platform".to_owned(), + "can't pass fd to listdir on this platform", )); } #[cfg(all(unix, not(target_os = "redox")))] @@ -388,10 +388,10 @@ pub(super) mod _os { let key = env_bytes_as_bytes(&key); let value = env_bytes_as_bytes(&value); if key.contains(&b'\0') || value.contains(&b'\0') { - return Err(vm.new_value_error("embedded null byte".to_string())); + return Err(vm.new_value_error("embedded null byte")); } if key.is_empty() || key.contains(&b'=') { - return Err(vm.new_value_error("illegal environment variable name".to_string())); + return Err(vm.new_value_error("illegal environment variable name")); } let key = super::bytes_as_os_str(key, vm)?; let value = super::bytes_as_os_str(value, vm)?; @@ -404,7 +404,7 @@ pub(super) mod _os { fn unsetenv(key: Either, vm: &VirtualMachine) -> PyResult<()> { let key = env_bytes_as_bytes(&key); if key.contains(&b'\0') { - return Err(vm.new_value_error("embedded null byte".to_string())); + return Err(vm.new_value_error("embedded null byte")); } if key.is_empty() || key.contains(&b'=') { return Err(vm.new_errno_error( @@ -971,7 +971,7 @@ pub(super) mod _os { #[pyfunction] fn urandom(size: isize, vm: &VirtualMachine) -> PyResult> { if size < 0 { - return Err(vm.new_value_error("negative argument not allowed".to_owned())); + return Err(vm.new_value_error("negative argument not allowed")); } let mut buf = vec![0u8; size as usize]; getrandom::fill(&mut buf).map_err(|e| io::Error::from(e).into_pyexception(vm))?; @@ -1052,14 +1052,14 @@ pub(super) mod _os { (Some(t), None) => { let (a, m) = parse_tup(&t).ok_or_else(|| { vm.new_type_error( - "utime: 'times' must be either a tuple of two ints or None".to_owned(), + "utime: 'times' must be either a tuple of two ints or None", ) })?; (a.try_into_value(vm)?, m.try_into_value(vm)?) } (None, Some(ns)) => { let (a, m) = parse_tup(&ns).ok_or_else(|| { - vm.new_type_error("utime: 'ns' must be a tuple of two ints".to_owned()) + vm.new_type_error("utime: 'ns' must be a tuple of two ints") })?; let ns_in_sec: PyObjectRef = vm.ctx.new_int(1_000_000_000).into(); let ns_to_dur = |obj: PyObjectRef| { @@ -1089,7 +1089,7 @@ pub(super) mod _os { } (Some(_), Some(_)) => { return Err(vm.new_value_error( - "utime: you may specify either 'times' or 'ns' but not both".to_owned(), + "utime: you may specify either 'times' or 'ns' but not both", )); } }; @@ -1286,7 +1286,7 @@ pub(super) mod _os { let count: usize = args .count .try_into() - .map_err(|_| vm.new_value_error("count should >= 0".to_string()))?; + .map_err(|_| vm.new_value_error("count should >= 0"))?; // The flags argument is provided to allow // for future extensions and currently must be to 0. diff --git a/vm/src/stdlib/posix.rs b/vm/src/stdlib/posix.rs index 8eecaaf119..a5f61d41da 100644 --- a/vm/src/stdlib/posix.rs +++ b/vm/src/stdlib/posix.rs @@ -288,8 +288,7 @@ pub mod module { let flags = AccessFlags::from_bits(mode).ok_or_else(|| { vm.new_value_error( - "One of the flags is wrong, there are only 4 possibilities F_OK, R_OK, W_OK and X_OK" - .to_owned(), + "One of the flags is wrong, there are only 4 possibilities F_OK, R_OK, W_OK and X_OK", ) })?; @@ -475,7 +474,7 @@ pub mod module { match arg { OptionalArg::Present(obj) => { if !obj.is_callable() { - return Err(vm.new_type_error("Args must be callable".to_owned())); + return Err(vm.new_type_error("Args must be callable")); } Ok(Some(obj)) } @@ -486,7 +485,7 @@ pub mod module { let after_in_parent = into_option(self.after_in_parent, vm)?; let after_in_child = into_option(self.after_in_child, vm)?; if before.is_none() && after_in_parent.is_none() && after_in_child.is_none() { - return Err(vm.new_type_error("At least one arg must be present".to_owned())); + return Err(vm.new_type_error("At least one arg must be present")); } Ok((before, after_in_parent, after_in_child)) } @@ -988,10 +987,10 @@ pub mod module { let first = argv .first() - .ok_or_else(|| vm.new_value_error("execv() arg 2 must not be empty".to_owned()))?; + .ok_or_else(|| vm.new_value_error("execv() arg 2 must not be empty"))?; if first.to_bytes().is_empty() { return Err( - vm.new_value_error("execv() arg 2 first element cannot be empty".to_owned()) + vm.new_value_error("execv() arg 2 first element cannot be empty") ); } @@ -1016,11 +1015,11 @@ pub mod module { let first = argv .first() - .ok_or_else(|| vm.new_value_error("execve() arg 2 must not be empty".to_owned()))?; + .ok_or_else(|| vm.new_value_error("execve() arg 2 must not be empty"))?; if first.to_bytes().is_empty() { return Err( - vm.new_value_error("execve() arg 2 first element cannot be empty".to_owned()) + vm.new_value_error("execve() arg 2 first element cannot be empty") ); } @@ -1033,7 +1032,7 @@ pub mod module { ); if memchr::memchr(b'=', &key).is_some() { - return Err(vm.new_value_error("illegal environment variable name".to_owned())); + return Err(vm.new_value_error("illegal environment variable name")); } let mut entry = key; @@ -1324,11 +1323,11 @@ pub mod module { .map(|item| { let tuple = item .downcast_ref::() - .ok_or_else(|| vm.new_type_error("items() should return tuples".to_owned()))?; + .ok_or_else(|| vm.new_type_error("items() should return tuples"))?; let tuple_items = tuple.as_slice(); if tuple_items.len() != 2 { return Err(vm.new_value_error( - "items() tuples should have exactly 2 elements".to_owned(), + "items() tuples should have exactly 2 elements", )); } Ok((tuple_items[0].clone(), tuple_items[1].clone())) @@ -1340,17 +1339,17 @@ pub mod module { let v = OsPath::try_from_object(vm, v)?.into_bytes(); if k.contains(&0) { return Err( - vm.new_value_error("envp dict key cannot contain a nul byte".to_owned()) + vm.new_value_error("envp dict key cannot contain a nul byte") ); } if k.contains(&b'=') { return Err(vm.new_value_error( - "envp dict key cannot contain a '=' character".to_owned(), + "envp dict key cannot contain a '=' character", )); } if v.contains(&0) { return Err( - vm.new_value_error("envp dict value cannot contain a nul byte".to_owned()) + vm.new_value_error("envp dict value cannot contain a nul byte") ); } let mut env = k; @@ -1404,7 +1403,7 @@ pub mod module { .path .clone() .into_cstring(vm) - .map_err(|_| vm.new_value_error("path should not have nul bytes".to_owned()))?; + .map_err(|_| vm.new_value_error("path should not have nul bytes"))?; let mut file_actions = unsafe { let mut fa = std::mem::MaybeUninit::uninit(); @@ -1416,12 +1415,12 @@ pub mod module { let action = action?; let (id, args) = action.split_first().ok_or_else(|| { vm.new_type_error( - "Each file_actions element must be a non-empty tuple".to_owned(), + "Each file_actions element must be a non-empty tuple", ) })?; let id = i32::try_from_borrowed_object(vm, id)?; let id = PosixSpawnFileActionIdentifier::try_from(id).map_err(|_| { - vm.new_type_error("Unknown file_actions identifier".to_owned()) + vm.new_type_error("Unknown file_actions identifier") })?; let args: crate::function::FuncArgs = args.to_vec().into(); let ret = match id { @@ -1429,7 +1428,7 @@ pub mod module { let (fd, path, oflag, mode): (_, OsPath, _, _) = args.bind(vm)?; let path = CString::new(path.into_bytes()).map_err(|_| { vm.new_value_error( - "POSIX_SPAWN_OPEN path should not have nul bytes".to_owned(), + "POSIX_SPAWN_OPEN path should not have nul bytes", ) })?; unsafe { @@ -1506,7 +1505,7 @@ pub mod module { #[cfg(not(target_os = "linux"))] { return Err(vm.new_not_implemented_error( - "setsid parameter is not supported on this platform".to_owned(), + "setsid parameter is not supported on this platform", )); } } @@ -1534,14 +1533,14 @@ pub mod module { // TODO: Implement scheduler parameter handling // This requires platform-specific sched_param struct handling return Err(vm.new_not_implemented_error( - "scheduler parameter is not yet implemented".to_owned(), + "scheduler parameter is not yet implemented", )); } if flags != 0 { // Check for potential overflow when casting to c_short if flags > libc::c_short::MAX as i32 { - return Err(vm.new_value_error("Too many flags set for posix_spawn".to_owned())); + return Err(vm.new_value_error("Too many flags set for posix_spawn")); } let ret = unsafe { libc::posix_spawnattr_setflags(&mut attrp, flags as libc::c_short) }; @@ -1555,7 +1554,7 @@ pub mod module { .iter(vm)? .map(|res| { CString::new(res?.into_bytes()).map_err(|_| { - vm.new_value_error("path should not have nul bytes".to_owned()) + vm.new_value_error("path should not have nul bytes") }) }) .collect::>()?; @@ -1856,7 +1855,7 @@ pub mod module { Err(obj) => { let s = PyStrRef::try_from_object(vm, obj)?; s.as_str().parse::().map_err(|_| { - vm.new_value_error("unrecognized configuration name".to_string()) + vm.new_value_error("unrecognized configuration name") })? as i32 } }; @@ -2252,7 +2251,7 @@ pub mod module { if s.as_str() == "SC_PAGESIZE" { Ok(SysconfVar::SC_PAGESIZE) } else { - Err(vm.new_value_error("unrecognized configuration name".to_string())) + Err(vm.new_value_error("unrecognized configuration name")) } })? as i32 } diff --git a/vm/src/stdlib/signal.rs b/vm/src/stdlib/signal.rs index 1e1e779e34..b0b0343961 100644 --- a/vm/src/stdlib/signal.rs +++ b/vm/src/stdlib/signal.rs @@ -147,7 +147,7 @@ pub(crate) mod _signal { _handler: PyObjectRef, vm: &VirtualMachine, ) -> PyResult> { - Err(vm.new_not_implemented_error("signal is not implemented on this platform".to_owned())) + Err(vm.new_not_implemented_error("signal is not implemented on this platform")) } #[cfg(any(unix, windows))] @@ -161,7 +161,7 @@ pub(crate) mod _signal { let signal_handlers = vm .signal_handlers .as_deref() - .ok_or_else(|| vm.new_value_error("signal only works in main thread".to_owned()))?; + .ok_or_else(|| vm.new_value_error("signal only works in main thread"))?; let sig_handler = match usize::try_from_borrowed_object(vm, &handler).ok() { @@ -169,8 +169,7 @@ pub(crate) mod _signal { Some(SIG_IGN) => SIG_IGN, None if handler.is_callable() => run_signal as sighandler_t, _ => return Err(vm.new_type_error( - "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object" - .to_owned(), + "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object", )), }; signal::check_signals(vm)?; @@ -194,7 +193,7 @@ pub(crate) mod _signal { let signal_handlers = vm .signal_handlers .as_deref() - .ok_or_else(|| vm.new_value_error("getsignal only works in main thread".to_owned()))?; + .ok_or_else(|| vm.new_value_error("getsignal only works in main thread"))?; let handler = signal_handlers.borrow()[signalnum as usize] .clone() .unwrap_or_else(|| vm.ctx.none()); @@ -238,7 +237,7 @@ pub(crate) mod _signal { let fd = args.fd; if vm.signal_handlers.is_none() { - return Err(vm.new_value_error("signal only works in main thread".to_owned())); + return Err(vm.new_value_error("signal only works in main thread")); } #[cfg(windows)] diff --git a/vm/src/stdlib/sre.rs b/vm/src/stdlib/sre.rs index fdb48c7524..34a83c2559 100644 --- a/vm/src/stdlib/sre.rs +++ b/vm/src/stdlib/sre.rs @@ -128,7 +128,7 @@ mod _sre { let result = func.call((pattern, repl.clone()), vm)?; result .downcast::() - .map_err(|_| vm.new_runtime_error("expected SRE_Template".to_owned())) + .map_err(|_| vm.new_runtime_error("expected SRE_Template")) } } @@ -138,7 +138,7 @@ mod _sre { template: PyListRef, vm: &VirtualMachine, ) -> PyResult