RustPython · coolreader18 · Feb 25, 2025 · Feb 25, 2025 · youknowone · Feb 25, 2025
diff --git a/Cargo.toml b/Cargo.toml
@@ -190,9 +190,13 @@ wasm-bindgen = "0.2.100"
 [workspace.lints.rust]
 unsafe_code = "allow"
 unsafe_op_in_unsafe_fn = "deny"
+
+# rust_2024_compatibility
 missing_unsafe_on_extern = "deny"
 unsafe_attr_outside_unsafe = "deny"
 deprecated_safe_2024 = "deny"
+rust_2024_incompatible_pat = "deny"
+keyword_idents_2024 = "deny"

 [workspace.lints.clippy]
 perf = "warn"

diff --git a/common/src/int.rs b/common/src/int.rs
@@ -50,7 +50,7 @@ pub fn bytes_to_int(lit: &[u8], mut base: u32) -> Option<BigInt> {
                    base = parsed;
                    true
                } else {
-                    if let [_first, ref others @ .., last] = lit {
+                    if let [_first, others @ .., last] = lit {
                        let is_zero =
                            others.iter().all(|&c| c == b'0' || c == b'_') && *last == b'0';
                        if !is_zero {

diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
@@ -3302,13 +3302,13 @@ impl Compiler {
                elt, generators, ..
            }) => {
                Self::contains_await(elt)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
            }
            Expr::SetComp(located_ast::ExprSetComp {
                elt, generators, ..
            }) => {
                Self::contains_await(elt)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
            }
            Expr::DictComp(located_ast::ExprDictComp {
                key,
@@ -3318,13 +3318,13 @@ impl Compiler {
            }) => {
                Self::contains_await(key)
                    || Self::contains_await(value)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
            }
            Expr::GeneratorExp(located_ast::ExprGeneratorExp {
                elt, generators, ..
            }) => {
                Self::contains_await(elt)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
            }
            Expr::Starred(expr) => Self::contains_await(&expr.value),
            Expr::IfExp(located_ast::ExprIfExp {

diff --git a/derive-impl/src/pytraverse.rs b/derive-impl/src/pytraverse.rs
@@ -70,7 +70,7 @@ fn gen_trace_code(item: &mut DeriveInput) -> Result<TokenStream> {
        syn::Data::Struct(s) => {
            let fields = &mut s.fields;
            match fields {
-                syn::Fields::Named(ref mut fields) => {
+                syn::Fields::Named(fields) => {
                    let res: Vec<TokenStream> = fields
                        .named
                        .iter_mut()

diff --git a/derive-impl/src/util.rs b/derive-impl/src/util.rs
@@ -529,7 +529,7 @@ impl AttributeExt for Attribute {
    fn try_remove_name(&mut self, item_name: &str) -> Result<Option<NestedMeta>> {
        self.try_meta_mut(|meta| {
            let nested = match meta {
-                Meta::List(MetaList { ref mut nested, .. }) => Ok(nested),
+                Meta::List(MetaList { nested, .. }) => Ok(nested),
                other => Err(syn::Error::new(
                    other.span(),
                    format!(

diff --git a/jit/src/lib.rs b/jit/src/lib.rs
@@ -215,9 +215,9 @@ pub enum AbiValue {
 impl AbiValue {
    fn to_libffi_arg(&self) -> libffi::middle::Arg {
        match self {
-            AbiValue::Int(ref i) => libffi::middle::Arg::new(i),
-            AbiValue::Float(ref f) => libffi::middle::Arg::new(f),
-            AbiValue::Bool(ref b) => libffi::middle::Arg::new(b),
+            AbiValue::Int(i) => libffi::middle::Arg::new(i),
+            AbiValue::Float(f) => libffi::middle::Arg::new(f),
+            AbiValue::Bool(b) => libffi::middle::Arg::new(b),
        }
    }
 }

diff --git a/stdlib/src/csv.rs b/stdlib/src/csv.rs
@@ -272,12 +272,12 @@ mod _csv {
        let Some(name) = name.payload_if_subclass::<PyStr>(vm) else {
            return Err(vm.new_type_error("argument 0 must be a string".to_string()));
        };
-        let mut dialect = match dialect {
+        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()))?,
            OptionalArg::Missing => opts.result(vm)?,
        };
-        opts.update_pydialect(&mut dialect);
+        let dialect = opts.update_pydialect(dialect);
        GLOBAL_HASHMAP
            .lock()
            .insert(name.as_str().to_owned(), dialect);
@@ -665,7 +665,7 @@ mod _csv {
    }

    impl FormatOptions {
-        fn update_pydialect<'b>(&self, res: &'b mut PyDialect) -> &'b mut PyDialect {
+        fn update_pydialect(&self, mut res: PyDialect) -> PyDialect {
            macro_rules! check_and_fill {
                ($res:ident, $e:ident) => {{
                    if let Some(t) = self.$e {
@@ -699,24 +699,18 @@ mod _csv {
                DialectItem::Str(name) => {
                    let g = GLOBAL_HASHMAP.lock();
                    if let Some(dialect) = g.get(name) {
-                        let mut dialect = *dialect;
-                        self.update_pydialect(&mut dialect);
-                        Ok(dialect)
+                        Ok(self.update_pydialect(*dialect))
                    } else {
                        Err(new_csv_error(vm, format!("{} is not registed.", name)))
                    }
                    // TODO
                    // Maybe need to update the obj from HashMap
                }
-                DialectItem::Obj(mut o) => {
-                    self.update_pydialect(&mut o);
-                    Ok(o)
-                }
+                DialectItem::Obj(o) => Ok(self.update_pydialect(*o)),
                DialectItem::None => {
                    let g = GLOBAL_HASHMAP.lock();
-                    let mut res = *g.get("excel").unwrap();
-                    self.update_pydialect(&mut res);
-                    Ok(res)
+                    let res = *g.get("excel").unwrap();
+                    Ok(self.update_pydialect(res))
                }
            }
        }

diff --git a/stdlib/src/json/machinery.rs b/stdlib/src/json/machinery.rs
@@ -135,7 +135,7 @@ pub fn scanstring<'a>(
    };
    let unterminated_err = || DecodeError::new("Unterminated string starting at", end - 1);
    let mut chars = s.char_indices().enumerate().skip(end).peekable();
-    let (_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
+    let &(_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
    while let Some((char_i, (byte_i, c))) = chars.next() {
        match c {
            '"' => {

diff --git a/stdlib/src/mmap.rs b/stdlib/src/mmap.rs
@@ -497,8 +497,8 @@ mod mmap {
        fn as_bytes(&self) -> BorrowedValue<[u8]> {
            PyMutexGuard::map_immutable(self.mmap.lock(), |m| {
                match m.as_ref().expect("mmap closed or invalid") {
-                    MmapObj::Read(ref mmap) => &mmap[..],
-                    MmapObj::Write(ref mmap) => &mmap[..],
+                    MmapObj::Read(mmap) => &mmap[..],
+                    MmapObj::Write(mmap) => &mmap[..],
                }
            })
            .into()

diff --git a/stdlib/src/socket.rs b/stdlib/src/socket.rs
@@ -1924,7 +1924,7 @@ mod _socket {
        let host = opts.host.as_ref().map(|s| s.as_str());
        let port = opts.port.as_ref().map(|p| -> std::borrow::Cow<str> {
            match p {
-                Either::A(ref s) => s.as_str().into(),
+                Either::A(s) => s.as_str().into(),
                Either::B(i) => i.to_string().into(),
            }
        });

diff --git a/stdlib/src/syslog.rs b/stdlib/src/syslog.rs
@@ -49,7 +49,7 @@ mod syslog {
    impl GlobalIdent {
        fn as_ptr(&self) -> *const c_char {
            match self {
-                GlobalIdent::Explicit(ref cstr) => cstr.as_ptr(),
+                GlobalIdent::Explicit(cstr) => cstr.as_ptr(),
                GlobalIdent::Implicit => std::ptr::null(),
            }
        }

diff --git a/vm/src/builtins/iter.rs b/vm/src/builtins/iter.rs
@@ -28,7 +28,7 @@ pub enum IterStatus<T> {
 unsafe impl<T: Traverse> Traverse for IterStatus<T> {
    fn traverse(&self, tracer_fn: &mut TraverseFn) {
        match self {
-            IterStatus::Active(ref r) => r.traverse(tracer_fn),
+            IterStatus::Active(r) => r.traverse(tracer_fn),
            IterStatus::Exhausted => (),
        }
    }

diff --git a/vm/src/builtins/mappingproxy.rs b/vm/src/builtins/mappingproxy.rs
@@ -29,8 +29,8 @@ enum MappingProxyInner {
 unsafe impl Traverse for MappingProxyInner {
    fn traverse(&self, tracer_fn: &mut TraverseFn) {
        match self {
-            MappingProxyInner::Class(ref r) => r.traverse(tracer_fn),
-            MappingProxyInner::Mapping(ref arg) => arg.traverse(tracer_fn),
+            MappingProxyInner::Class(r) => r.traverse(tracer_fn),
+            MappingProxyInner::Mapping(arg) => arg.traverse(tracer_fn),
        }
    }
 }

diff --git a/vm/src/coroutine.rs b/vm/src/coroutine.rs
@@ -36,8 +36,8 @@ pub struct Coro {
    exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
 }

-fn gen_name(gen: &PyObject, vm: &VirtualMachine) -> &'static str {
-    let typ = gen.class();
+fn gen_name(jen: &PyObject, vm: &VirtualMachine) -> &'static str {
+    let typ = jen.class();
    if typ.is(vm.ctx.types.coroutine_type) {
        "coroutine"
    } else if typ.is(vm.ctx.types.async_generator) {
@@ -67,15 +67,15 @@ impl Coro {

    fn run_with_context<F>(
        &self,
-        gen: &PyObject,
+        jen: &PyObject,
        vm: &VirtualMachine,
        func: F,
    ) -> PyResult<ExecutionResult>
    where
        F: FnOnce(FrameRef) -> PyResult<ExecutionResult>,
    {
        if self.running.compare_exchange(false, true).is_err() {
-            return Err(vm.new_value_error(format!("{} already executing", gen_name(gen, vm))));
+            return Err(vm.new_value_error(format!("{} already executing", gen_name(jen, vm))));
        }

        vm.push_exception(self.exception.lock().take());
@@ -90,7 +90,7 @@ impl Coro {

    pub fn send(
        &self,
-        gen: &PyObject,
+        jen: &PyObject,
        value: PyObjectRef,
        vm: &VirtualMachine,
    ) -> PyResult<PyIterReturn> {
@@ -102,22 +102,22 @@ impl Coro {
        } else if !vm.is_none(&value) {
            return Err(vm.new_type_error(format!(
                "can't send non-None value to a just-started {}",
-                gen_name(gen, vm),
+                gen_name(jen, vm),
            )));
        } else {
            None
        };
-        let result = self.run_with_context(gen, vm, |f| f.resume(value, vm));
+        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
        self.maybe_close(&result);
        match result {
            Ok(exec_res) => Ok(exec_res.into_iter_return(vm)),
            Err(e) => {
                if e.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
                    let err =
-                        vm.new_runtime_error(format!("{} raised StopIteration", gen_name(gen, vm)));
+                        vm.new_runtime_error(format!("{} raised StopIteration", gen_name(jen, vm)));
                    err.set_cause(Some(e));
                    Err(err)
-                } else if gen.class().is(vm.ctx.types.async_generator)
+                } else if jen.class().is(vm.ctx.types.async_generator)
                    && e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
                {
                    let err = vm
@@ -132,7 +132,7 @@ impl Coro {
    }
    pub fn throw(
        &self,
-        gen: &PyObject,
+        jen: &PyObject,
        exc_type: PyObjectRef,
        exc_val: PyObjectRef,
        exc_tb: PyObjectRef,
@@ -141,16 +141,16 @@ impl Coro {
        if self.closed.load() {
            return Err(vm.normalize_exception(exc_type, exc_val, exc_tb)?);
        }
-        let result = self.run_with_context(gen, vm, |f| f.gen_throw(vm, exc_type, exc_val, exc_tb));
+        let result = self.run_with_context(jen, vm, |f| f.gen_throw(vm, exc_type, exc_val, exc_tb));
        self.maybe_close(&result);
        Ok(result?.into_iter_return(vm))
    }

-    pub fn close(&self, gen: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+    pub fn close(&self, jen: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
        if self.closed.load() {
            return Ok(());
        }
-        let result = self.run_with_context(gen, vm, |f| {
+        let result = self.run_with_context(jen, vm, |f| {
            f.gen_throw(
                vm,
                vm.ctx.exceptions.generator_exit.to_owned().into(),
@@ -161,7 +161,7 @@ impl Coro {
        self.closed.store(true);
        match result {
            Ok(ExecutionResult::Yield(_)) => {
-                Err(vm.new_runtime_error(format!("{} ignored GeneratorExit", gen_name(gen, vm))))
+                Err(vm.new_runtime_error(format!("{} ignored GeneratorExit", gen_name(jen, vm))))
            }
            Err(e) if !is_gen_exit(&e, vm) => Err(e),
            _ => Ok(()),
@@ -183,10 +183,10 @@ impl Coro {
    pub fn set_name(&self, name: PyStrRef) {
        *self.name.lock() = name;
    }
-    pub fn repr(&self, gen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
+    pub fn repr(&self, jen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
        format!(
            "<{} object {} at {:#x}>",
-            gen_name(gen, vm),
+            gen_name(jen, vm),
            self.name.lock(),
            id
        )

diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -426,19 +426,19 @@ impl ExecutingFrame<'_> {
        exc_val: PyObjectRef,
        exc_tb: PyObjectRef,
    ) -> PyResult<ExecutionResult> {
-        if let Some(gen) = self.yield_from_target() {
+        if let Some(jen) = self.yield_from_target() {
            // borrow checker shenanigans - we only need to use exc_type/val/tb if the following
            // variable is Some
-            let thrower = if let Some(coro) = self.builtin_coro(gen) {
+            let thrower = if let Some(coro) = self.builtin_coro(jen) {
                Some(Either::A(coro))
            } else {
-                vm.get_attribute_opt(gen.to_owned(), "throw")?
+                vm.get_attribute_opt(jen.to_owned(), "throw")?
                    .map(Either::B)
            };
            if let Some(thrower) = thrower {
                let ret = match thrower {
                    Either::A(coro) => coro
-                        .throw(gen, exc_type, exc_val, exc_tb, vm)
+                        .throw(jen, exc_type, exc_val, exc_tb, vm)
                        .to_pyresult(vm), // FIXME:
                    Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
                };
@@ -1568,16 +1568,16 @@ impl ExecutingFrame<'_> {

    fn _send(
        &self,
-        gen: &PyObject,
+        jen: &PyObject,
        val: PyObjectRef,
        vm: &VirtualMachine,
    ) -> PyResult<PyIterReturn> {
-        match self.builtin_coro(gen) {
-            Some(coro) => coro.send(gen, val, vm),
+        match self.builtin_coro(jen) {
+            Some(coro) => coro.send(jen, val, vm),
            // FIXME: turn return type to PyResult<PyIterReturn> then ExecutionResult will be simplified
-            None if vm.is_none(&val) => PyIter::new(gen).next(vm),
+            None if vm.is_none(&val) => PyIter::new(jen).next(vm),
            None => {
-                let meth = gen.get_attr("send", vm)?;
+                let meth = jen.get_attr("send", vm)?;
                PyIterReturn::from_pyresult(meth.call((val,), vm), vm)
            }
        }

diff --git a/vm/src/function/argument.rs b/vm/src/function/argument.rs
@@ -497,7 +497,7 @@ where
 {
    fn traverse(&self, tracer_fn: &mut TraverseFn) {
        match self {
-            OptionalArg::Present(ref o) => o.traverse(tracer_fn),
+            OptionalArg::Present(o) => o.traverse(tracer_fn),
            OptionalArg::Missing => (),
        }
    }

diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs
@@ -3,7 +3,7 @@
 //! This module makes use of the parser logic, and translates all ast nodes
 //! into python ast.AST objects.

-mod gen;
+mod r#gen;

 use crate::{
    builtins::{self, PyDict, PyModule, PyStrRef, PyType},
@@ -398,6 +398,6 @@ pub const PY_COMPILE_FLAGS_MASK: i32 = PY_COMPILE_FLAG_AST_ONLY

 pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
    let module = _ast::make_module(vm);
-    gen::extend_module_nodes(vm, &module);
+    r#gen::extend_module_nodes(vm, &module);
    module
 }
diff --git a/vm/src/stdlib/ctypes/base.rs b/vm/src/stdlib/ctypes/base.rs
@@ -176,7 +176,7 @@ impl Constructor for PyCSimple {
        let attributes = cls.get_attributes();
        let _type_ = attributes
            .iter()
-            .find(|(&k, _)| k.to_object().str(vm).unwrap().to_string() == *"_type_")
+            .find(|(k, _)| k.to_object().str(vm).unwrap().to_string() == *"_type_")
            .unwrap()
            .1
            .str(vm)?