From a9331bb34df1ce1b61b156044087886e2a182bf3 Mon Sep 17 00:00:00 2001 From: Noa Date: Mon, 10 Feb 2025 23:47:27 -0600 Subject: [PATCH] Fix warnings for rust 1.85 --- Cargo.lock | 2 +- Cargo.toml | 2 +- common/src/hash.rs | 4 +- compiler/core/src/bytecode.rs | 2 +- src/shell/helper.rs | 2 +- stdlib/src/binascii.rs | 14 ++-- vm/src/builtins/object.rs | 2 +- vm/src/builtins/str.rs | 148 +++++++++++++++++----------------- vm/src/codecs.rs | 4 +- vm/src/stdlib/io.rs | 2 +- vm/src/vm/vm_ops.rs | 4 +- vm/sre_engine/src/string.rs | 4 +- 12 files changed, 95 insertions(+), 95 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 11992d8d8..edf28dc7f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1322,7 +1322,7 @@ version = "3.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df7151a832e54d2d6b2c827a20e5bcdd80359281cd2c354e725d4b82e7c471de" dependencies = [ - "rand_core 0.9.0", + "rand_core 0.9.1", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index bda7286af..83007606c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -104,7 +104,7 @@ members = [ version = "0.4.0" authors = ["RustPython Team"] edition = "2021" -rust-version = "1.83.0" +rust-version = "1.85.0" repository = "https://github.com/RustPython/RustPython" license = "MIT" diff --git a/common/src/hash.rs b/common/src/hash.rs index 700d2ceef..5b5ac003c 100644 --- a/common/src/hash.rs +++ b/common/src/hash.rs @@ -114,7 +114,7 @@ pub fn hash_float(value: f64) -> Option { let mut e = frexp.1; let mut x: PyUHash = 0; while m != 0.0 { - x = ((x << 28) & MODULUS) | x >> (BITS - 28); + x = ((x << 28) & MODULUS) | (x >> (BITS - 28)); m *= 268_435_456.0; // 2**28 e -= 28; let y = m as PyUHash; // pull out integer part @@ -132,7 +132,7 @@ pub fn hash_float(value: f64) -> Option { } else { BITS32 - 1 - ((-1 - e) % BITS32) }; - x = ((x << e) & MODULUS) | x >> (BITS32 - e); + x = ((x << e) & MODULUS) | (x >> (BITS32 - e)); Some(fix_sentinel(x as PyHash * value.signum() as PyHash)) } diff --git a/compiler/core/src/bytecode.rs b/compiler/core/src/bytecode.rs index 46839c269..21d342b54 100644 --- a/compiler/core/src/bytecode.rs +++ b/compiler/core/src/bytecode.rs @@ -197,7 +197,7 @@ impl OpArgState { } #[inline(always)] pub fn extend(&mut self, arg: OpArgByte) -> OpArg { - self.state = self.state << 8 | u32::from(arg.0); + self.state = (self.state << 8) | u32::from(arg.0); OpArg(self.state) } #[inline(always)] diff --git a/src/shell/helper.rs b/src/shell/helper.rs index c228dbdf6..4d663b942 100644 --- a/src/shell/helper.rs +++ b/src/shell/helper.rs @@ -107,7 +107,7 @@ impl<'vm> ShellHelper<'vm> { .filter(|res| { res.as_ref() .ok() - .map_or(true, |s| s.as_str().starts_with(word_start)) + .is_none_or(|s| s.as_str().starts_with(word_start)) }) .collect::, _>>() .ok()?; diff --git a/stdlib/src/binascii.rs b/stdlib/src/binascii.rs index d348049f4..eb1164587 100644 --- a/stdlib/src/binascii.rs +++ b/stdlib/src/binascii.rs @@ -76,7 +76,7 @@ mod decl { let mut unhex = Vec::::with_capacity(hex_bytes.len() / 2); for (n1, n2) in hex_bytes.iter().tuples() { if let (Some(n1), Some(n2)) = (unhex_nibble(*n1), unhex_nibble(*n2)) { - unhex.push(n1 << 4 | n2); + unhex.push((n1 << 4) | n2); } else { return Err(super::new_binascii_error( "Non-hexadecimal digit found".to_owned(), @@ -343,7 +343,7 @@ mod decl { if let (Some(ch1), Some(ch2)) = (unhex_nibble(buffer[idx]), unhex_nibble(buffer[idx + 1])) { - out_data.push(ch1 << 4 | ch2); + out_data.push((ch1 << 4) | ch2); } idx += 2; } else { @@ -661,19 +661,19 @@ mod decl { }; if res.len() < length { - res.push(char_a << 2 | char_b >> 4); + res.push((char_a << 2) | (char_b >> 4)); } else if char_a != 0 || char_b != 0 { return trailing_garbage_error(); } if res.len() < length { - res.push((char_b & 0xf) << 4 | char_c >> 2); + res.push(((char_b & 0xf) << 4) | (char_c >> 2)); } else if char_c != 0 { return trailing_garbage_error(); } if res.len() < length { - res.push((char_c & 0x3) << 6 | char_d); + res.push(((char_c & 0x3) << 6) | char_d); } else if char_d != 0 { return trailing_garbage_error(); } @@ -725,8 +725,8 @@ mod decl { let char_c = *chunk.get(2).unwrap_or(&0); res.push(uu_b2a(char_a >> 2, backtick)); - res.push(uu_b2a((char_a & 0x3) << 4 | char_b >> 4, backtick)); - res.push(uu_b2a((char_b & 0xf) << 2 | char_c >> 6, backtick)); + res.push(uu_b2a(((char_a & 0x3) << 4) | (char_b >> 4), backtick)); + res.push(uu_b2a(((char_b & 0xf) << 2) | (char_c >> 6), backtick)); res.push(uu_b2a(char_c & 0x3f, backtick)); } diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs index f783ee017..aeb9e93cc 100644 --- a/vm/src/builtins/object.rs +++ b/vm/src/builtins/object.rs @@ -113,7 +113,7 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine) // )); // } - let state = if obj.dict().map_or(true, |d| d.is_empty()) { + let state = if obj.dict().is_none_or(|d| d.is_empty()) { vm.ctx.none() } else { // let state = object_get_dict(obj.clone(), obj.ctx()).unwrap(); diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs index 52112f371..f5a340836 100644 --- a/vm/src/builtins/str.rs +++ b/vm/src/builtins/str.rs @@ -1565,80 +1565,6 @@ impl AsRef for PyExact { } } -#[cfg(test)] -mod tests { - use super::*; - use crate::Interpreter; - - #[test] - fn str_title() { - let tests = vec![ - (" Hello ", " hello "), - ("Hello ", "hello "), - ("Hello ", "Hello "), - ("Format This As Title String", "fOrMaT thIs aS titLe String"), - ("Format,This-As*Title;String", "fOrMaT,thIs-aS*titLe;String"), - ("Getint", "getInt"), - ("Greek Ωppercases ...", "greek ωppercases ..."), - ("Greek ῼitlecases ...", "greek ῳitlecases ..."), - ]; - for (title, input) in tests { - assert_eq!(PyStr::from(input).title().as_str(), title); - } - } - - #[test] - fn str_istitle() { - let pos = vec![ - "A", - "A Titlecased Line", - "A\nTitlecased Line", - "A Titlecased, Line", - "Greek Ωppercases ...", - "Greek ῼitlecases ...", - ]; - - for s in pos { - assert!(PyStr::from(s).istitle()); - } - - let neg = vec![ - "", - "a", - "\n", - "Not a capitalized String", - "Not\ta Titlecase String", - "Not--a Titlecase String", - "NOT", - ]; - for s in neg { - assert!(!PyStr::from(s).istitle()); - } - } - - #[test] - fn str_maketrans_and_translate() { - Interpreter::without_stdlib(Default::default()).enter(|vm| { - let table = vm.ctx.new_dict(); - table - .set_item("a", vm.ctx.new_str("🎅").into(), vm) - .unwrap(); - table.set_item("b", vm.ctx.none(), vm).unwrap(); - table - .set_item("c", vm.ctx.new_str(ascii!("xda")).into(), vm) - .unwrap(); - let translated = - PyStr::maketrans(table.into(), OptionalArg::Missing, OptionalArg::Missing, vm) - .unwrap(); - let text = PyStr::from("abc"); - let translated = text.translate(translated, vm).unwrap(); - assert_eq!(translated, "🎅xda".to_owned()); - let translated = text.translate(vm.ctx.new_int(3).into(), vm); - assert_eq!("TypeError", &*translated.unwrap_err().class().name(),); - }) - } -} - impl AnyStrWrapper for PyStrRef { type Str = str; fn as_ref(&self) -> &str { @@ -1780,3 +1706,77 @@ impl AsRef for PyStrInterned { self.as_str() } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::Interpreter; + + #[test] + fn str_title() { + let tests = vec![ + (" Hello ", " hello "), + ("Hello ", "hello "), + ("Hello ", "Hello "), + ("Format This As Title String", "fOrMaT thIs aS titLe String"), + ("Format,This-As*Title;String", "fOrMaT,thIs-aS*titLe;String"), + ("Getint", "getInt"), + ("Greek Ωppercases ...", "greek ωppercases ..."), + ("Greek ῼitlecases ...", "greek ῳitlecases ..."), + ]; + for (title, input) in tests { + assert_eq!(PyStr::from(input).title().as_str(), title); + } + } + + #[test] + fn str_istitle() { + let pos = vec![ + "A", + "A Titlecased Line", + "A\nTitlecased Line", + "A Titlecased, Line", + "Greek Ωppercases ...", + "Greek ῼitlecases ...", + ]; + + for s in pos { + assert!(PyStr::from(s).istitle()); + } + + let neg = vec![ + "", + "a", + "\n", + "Not a capitalized String", + "Not\ta Titlecase String", + "Not--a Titlecase String", + "NOT", + ]; + for s in neg { + assert!(!PyStr::from(s).istitle()); + } + } + + #[test] + fn str_maketrans_and_translate() { + Interpreter::without_stdlib(Default::default()).enter(|vm| { + let table = vm.ctx.new_dict(); + table + .set_item("a", vm.ctx.new_str("🎅").into(), vm) + .unwrap(); + table.set_item("b", vm.ctx.none(), vm).unwrap(); + table + .set_item("c", vm.ctx.new_str(ascii!("xda")).into(), vm) + .unwrap(); + let translated = + PyStr::maketrans(table.into(), OptionalArg::Missing, OptionalArg::Missing, vm) + .unwrap(); + let text = PyStr::from("abc"); + let translated = text.translate(translated, vm).unwrap(); + assert_eq!(translated, "🎅xda".to_owned()); + let translated = text.translate(vm.ctx.new_int(3).into(), vm); + assert_eq!("TypeError", &*translated.unwrap_err().class().name(),); + }) + } +} diff --git a/vm/src/codecs.rs b/vm/src/codecs.rs index 61be9f917..898198f3d 100644 --- a/vm/src/codecs.rs +++ b/vm/src/codecs.rs @@ -637,10 +637,10 @@ fn surrogatepass_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyOb } } StandardEncoding::Utf16Le => { - c = (p[1] as u32) << 8 | p[0] as u32; + c = ((p[1] as u32) << 8) | p[0] as u32; } StandardEncoding::Utf16Be => { - c = (p[0] as u32) << 8 | p[1] as u32; + c = ((p[0] as u32) << 8) | p[1] as u32; } StandardEncoding::Utf32Le => { c = ((p[3] as u32) << 24) diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index 3c35b05e1..c4f67cd6a 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -482,7 +482,7 @@ mod _io { let size = size.to_usize(); let read = instance.get_attr("read", vm)?; let mut res = Vec::new(); - while size.map_or(true, |s| res.len() < s) { + while size.is_none_or(|s| res.len() < s) { let read_res = ArgBytesLike::try_from_object(vm, read.call((1,), vm)?)?; if read_res.with_ref(|b| b.is_empty()) { break; diff --git a/vm/src/vm/vm_ops.rs b/vm/src/vm/vm_ops.rs index 56c32d292..3aa414419 100644 --- a/vm/src/vm/vm_ops.rs +++ b/vm/src/vm/vm_ops.rs @@ -298,8 +298,8 @@ impl VirtualMachine { } if let Some(slot_c) = class_c.slots.as_number.left_ternary_op(op_slot) { - if slot_a.is_some_and(|slot_a| slot_a != slot_c) - && slot_b.is_some_and(|slot_b| slot_b != slot_c) + if slot_a.is_some_and(|slot_a| !std::ptr::fn_addr_eq(slot_a, slot_c)) + && slot_b.is_some_and(|slot_b| !std::ptr::fn_addr_eq(slot_b, slot_c)) { let ret = slot_c(a, b, c, self)?; if !ret.is(&self.ctx.not_implemented) { diff --git a/vm/sre_engine/src/string.rs b/vm/sre_engine/src/string.rs index ca8b3179d..b5a2470f5 100644 --- a/vm/sre_engine/src/string.rs +++ b/vm/sre_engine/src/string.rs @@ -181,7 +181,7 @@ unsafe fn next_code_point(ptr: &mut *const u8) -> u32 { let z = **ptr; *ptr = ptr.offset(1); let y_z = utf8_acc_cont_byte((y & CONT_MASK) as u32, z); - ch = init << 12 | y_z; + ch = (init << 12) | y_z; if x >= 0xF0 { // [x y z w] case // use only the lower 3 bits of `init` @@ -189,7 +189,7 @@ unsafe fn next_code_point(ptr: &mut *const u8) -> u32 { // so the iterator must produce a value here. let w = **ptr; *ptr = ptr.offset(1); - ch = (init & 7) << 18 | utf8_acc_cont_byte(y_z, w); + ch = ((init & 7) << 18) | utf8_acc_cont_byte(y_z, w); } }