Fix clippy errors (#5134)

clin1234 · web-flow · commit 283ba3fbf0ce · 2025-05-12T10:05:10.000Z
* Fix clippy errors

* Add news file

* Delete newsfragments/5134.fixed.md
diff --git a/build.rs b/build.rs
@@ -38,7 +38,7 @@ fn configure_pyo3() -> Result<()> {
     ensure_auto_initialize_ok(interpreter_config)?;
 
     for cfg in interpreter_config.build_script_outputs() {
-        println!("{}", cfg)
+        println!("{cfg}")
     }
 
     // Emit cfgs like `invalid_from_utf8_lint`
diff --git a/src/buffer.rs b/src/buffer.rs
@@ -702,7 +702,7 @@ mod tests {
                 buffer.0.suboffsets,
                 buffer.0.internal
             );
-            let debug_repr = format!("{:?}", buffer);
+            let debug_repr = format!("{buffer:?}");
             assert_eq!(debug_repr, expected);
         });
     }
@@ -829,8 +829,7 @@ mod tests {
             assert_eq!(
                 ElementType::from_format(cstr),
                 expected,
-                "element from format &Cstr: {:?}",
-                cstr,
+                "element from format &Cstr: {cstr:?}",
             );
         }
     }
diff --git a/src/conversions/std/array.rs b/src/conversions/std/array.rs
@@ -110,8 +110,7 @@ where
 
 fn invalid_sequence_length(expected: usize, actual: usize) -> PyErr {
     exceptions::PyValueError::new_err(format!(
-        "expected a sequence of length {} (got {})",
-        expected, actual
+        "expected a sequence of length {expected} (got {actual})"
     ))
 }
 
diff --git a/src/conversions/std/ipaddr.rs b/src/conversions/std/ipaddr.rs
@@ -123,7 +123,7 @@ mod test_ipaddr {
                 let pyobj = ip.into_pyobject(py).unwrap();
                 let repr = pyobj.repr().unwrap();
                 let repr = repr.to_string_lossy();
-                assert_eq!(repr, format!("{}('{}')", py_cls, ip));
+                assert_eq!(repr, format!("{py_cls}('{ip}')"));
 
                 let ip2: IpAddr = pyobj.extract().unwrap();
                 assert_eq!(ip, ip2);
diff --git a/src/conversions/std/num.rs b/src/conversions/std/num.rs
@@ -606,7 +606,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: i128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
@@ -622,7 +622,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: NonZeroI128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
@@ -637,7 +637,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: u128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
@@ -653,7 +653,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: NonZeroU128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
diff --git a/src/err/impls.rs b/src/err/impls.rs
@@ -155,7 +155,7 @@ mod tests {
                 let rust_err = io::Error::new(kind, "some error msg");
 
                 let py_err: PyErr = rust_err.into();
-                let py_err_msg = format!("{}: some error msg", expected_ty);
+                let py_err_msg = format!("{expected_ty}: some error msg");
                 assert_eq!(py_err.to_string(), py_err_msg);
                 let py_error_clone = py_err.clone_ref(py);
 
diff --git a/src/err/mod.rs b/src/err/mod.rs
@@ -671,7 +671,7 @@ impl std::fmt::Debug for PyErr {
                             // error, but we can't guarantee that the error
                             // won't have another unformattable traceback inside
                             // it and we want to avoid an infinite recursion.
-                            format!("<unformattable {:?}>", tb)
+                            format!("<unformattable {tb:?}>")
                         }
                     }),
                 )
@@ -685,7 +685,7 @@ impl std::fmt::Display for PyErr {
         Python::with_gil(|py| {
             let value = self.value(py);
             let type_name = value.get_type().qualname().map_err(|_| std::fmt::Error)?;
-            write!(f, "{}", type_name)?;
+            write!(f, "{type_name}")?;
             if let Ok(s) = value.str() {
                 write!(f, ": {}", &s.to_string_lossy())
             } else {
@@ -946,7 +946,7 @@ mod tests {
                 .run(ffi::c_str!("raise Exception('banana')"), None, None)
                 .expect_err("raising should have given us an error");
 
-            let debug_str = format!("{:?}", err);
+            let debug_str = format!("{err:?}");
             assert!(debug_str.starts_with("PyErr { "));
             assert!(debug_str.ends_with(" }"));
 
diff --git a/src/exceptions.rs b/src/exceptions.rs
@@ -996,7 +996,7 @@ mod tests {
                 .into_value(py)
                 .into_bound(py);
             assert_eq!(
-                format!("{:?}", exc),
+                format!("{exc:?}"),
                 exc.repr().unwrap().extract::<String>().unwrap()
             );
         });
@@ -1025,7 +1025,7 @@ mod tests {
         Python::with_gil(|py| {
             let decode_err = PyUnicodeDecodeError::new_utf8(py, invalid_utf8, err).unwrap();
             assert_eq!(
-                format!("{:?}", decode_err),
+                format!("{decode_err:?}"),
                 "UnicodeDecodeError('utf-8', b'fo\\xd8o', 2, 3, 'invalid utf-8')"
             );
 
diff --git a/src/impl_/frompyobject.rs b/src/impl_/frompyobject.rs
@@ -36,7 +36,7 @@ fn extract_traceback(py: Python<'_>, mut error: PyErr) -> String {
 
     let mut error_msg = error.to_string();
     while let Some(cause) = error.cause(py) {
-        write!(&mut error_msg, ", caused by {}", cause).unwrap();
+        write!(&mut error_msg, ", caused by {cause}").unwrap();
         error = cause
     }
     error_msg
@@ -86,8 +86,7 @@ fn failed_to_extract_struct_field(
     field_name: &str,
 ) -> PyErr {
     let new_err = PyTypeError::new_err(format!(
-        "failed to extract field {}.{}",
-        struct_name, field_name
+        "failed to extract field {struct_name}.{field_name}"
     ));
     new_err.set_cause(py, ::std::option::Option::Some(inner_err));
     new_err
@@ -136,8 +135,7 @@ fn failed_to_extract_tuple_struct_field(
     struct_name: &str,
     index: usize,
 ) -> PyErr {
-    let new_err =
-        PyTypeError::new_err(format!("failed to extract field {}.{}", struct_name, index));
+    let new_err = PyTypeError::new_err(format!("failed to extract field {struct_name}.{index}"));
     new_err.set_cause(py, ::std::option::Option::Some(inner_err));
     new_err
 }
diff --git a/src/impl_/pyclass.rs b/src/impl_/pyclass.rs
@@ -1106,8 +1106,7 @@ impl ThreadCheckerImpl {
         assert_eq!(
             thread::current().id(),
             self.0,
-            "{} is unsendable, but sent to another thread",
-            type_name
+            "{type_name} is unsendable, but sent to another thread"
         );
     }
 
@@ -1118,8 +1117,7 @@ impl ThreadCheckerImpl {
     fn can_drop(&self, py: Python<'_>, type_name: &'static str) -> bool {
         if thread::current().id() != self.0 {
             PyRuntimeError::new_err(format!(
-                "{} is unsendable, but is being dropped on another thread",
-                type_name
+                "{type_name} is unsendable, but is being dropped on another thread"
             ))
             .write_unraisable(py, None);
             return false;
diff --git a/src/impl_/pyclass/lazy_type_object.rs b/src/impl_/pyclass/lazy_type_object.rs
@@ -92,7 +92,7 @@ impl LazyTypeObjectInner {
             wrap_in_runtime_error(
                 py,
                 err,
-                format!("An error occurred while initializing class {}", name),
+                format!("An error occurred while initializing class {name}"),
             )
         })
     }
@@ -224,7 +224,7 @@ impl LazyTypeObjectInner {
             return Err(wrap_in_runtime_error(
                 py,
                 err.clone_ref(py),
-                format!("An error occurred while initializing `{}.__dict__`", name),
+                format!("An error occurred while initializing `{name}.__dict__`"),
             ));
         }
 
diff --git a/src/instance.rs b/src/instance.rs
@@ -497,7 +497,7 @@ fn python_format(
     }
 
     match any.get_type().name() {
-        Result::Ok(name) => std::write!(f, "<unprintable {} object>", name),
+        Result::Ok(name) => std::write!(f, "<unprintable {name} object>"),
         Result::Err(_err) => f.write_str("<unprintable object>"),
     }
 }
@@ -2108,15 +2108,15 @@ a = A()
     fn test_debug_fmt() {
         Python::with_gil(|py| {
             let obj = "hello world".into_pyobject(py).unwrap();
-            assert_eq!(format!("{:?}", obj), "'hello world'");
+            assert_eq!(format!("{obj:?}"), "'hello world'");
         });
     }
 
     #[test]
     fn test_display_fmt() {
         Python::with_gil(|py| {
             let obj = "hello world".into_pyobject(py).unwrap();
-            assert_eq!(format!("{}", obj), "hello world");
+            assert_eq!(format!("{obj}"), "hello world");
         });
     }
 
diff --git a/src/pyclass/create_type_object.rs b/src/pyclass/create_type_object.rs
@@ -451,8 +451,7 @@ impl PyTypeBuilder {
 
         if self.has_clear && !self.has_traverse {
             return Err(PyTypeError::new_err(format!(
-                "`#[pyclass]` {} implements __clear__ without __traverse__",
-                name
+                "`#[pyclass]` {name} implements __clear__ without __traverse__"
             )));
         }
 
@@ -562,8 +561,7 @@ unsafe extern "C" fn no_constructor_defined(
                 .name()
                 .map_or_else(|_| "<unknown>".into(), |name| name.to_string());
             Err(crate::exceptions::PyTypeError::new_err(format!(
-                "No constructor defined for {}",
-                name
+                "No constructor defined for {name}"
             )))
         })
     }
diff --git a/src/types/num.rs b/src/types/num.rs
@@ -139,13 +139,13 @@ mod tests {
     fn test_display_int() {
         Python::with_gil(|py| {
             let s = PyInt::new(py, 42u8);
-            assert_eq!(format!("{}", s), "42");
+            assert_eq!(format!("{s}"), "42");
 
             let s = PyInt::new(py, 43i32);
-            assert_eq!(format!("{}", s), "43");
+            assert_eq!(format!("{s}"), "43");
 
             let s = PyInt::new(py, 44usize);
-            assert_eq!(format!("{}", s), "44");
+            assert_eq!(format!("{s}"), "44");
         })
     }
 }
diff --git a/src/types/string.rs b/src/types/string.rs
@@ -609,15 +609,15 @@ mod tests {
     fn test_debug_string() {
         Python::with_gil(|py| {
             let s = "Hello\n".into_pyobject(py).unwrap();
-            assert_eq!(format!("{:?}", s), "'Hello\\n'");
+            assert_eq!(format!("{s:?}"), "'Hello\\n'");
         })
     }
 
     #[test]
     fn test_display_string() {
         Python::with_gil(|py| {
             let s = "Hello\n".into_pyobject(py).unwrap();
-            assert_eq!(format!("{}", s), "Hello\n");
+            assert_eq!(format!("{s}"), "Hello\n");
         })
     }
 
diff --git a/src/types/weakref/proxy.rs b/src/types/weakref/proxy.rs
@@ -265,7 +265,7 @@ mod tests {
                     #[cfg(not(Py_LIMITED_API))]
                     assert_eq!(
                         reference.get_type().to_string(),
-                        format!("<class {}>", CLASS_NAME)
+                        format!("<class {CLASS_NAME}>")
                     );
 
                     assert_eq!(reference.getattr("__class__")?.to_string(), "<class 'A'>");
@@ -282,7 +282,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
@@ -306,7 +306,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
@@ -440,7 +440,7 @@ mod tests {
                     #[cfg(not(Py_LIMITED_API))]
                     assert_eq!(
                         reference.get_type().to_string(),
-                        format!("<class {}>", CLASS_NAME)
+                        format!("<class {CLASS_NAME}>")
                     );
 
                     assert_eq!(
@@ -460,7 +460,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
@@ -484,7 +484,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
diff --git a/tests/test_arithmetics.rs b/tests/test_arithmetics.rs
diff --git a/tests/test_class_formatting.rs b/tests/test_class_formatting.rs
diff --git a/tests/test_datetime.rs b/tests/test_datetime.rs
diff --git a/tests/test_frompyobject.rs b/tests/test_frompyobject.rs
diff --git a/tests/test_methods.rs b/tests/test_methods.rs
diff --git a/tests/test_pyerr_debug_unformattable.rs b/tests/test_pyerr_debug_unformattable.rs
diff --git a/tests/test_pyfunction.rs b/tests/test_pyfunction.rs

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ fn configure_pyo3() -> Result<()> {`
`38`	`38`	`ensure_auto_initialize_ok(interpreter_config)?;`
`39`	`39`
`40`	`40`	`for cfg in interpreter_config.build_script_outputs() {`
`41`		`- println!("{}", cfg)`
	`41`	`+ println!("{cfg}")`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	// Emit cfgs like `invalid_from_utf8_lint`
Original file line number	Diff line number	Diff line change
`@@ -702,7 +702,7 @@ mod tests {`
`702`	`702`	`buffer.0.suboffsets,`
`703`	`703`	`buffer.0.internal`
`704`	`704`	`);`
`705`		`- let debug_repr = format!("{:?}", buffer);`
	`705`	`+ let debug_repr = format!("{buffer:?}");`
`706`	`706`	`assert_eq!(debug_repr, expected);`
`707`	`707`	`});`
`708`	`708`	`}`
`@@ -829,8 +829,7 @@ mod tests {`
`829`	`829`	`assert_eq!(`
`830`	`830`	`ElementType::from_format(cstr),`
`831`	`831`	`expected,`
`832`		`- "element from format &Cstr: {:?}",`
`833`		`- cstr,`
	`832`	`+ "element from format &Cstr: {cstr:?}",`
`834`	`833`	`);`
`835`	`834`	`}`
`836`	`835`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,8 +110,7 @@ where`
`110`	`110`
`111`	`111`	`fn invalid_sequence_length(expected: usize, actual: usize) -> PyErr {`
`112`	`112`	`exceptions::PyValueError::new_err(format!(`
`113`		`- "expected a sequence of length {} (got {})",`
`114`		`- expected, actual`
	`113`	`+ "expected a sequence of length {expected} (got {actual})"`
`115`	`114`	`))`
`116`	`115`	`}`
`117`	`116`