Merge pull request #1416 from dbus2/clippy-fixes

zeenix · web-flow · commit 02563f5a9919 · 2025-06-30T13:46:39.000+02:00
🚨 all: Fix against latest clippy
diff --git a/zbus/examples/screen-brightness.rs b/zbus/examples/screen-brightness.rs
@@ -16,7 +16,7 @@ fn main() {
             } else if s == "-" {
                 "StepDown"
             } else {
-                panic!("Expected either '+' or '-' argument. Got: {}", s);
+                panic!("Expected either '+' or '-' argument. Got: {s}");
             }
         }
         None => "StepUp",
diff --git a/zbus/src/address/mod.rs b/zbus/src/address/mod.rs
@@ -114,7 +114,7 @@ impl Display for Address {
         self.transport.fmt(f)?;
 
         if let Some(guid) = &self.guid {
-            write!(f, ",guid={}", guid)?;
+            write!(f, ",guid={guid}")?;
         }
 
         Ok(())
diff --git a/zbus/src/address/transport/autolaunch.rs b/zbus/src/address/transport/autolaunch.rs
@@ -11,7 +11,7 @@ impl std::fmt::Display for Autolaunch {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "autolaunch:")?;
         if let Some(scope) = &self.scope {
-            write!(f, "scope={}", scope)?;
+            write!(f, "scope={scope}")?;
         }
 
         Ok(())
diff --git a/zbus/src/address/transport/launchd.rs b/zbus/src/address/transport/launchd.rs
@@ -36,7 +36,7 @@ impl Launchd {
         }
 
         let addr = String::from_utf8(output.stdout).map_err(|e| {
-            crate::Error::Address(format!("Unable to parse launchctl output as UTF-8: {}", e))
+            crate::Error::Address(format!("Unable to parse launchctl output as UTF-8: {e}"))
         })?;
 
         Ok(Transport::Unix(Unix::new(UnixSocket::File(
diff --git a/zbus/src/address/transport/mod.rs b/zbus/src/address/transport/mod.rs
@@ -351,19 +351,19 @@ pub(super) fn encode_percents(f: &mut Formatter<'_>, mut value: &[u8]) -> std::f
 impl Display for Transport {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Tcp(tcp) => write!(f, "{}", tcp)?,
-            Self::Unix(unix) => write!(f, "{}", unix)?,
+            Self::Tcp(tcp) => write!(f, "{tcp}")?,
+            Self::Unix(unix) => write!(f, "{unix}")?,
             #[cfg(unix)]
-            Self::Unixexec(unixexec) => write!(f, "{}", unixexec)?,
+            Self::Unixexec(unixexec) => write!(f, "{unixexec}")?,
             #[cfg(any(
                 all(feature = "vsock", not(feature = "tokio")),
                 feature = "tokio-vsock"
             ))]
             Self::Vsock(vsock) => write!(f, "{}", vsock)?,
             #[cfg(windows)]
-            Self::Autolaunch(autolaunch) => write!(f, "{}", autolaunch)?,
+            Self::Autolaunch(autolaunch) => write!(f, "{autolaunch}")?,
             #[cfg(target_os = "macos")]
-            Self::Launchd(launchd) => write!(f, "{}", launchd)?,
+            Self::Launchd(launchd) => write!(f, "{launchd}")?,
         }
 
         Ok(())
diff --git a/zbus/src/connection/handshake/client.rs b/zbus/src/connection/handshake/client.rs
@@ -58,7 +58,7 @@ impl Client {
         let write = self.common.socket_mut().write_mut();
 
         let written = match write.send_zero_byte().await.map_err(|e| {
-            Error::Handshake(format!("Could not send zero byte with credentials: {}", e))
+            Error::Handshake(format!("Could not send zero byte with credentials: {e}"))
         })? {
             // This likely means that the socket type is unable to send SCM_CREDS.
             // Let's try to send the 0 byte as a regular message.
diff --git a/zbus/src/error.rs b/zbus/src/error.rs
@@ -145,7 +145,7 @@ impl fmt::Display for Error {
             Error::InvalidMatchRule => write!(f, "Invalid match rule string"),
             Error::Failure(e) => write!(f, "{e}"),
             Error::MissingParameter(p) => {
-                write!(f, "Parameter `{}` was not specified but it is required", p)
+                write!(f, "Parameter `{p}` was not specified but it is required")
             }
             Error::InvalidSerial => write!(f, "Serial number in the message header is 0"),
             Error::InterfaceExists(i, p) => write!(f, "Interface `{i}` already exists at `{p}`"),
diff --git a/zbus/src/win32.rs b/zbus/src/win32.rs
@@ -54,7 +54,7 @@ impl Mutex {
     pub fn lock(&self) -> MutexGuard<'_> {
         match unsafe { WaitForSingleObject(self.0.as_raw_handle(), INFINITE) } {
             WAIT_ABANDONED | WAIT_OBJECT_0 => MutexGuard(self),
-            err => panic!("WaitForSingleObject() failed: return code {}", err),
+            err => panic!("WaitForSingleObject() failed: return code {err}"),
         }
     }
 }
@@ -311,7 +311,7 @@ pub fn autolaunch_bus_address() -> Result<Address, crate::Error> {
 
     let addr = read_shm("DBusDaemonAddressInfo")?;
     let addr = String::from_utf8(addr)
-        .map_err(|e| crate::Error::Address(format!("Unable to parse address as UTF-8: {}", e)))?;
+        .map_err(|e| crate::Error::Address(format!("Unable to parse address as UTF-8: {e}")))?;
 
     addr.parse()
 }
diff --git a/zbus_macros/src/utils.rs b/zbus_macros/src/utils.rs
@@ -74,7 +74,7 @@ impl Display for PropertyEmitsChangedSignal {
             PropertyEmitsChangedSignal::False => "false",
             PropertyEmitsChangedSignal::Invalidates => "invalidates",
         };
-        write!(f, "{}", emits_changed_signal)
+        write!(f, "{emits_changed_signal}")
     }
 }
 
diff --git a/zbus_xmlgen/src/lib.rs b/zbus_xmlgen/src/lib.rs
@@ -39,13 +39,13 @@ pub fn write_interfaces(
             format: false,
         };
 
-        write!(unformatted, "{}", gen)?;
+        write!(unformatted, "{gen}")?;
     }
 
     let formatted = match format_generated_code(&unformatted) {
         Ok(formatted) => formatted,
         Err(e) => {
-            eprintln!("Failed to format generated code: {}", e);
+            eprintln!("Failed to format generated code: {e}");
             unformatted
         }
     };
@@ -86,16 +86,15 @@ fn write_doc_header<W: std::fmt::Write>(
     write!(
         w,
         "//!
-         //! This code was generated by `{}` `{}` from D-Bus introspection data.
-         //! Source: `{}`.
+         //! This code was generated by `{cargo_bin_name}` `{cargo_bin_version}` from D-Bus introspection data.
+         //! Source: `{input_src}`.
          //!
          //! You may prefer to adapt it, instead of using it verbatim.
          //!
          //! More information can be found in the [Writing a client proxy] section of the zbus
          //! documentation.
          //!
         ",
-        cargo_bin_name, cargo_bin_version, input_src,
     )?;
 
     if !standard_interfaces.is_empty() {
@@ -112,9 +111,8 @@ fn write_doc_header<W: std::fmt::Write>(
         write!(
             w,
             "//!
-             //! Consequently `{}` did not generate code for the above interfaces.
+             //! Consequently `{cargo_bin_name}` did not generate code for the above interfaces.
             ",
-            cargo_bin_name,
         )?;
     }
 
@@ -145,7 +143,7 @@ impl Display for GenTrait<'_> {
 
             let formatted = format_generated_code(&unformatted).unwrap_or(unformatted);
 
-            write!(f, "{}", formatted)
+            write!(f, "{formatted}")
         } else {
             self.write_interface(f)
         }
@@ -213,14 +211,14 @@ impl GenTrait<'_> {
             writeln!(w)?;
             writeln!(w, "    /// {} property", p.name())?;
             if p.access().read() {
-                writeln!(w, "{}", fn_attribute)?;
+                writeln!(w, "{fn_attribute}")?;
                 let output = to_rust_type(p.ty(), false, false);
                 hide_clippy_type_complexity_lint(w, p.ty())?;
                 writeln!(w, "    fn {name}(&self) -> zbus::Result<{output}>;",)?;
             }
 
             if p.access().write() {
-                writeln!(w, "{}", fn_attribute)?;
+                writeln!(w, "{fn_attribute}")?;
                 let input = to_rust_type(p.ty(), true, true);
                 writeln!(
                     w,
@@ -363,16 +361,16 @@ fn to_rust_type(ty: &Signature, input: bool, as_ref: bool) -> String {
             Signature::Array(child) => {
                 let child_ty = signature_to_rust_type(child, input, as_ref);
                 if input && as_ref {
-                    format!("&[{}]", child_ty)
+                    format!("&[{child_ty}]")
                 } else {
-                    format!("Vec<{}>", child_ty)
+                    format!("Vec<{child_ty}>")
                 }
             }
             Signature::Dict { key, value } => {
                 let key_ty = signature_to_rust_type(key, input, as_ref);
                 let value_ty = signature_to_rust_type(value, input, as_ref);
 
-                format!("std::collections::HashMap<{}, {}>", key_ty, value_ty)
+                format!("std::collections::HashMap<{key_ty}, {value_ty}>")
             }
             Signature::Structure(fields) => {
                 let fields = fields
diff --git a/zbus_xmlgen/src/main.rs b/zbus_xmlgen/src/main.rs
@@ -90,10 +90,10 @@ fn main() -> Result<(), Box<dyn Error>> {
 
         let interface_name = interface.name();
         match output_target {
-            OutputTarget::Stdout => println!("{}", output),
+            OutputTarget::Stdout => println!("{output}"),
             OutputTarget::SingleFile(ref mut file) => {
                 file.write_all(output.as_bytes())?;
-                println!("Generated code for `{}`", interface_name);
+                println!("Generated code for `{interface_name}`");
             }
             OutputTarget::MultipleFiles => {
                 let filename = interface_name
@@ -102,7 +102,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                     .expect("Failed to split name");
                 let filename = to_snakecase(filename);
                 std::fs::write(format!("{}.rs", &filename), output)?;
-                println!("Generated code for `{}` in {}.rs", interface_name, filename);
+                println!("Generated code for `{interface_name}` in {filename}.rs");
             }
         };
     }
@@ -126,10 +126,7 @@ impl DBusInfo<'_> {
         let service: BusName<'_> = service.try_into()?;
         let path: ObjectPath<'_> = object_path.try_into()?;
 
-        let input_src = format!(
-            "Interface '{}' from service '{}' on system bus",
-            path, service,
-        );
+        let input_src = format!("Interface '{path}' from service '{service}' on system bus",);
 
         let xml = IntrospectableProxy::builder(&connection)
             .destination(service.clone())
diff --git a/zvariant/src/utils.rs b/zvariant/src/utils.rs
@@ -65,17 +65,13 @@ pub fn padding_for_n_bytes(value: usize, align: usize) -> usize {
 }
 
 pub(crate) fn usize_to_u32(value: usize) -> u32 {
-    assert!(
-        value <= (u32::MAX as usize),
-        "{} too large for `u32`",
-        value,
-    );
+    assert!(value <= (u32::MAX as usize), "{value} too large for `u32`",);
 
     value as u32
 }
 
 pub(crate) fn usize_to_u8(value: usize) -> u8 {
-    assert!(value <= (u8::MAX as usize), "{} too large for `u8`", value,);
+    assert!(value <= (u8::MAX as usize), "{value} too large for `u8`",);
 
     value as u8
 }
diff --git a/zvariant/src/value.rs b/zvariant/src/value.rs
@@ -486,51 +486,51 @@ pub(crate) fn value_display_fmt(
             if type_annotate {
                 f.write_str("byte ")?;
             }
-            write!(f, "0x{:02x}", num)
+            write!(f, "0x{num:02x}")
         }
         Value::Bool(boolean) => {
-            write!(f, "{}", boolean)
+            write!(f, "{boolean}")
         }
         Value::I16(num) => {
             if type_annotate {
                 f.write_str("int16 ")?;
             }
-            write!(f, "{}", num)
+            write!(f, "{num}")
         }
         Value::U16(num) => {
             if type_annotate {
                 f.write_str("uint16 ")?;
             }
-            write!(f, "{}", num)
+            write!(f, "{num}")
         }
         Value::I32(num) => {
             // Never annotate this type because it is the default for numbers
-            write!(f, "{}", num)
+            write!(f, "{num}")
         }
         Value::U32(num) => {
             if type_annotate {
                 f.write_str("uint32 ")?;
             }
-            write!(f, "{}", num)
+            write!(f, "{num}")
         }
         Value::I64(num) => {
             if type_annotate {
                 f.write_str("int64 ")?;
             }
-            write!(f, "{}", num)
+            write!(f, "{num}")
         }
         Value::U64(num) => {
             if type_annotate {
                 f.write_str("uint64 ")?;
             }
-            write!(f, "{}", num)
+            write!(f, "{num}")
         }
         Value::F64(num) => {
             if num.fract() == 0. {
                 // Add a dot to make it clear that this is a float
-                write!(f, "{}.", num)
+                write!(f, "{num}.")
             } else {
-                write!(f, "{}", num)
+                write!(f, "{num}")
             }
         }
         Value::Str(string) => {
@@ -568,7 +568,7 @@ pub(crate) fn value_display_fmt(
             if type_annotate {
                 f.write_str("handle ")?;
             }
-            write!(f, "{}", handle)
+            write!(f, "{handle}")
         }
     }
 }
diff --git a/zvariant/tests/dict_value.rs b/zvariant/tests/dict_value.rs
@@ -212,7 +212,7 @@ fn dict_value() {
     }
     let decoded: TestParseUnknown<'_> = encoded.deserialize().unwrap().0;
     assert_eq!(decoded.rest.len(), 1);
-    assert_eq!(decoded.rest["user"], Value::new("me").try_into().unwrap());
+    assert_eq!(decoded.rest["user"], Value::new("me"));
 
     #[cfg(feature = "gvariant")]
     {
diff --git a/zvariant_derive/src/dict.rs b/zvariant_derive/src/dict.rs
@@ -34,7 +34,7 @@ pub fn expand_serialize_derive(input: DeriveInput) -> Result<TokenStream, Error>
             let is_opt = macros::ty_is_option(ty);
             if is_opt {
                 let as_value_opt_path = quote! { #zv::as_value::optional };
-                let as_value_opt_str = format!("{}", as_value_opt_path);
+                let as_value_opt_str = format!("{as_value_opt_path}");
                 field_defs.push(quote! {
                     #[serde(
                         rename = #dict_name,
@@ -45,7 +45,7 @@ pub fn expand_serialize_derive(input: DeriveInput) -> Result<TokenStream, Error>
                 });
             } else {
                 let as_value_path = quote! { #zv::as_value };
-                let as_value_str = format!("{}", as_value_path);
+                let as_value_str = format!("{as_value_path}");
                 field_defs.push(quote! {
                     #[serde(rename = #dict_name, with = #as_value_str)]
                     #ident: &'a #ty
@@ -125,7 +125,7 @@ pub fn expand_deserialize_derive(input: DeriveInput) -> Result<TokenStream, Erro
 
             if is_opt {
                 let as_value_opt_path = quote! { #zv::as_value::optional };
-                let as_value_opt_str = format!("{}", as_value_opt_path);
+                let as_value_opt_str = format!("{as_value_opt_path}");
                 field_defs.push(quote! {
                     #[serde(rename = #dict_name, with = #as_value_opt_str, default)]
                     #ident: #ty
@@ -134,7 +134,7 @@ pub fn expand_deserialize_derive(input: DeriveInput) -> Result<TokenStream, Erro
             } else {
                 // For non-optional fields, use Option<T> in helper for default support
                 let as_value_opt_path = quote! { #zv::as_value::optional };
-                let as_value_opt_str = format!("{}", as_value_opt_path);
+                let as_value_opt_str = format!("{as_value_opt_path}");
                 field_defs.push(quote! {
                     #[serde(rename = #dict_name, with = #as_value_opt_str, default)]
                     #ident: Option<#ty>
diff --git a/zvariant_utils/src/signature/mod.rs b/zvariant_utils/src/signature/mod.rs
@@ -357,7 +357,7 @@ impl Signature {
                     write!(w, "(")?;
                 }
                 for field in fields.iter() {
-                    write!(w, "{}", field)?;
+                    write!(w, "{field}")?;
                 }
                 if outer_parens {
                     write!(w, ")")?;

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ fn main() {`
`16`	`16`	`} else if s == "-" {`
`17`	`17`	`"StepDown"`
`18`	`18`	`} else {`
`19`		`- panic!("Expected either '+' or '-' argument. Got: {}", s);`
	`19`	`+ panic!("Expected either '+' or '-' argument. Got: {s}");`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`	`None => "StepUp",`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ impl Display for Address {`
`114`	`114`	`self.transport.fmt(f)?;`
`115`	`115`
`116`	`116`	`if let Some(guid) = &self.guid {`
`117`		`- write!(f, ",guid={}", guid)?;`
	`117`	`+ write!(f, ",guid={guid}")?;`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ impl std::fmt::Display for Autolaunch {`
`11`	`11`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`12`	`12`	`write!(f, "autolaunch:")?;`
`13`	`13`	`if let Some(scope) = &self.scope {`
`14`		`- write!(f, "scope={}", scope)?;`
	`14`	`+ write!(f, "scope={scope}")?;`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ impl Launchd {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`let addr = String::from_utf8(output.stdout).map_err(\|e\| {`
`39`		`- crate::Error::Address(format!("Unable to parse launchctl output as UTF-8: {}", e))`
	`39`	`+ crate::Error::Address(format!("Unable to parse launchctl output as UTF-8: {e}"))`
`40`	`40`	`})?;`
`41`	`41`
`42`	`42`	`Ok(Transport::Unix(Unix::new(UnixSocket::File(`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ impl fmt::Display for Error {`
`145`	`145`	`Error::InvalidMatchRule => write!(f, "Invalid match rule string"),`
`146`	`146`	`Error::Failure(e) => write!(f, "{e}"),`
`147`	`147`	`Error::MissingParameter(p) => {`
`148`		- write!(f, "Parameter `{}` was not specified but it is required", p)
	`148`	+ write!(f, "Parameter `{p}` was not specified but it is required")
`149`	`149`	`}`
`150`	`150`	`Error::InvalidSerial => write!(f, "Serial number in the message header is 0"),`
`151`	`151`	Error::InterfaceExists(i, p) => write!(f, "Interface `{i}` already exists at `{p}`"),
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ impl Mutex {`
`54`	`54`	`pub fn lock(&self) -> MutexGuard<'_> {`
`55`	`55`	`match unsafe { WaitForSingleObject(self.0.as_raw_handle(), INFINITE) } {`
`56`	`56`	`WAIT_ABANDONED \| WAIT_OBJECT_0 => MutexGuard(self),`
`57`		`- err => panic!("WaitForSingleObject() failed: return code {}", err),`
	`57`	`+ err => panic!("WaitForSingleObject() failed: return code {err}"),`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`}`
`@@ -311,7 +311,7 @@ pub fn autolaunch_bus_address() -> Result<Address, crate::Error> {`
`311`	`311`
`312`	`312`	`let addr = read_shm("DBusDaemonAddressInfo")?;`
`313`	`313`	`let addr = String::from_utf8(addr)`
`314`		`- .map_err(\|e\| crate::Error::Address(format!("Unable to parse address as UTF-8: {}", e)))?;`
	`314`	`+ .map_err(\|e\| crate::Error::Address(format!("Unable to parse address as UTF-8: {e}")))?;`
`315`	`315`
`316`	`316`	`addr.parse()`
`317`	`317`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ impl Display for PropertyEmitsChangedSignal {`
`74`	`74`	`PropertyEmitsChangedSignal::False => "false",`
`75`	`75`	`PropertyEmitsChangedSignal::Invalidates => "invalidates",`
`76`	`76`	`};`
`77`		`- write!(f, "{}", emits_changed_signal)`
	`77`	`+ write!(f, "{emits_changed_signal}")`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`