Fix stable clippy

youknowone · youknowone · commit 6c561ac9d7b7 · 2025-06-27T12:12:08.000+09:00
diff --git a/benches/execution.rs b/benches/execution.rs
@@ -71,7 +71,7 @@ pub fn benchmark_file_parsing(group: &mut BenchmarkGroup<WallTime>, name: &str,
 pub fn benchmark_pystone(group: &mut BenchmarkGroup<WallTime>, contents: String) {
     // Default is 50_000. This takes a while, so reduce it to 30k.
     for idx in (10_000..=30_000).step_by(10_000) {
-        let code_with_loops = format!("LOOPS = {}\n{}", idx, contents);
+        let code_with_loops = format!("LOOPS = {idx}\n{contents}");
         let code_str = code_with_loops.as_str();
 
         group.throughput(Throughput::Elements(idx as u64));
diff --git a/compiler/literal/src/float.rs b/compiler/literal/src/float.rs
@@ -261,7 +261,7 @@ fn test_to_hex() {
         // println!("{} -> {}", f, hex);
         let roundtrip = hexf_parse::parse_hexf64(&hex, false).unwrap();
         // println!("  -> {}", roundtrip);
-        assert!(f == roundtrip, "{} {} {}", f, hex, roundtrip);
+        assert!(f == roundtrip, "{f} {hex} {roundtrip}");
     }
 }
 
diff --git a/examples/dis.rs b/examples/dis.rs
@@ -59,7 +59,7 @@ fn main() -> Result<(), lexopt::Error> {
         if script.exists() && script.is_file() {
             let res = display_script(script, mode, opts.clone(), expand_code_objects);
             if let Err(e) = res {
-                error!("Error while compiling {:?}: {}", script, e);
+                error!("Error while compiling {script:?}: {e}");
             }
         } else {
             eprintln!("{script:?} is not a file.");
diff --git a/examples/parse_folder.rs b/examples/parse_folder.rs
@@ -41,9 +41,9 @@ fn main() {
 
 fn parse_folder(path: &Path) -> std::io::Result<Vec<ParsedFile>> {
     let mut res = vec![];
-    info!("Parsing folder of python code: {:?}", path);
+    info!("Parsing folder of python code: {path:?}");
     for entry in path.read_dir()? {
-        debug!("Entry: {:?}", entry);
+        debug!("Entry: {entry:?}");
         let entry = entry?;
         let metadata = entry.metadata()?;
 
@@ -56,7 +56,7 @@ fn parse_folder(path: &Path) -> std::io::Result<Vec<ParsedFile>> {
             let parsed_file = parse_python_file(&path);
             match &parsed_file.result {
                 Ok(_) => {}
-                Err(y) => error!("Erreur in file {:?} {:?}", path, y),
+                Err(y) => error!("Erreur in file {path:?} {y:?}"),
             }
 
             res.push(parsed_file);
@@ -66,7 +66,7 @@ fn parse_folder(path: &Path) -> std::io::Result<Vec<ParsedFile>> {
 }
 
 fn parse_python_file(filename: &Path) -> ParsedFile {
-    info!("Parsing file {:?}", filename);
+    info!("Parsing file {filename:?}");
     match std::fs::read_to_string(filename) {
         Err(e) => ParsedFile {
             num_lines: 0,
diff --git a/jit/tests/common.rs b/jit/tests/common.rs
@@ -172,7 +172,7 @@ impl StackMachine {
         if let Some(StackValue::Function(function)) = self.locals.get(name) {
             function.clone()
         } else {
-            panic!("There was no function named {}", name)
+            panic!("There was no function named {name}")
         }
     }
 }
diff --git a/stdlib/src/array.rs b/stdlib/src/array.rs
@@ -601,7 +601,7 @@ mod array {
 
         fn try_from(ch: WideChar) -> Result<Self, Self::Error> {
             // safe because every configuration of bytes for the types we support are valid
-            u32_to_char(ch.0 as u32)
+            u32_to_char(ch.0 as _)
         }
     }
 
diff --git a/vm/src/builtins/genericalias.rs b/vm/src/builtins/genericalias.rs
@@ -388,10 +388,9 @@ pub fn subs_parameters<F: Fn(&VirtualMachine) -> PyResult<String>>(
                 new_args.push(substituted);
             } else {
                 // CPython doesn't support default values in this context
-                return Err(vm.new_type_error(format!(
-                    "No argument provided for parameter at index {}",
-                    idx
-                )));
+                return Err(
+                    vm.new_type_error(format!("No argument provided for parameter at index {idx}"))
+                );
             }
         } else {
             new_args.push(subs_tvars(arg.clone(), &parameters, arg_items, vm)?);
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -349,7 +349,10 @@ impl ExecutingFrame<'_> {
     }
 
     fn run(&mut self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
-        flame_guard!(format!("Frame::run({})", self.code.obj_name));
+        flame_guard!(format!(
+            "Frame::run({obj_name})",
+            obj_name = self.code.obj_name
+        ));
         // Execute until return or exception:
         let instructions = &self.code.instructions;
         let mut arg_state = bytecode::OpArgState::default();
@@ -941,7 +944,7 @@ impl ExecutingFrame<'_> {
                     .get_attr(identifier!(vm, __exit__), vm)
                     .map_err(|_exc| {
                         vm.new_type_error({
-                            format!("'{} (missed __exit__ method)", error_string())
+                            format!("{} (missed __exit__ method)", error_string())
                         })
                     })?;
                 self.push_value(exit);
@@ -968,7 +971,7 @@ impl ExecutingFrame<'_> {
                     .get_attr(identifier!(vm, __aexit__), vm)
                     .map_err(|_exc| {
                         vm.new_type_error({
-                            format!("'{} (missed __aexit__ method)", error_string())
+                            format!("{} (missed __aexit__ method)", error_string())
                         })
                     })?;
                 self.push_value(aexit);
@@ -1638,7 +1641,7 @@ impl ExecutingFrame<'_> {
         F: FnMut(PyObjectRef) -> PyResult<()>,
     {
         let Some(keys_method) = vm.get_method(mapping.clone(), vm.ctx.intern_str("keys")) else {
-            return Err(vm.new_type_error(format!("{} must be a mapping", error_prefix)));
+            return Err(vm.new_type_error(format!("{error_prefix} must be a mapping")));
         };
 
         let keys = keys_method?.call((), vm)?.get_iter(vm)?;
diff --git a/vm/src/stdlib/functools.rs b/vm/src/stdlib/functools.rs
@@ -286,7 +286,10 @@ mod _functools {
                         key.str(vm)?.as_str().to_owned()
                     };
                     let value_str = value.repr(vm)?;
-                    parts.push(format!("{}={}", key_part, value_str.as_str()));
+                    parts.push(format!(
+                        "{key_part}={value_str}",
+                        value_str = value_str.as_str()
+                    ));
                 }
 
                 let class_name = zelf.class().name();
@@ -306,14 +309,17 @@ mod _functools {
                                     // For test modules, just use the class name without module prefix
                                     class_name.to_owned()
                                 }
-                                _ => format!("{}.{}", module_name, class_name),
+                                _ => format!("{module_name}.{class_name}"),
                             }
                         }
                         Err(_) => class_name.to_owned(),
                     }
                 };
 
-                Ok(format!("{}({})", qualified_name, parts.join(", ")))
+                Ok(format!(
+                    "{qualified_name}({parts})",
+                    parts = parts.join(", ")
+                ))
             } else {
                 Ok("...".to_owned())
             }
diff --git a/vm/src/stdlib/sys.rs b/vm/src/stdlib/sys.rs
@@ -373,11 +373,10 @@ mod sys {
                 let type_name = exc_val.class().name();
                 // TODO: fix error message
                 let msg = format!(
-                    "TypeError: print_exception(): Exception expected for value, {} found\n",
-                    type_name
+                    "TypeError: print_exception(): Exception expected for value, {type_name} found\n"
                 );
                 use crate::py_io::Write;
-                write!(&mut crate::py_io::PyWriter(stderr, vm), "{}", msg)?;
+                write!(&mut crate::py_io::PyWriter(stderr, vm), "{msg}")?;
                 Ok(())
             }
         }
diff --git a/vm/src/stdlib/typing.rs b/vm/src/stdlib/typing.rs
@@ -171,11 +171,11 @@ pub(crate) mod decl {
         fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
             let name = zelf.name.str(vm)?;
             let repr = if zelf.covariant {
-                format!("+{}", name)
+                format!("+{name}")
             } else if zelf.contravariant {
-                format!("-{}", name)
+                format!("-{name}")
             } else {
-                format!("~{}", name)
+                format!("~{name}")
             };
             Ok(repr)
         }
@@ -738,7 +738,7 @@ pub(crate) mod decl {
         #[inline(always)]
         fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
             let name = zelf.name.str(vm)?;
-            Ok(format!("*{}", name))
+            Ok(format!("*{name}"))
         }
     }
 
@@ -785,7 +785,7 @@ pub(crate) mod decl {
         fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
             // Check if origin is a ParamSpec
             if let Ok(name) = zelf.__origin__.get_attr("__name__", vm) {
-                return Ok(format!("{}.args", name.str(vm)?));
+                return Ok(format!("{name}.args", name = name.str(vm)?));
             }
             Ok(format!("{:?}.args", zelf.__origin__))
         }
@@ -864,7 +864,7 @@ pub(crate) mod decl {
         fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
             // Check if origin is a ParamSpec
             if let Ok(name) = zelf.__origin__.get_attr("__name__", vm) {
-                return Ok(format!("{}.kwargs", name.str(vm)?));
+                return Ok(format!("{name}.kwargs", name = name.str(vm)?));
             }
             Ok(format!("{:?}.kwargs", zelf.__origin__))
         }
diff --git a/vm/src/vm/vm_object.rs b/vm/src/vm/vm_object.rs
@@ -38,7 +38,7 @@ impl VirtualMachine {
             let mut s = String::new();
             self.write_exception(&mut s, &exc).unwrap();
             error(&s);
-            panic!("{}; exception backtrace above", msg)
+            panic!("{msg}; exception backtrace above")
         }
         #[cfg(all(
             target_arch = "wasm32",
@@ -49,7 +49,7 @@ impl VirtualMachine {
             use crate::convert::ToPyObject;
             let err_string: String = exc.to_pyobject(self).repr(self).unwrap().to_string();
             eprintln!("{err_string}");
-            panic!("{}; python exception not available", msg)
+            panic!("{msg}; python exception not available")
         }
     }
 
diff --git a/wasm/wasm-unknown-test/Cargo.toml b/wasm/wasm-unknown-test/Cargo.toml
@@ -11,3 +11,6 @@ getrandom = "0.3"
 rustpython-vm = { path = "../../vm", default-features = false, features = ["compiler"] }
 
 [workspace]
+
+[patch.crates-io]
+radium = { version = "1.1.0", git = "https://github.com/youknowone/ferrilab", branch = "fix-nightly" }

Original file line number	Diff line number	Diff line change
`@@ -261,7 +261,7 @@ fn test_to_hex() {`
`261`	`261`	`// println!("{} -> {}", f, hex);`
`262`	`262`	`let roundtrip = hexf_parse::parse_hexf64(&hex, false).unwrap();`
`263`	`263`	`// println!(" -> {}", roundtrip);`
`264`		`- assert!(f == roundtrip, "{} {} {}", f, hex, roundtrip);`
	`264`	`+ assert!(f == roundtrip, "{f} {hex} {roundtrip}");`
`265`	`265`	`}`
`266`	`266`	`}`
`267`	`267`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ fn main() -> Result<(), lexopt::Error> {`
`59`	`59`	`if script.exists() && script.is_file() {`
`60`	`60`	`let res = display_script(script, mode, opts.clone(), expand_code_objects);`
`61`	`61`	`if let Err(e) = res {`
`62`		`- error!("Error while compiling {:?}: {}", script, e);`
	`62`	`+ error!("Error while compiling {script:?}: {e}");`
`63`	`63`	`}`
`64`	`64`	`} else {`
`65`	`65`	`eprintln!("{script:?} is not a file.");`
Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ impl StackMachine {`
`172`	`172`	`if let Some(StackValue::Function(function)) = self.locals.get(name) {`
`173`	`173`	`function.clone()`
`174`	`174`	`} else {`
`175`		`- panic!("There was no function named {}", name)`
	`175`	`+ panic!("There was no function named {name}")`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -601,7 +601,7 @@ mod array {`
`601`	`601`
`602`	`602`	`fn try_from(ch: WideChar) -> Result<Self, Self::Error> {`
`603`	`603`	`// safe because every configuration of bytes for the types we support are valid`
`604`		`- u32_to_char(ch.0 as u32)`
	`604`	`+ u32_to_char(ch.0 as _)`
`605`	`605`	`}`
`606`	`606`	`}`
`607`	`607`
Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,10 @@ mod _functools {`
`286`	`286`	`key.str(vm)?.as_str().to_owned()`
`287`	`287`	`};`
`288`	`288`	`let value_str = value.repr(vm)?;`
`289`		`- parts.push(format!("{}={}", key_part, value_str.as_str()));`
	`289`	`+ parts.push(format!(`
	`290`	`+ "{key_part}={value_str}",`
	`291`	`+ value_str = value_str.as_str()`
	`292`	`+ ));`
`290`	`293`	`}`
`291`	`294`
`292`	`295`	`let class_name = zelf.class().name();`
`@@ -306,14 +309,17 @@ mod _functools {`
`306`	`309`	`// For test modules, just use the class name without module prefix`
`307`	`310`	`class_name.to_owned()`
`308`	`311`	`}`
`309`		`- _ => format!("{}.{}", module_name, class_name),`
	`312`	`+ _ => format!("{module_name}.{class_name}"),`
`310`	`313`	`}`
`311`	`314`	`}`
`312`	`315`	`Err(_) => class_name.to_owned(),`
`313`	`316`	`}`
`314`	`317`	`};`
`315`	`318`
`316`		`- Ok(format!("{}({})", qualified_name, parts.join(", ")))`
	`319`	`+ Ok(format!(`
	`320`	`+ "{qualified_name}({parts})",`
	`321`	`+ parts = parts.join(", ")`
	`322`	`+ ))`
`317`	`323`	`} else {`
`318`	`324`	`Ok("...".to_owned())`
`319`	`325`	`}`
Original file line number	Diff line number	Diff line change
`@@ -373,11 +373,10 @@ mod sys {`
`373`	`373`	`let type_name = exc_val.class().name();`
`374`	`374`	`// TODO: fix error message`
`375`	`375`	`let msg = format!(`
`376`		`- "TypeError: print_exception(): Exception expected for value, {} found\n",`
`377`		`- type_name`
	`376`	`+ "TypeError: print_exception(): Exception expected for value, {type_name} found\n"`
`378`	`377`	`);`
`379`	`378`	`use crate::py_io::Write;`
`380`		`- write!(&mut crate::py_io::PyWriter(stderr, vm), "{}", msg)?;`
	`379`	`+ write!(&mut crate::py_io::PyWriter(stderr, vm), "{msg}")?;`
`381`	`380`	`Ok(())`
`382`	`381`	`}`
`383`	`382`	`}`