Fix clippy::uninlined_format_args (#1858)

Author: newpavlov

.github/workflows/workspace.yml

@@ -24,7 +24,7 @@ jobs:
       - uses: RustCrypto/actions/cargo-cache@master
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.85.0
+          toolchain: 1.87.0
           components: clippy
       - run: cargo clippy --all --all-features --tests -- -D warnings
 

password-hash/src/errors.rs

@@ -72,31 +72,28 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> core::result::Result<(), fmt::Error> {
         match self {
             Self::Algorithm => write!(f, "unsupported algorithm"),
-            Self::B64Encoding(err) => write!(f, "{}", err),
+            Self::B64Encoding(err) => write!(f, "{err}"),
             Self::Crypto => write!(f, "cryptographic error"),
             Self::OutputSize { provided, expected } => match provided {
                 Ordering::Less => write!(
                     f,
-                    "output size too short, expected at least {} bytes",
-                    expected
-                ),
-                Ordering::Equal => write!(f, "output size unexpected, expected {} bytes", expected),
-                Ordering::Greater => write!(
-                    f,
-                    "output size too long, expected at most {} bytes",
-                    expected
+                    "output size too short, expected at least {expected} bytes",
                 ),
+                Ordering::Equal => write!(f, "output size unexpected, expected {expected} bytes"),
+                Ordering::Greater => {
+                    write!(f, "output size too long, expected at most {expected} bytes")
+                }
             },
             Self::ParamNameDuplicated => f.write_str("duplicate parameter"),
             Self::ParamNameInvalid => f.write_str("invalid parameter name"),
-            Self::ParamValueInvalid(val_err) => write!(f, "invalid parameter value: {}", val_err),
+            Self::ParamValueInvalid(val_err) => write!(f, "invalid parameter value: {val_err}"),
             Self::ParamsMaxExceeded => f.write_str("maximum number of parameters reached"),
             Self::Password => write!(f, "invalid password"),
             Self::PhcStringField => write!(f, "password hash string missing field"),
             Self::PhcStringTrailingData => {
                 write!(f, "password hash string contains trailing characters")
             }
-            Self::SaltInvalid(val_err) => write!(f, "salt invalid: {}", val_err),
+            Self::SaltInvalid(val_err) => write!(f, "salt invalid: {val_err}"),
             Self::Version => write!(f, "invalid algorithm version"),
             Self::OutOfMemory => write!(f, "out of memory"),
         }
@@ -161,7 +158,7 @@ impl InvalidValue {
 impl fmt::Display for InvalidValue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> core::result::Result<(), fmt::Error> {
         match self {
-            Self::InvalidChar(c) => write!(f, "contains invalid character: '{}'", c),
+            Self::InvalidChar(c) => write!(f, "contains invalid character: '{c}'"),
             Self::InvalidFormat => f.write_str("value format is invalid"),
             Self::Malformed => f.write_str("value malformed"),
             Self::TooLong => f.write_str("value to long"),

password-hash/src/lib.rs

@@ -253,18 +253,18 @@ impl fmt::Display for PasswordHash<'_> {
         write!(f, "{}{}", PASSWORD_HASH_SEPARATOR, self.algorithm)?;
 
         if let Some(version) = self.version {
-            write!(f, "{}v={}", PASSWORD_HASH_SEPARATOR, version)?;
+            write!(f, "{PASSWORD_HASH_SEPARATOR}v={version}")?;
         }
 
         if !self.params.is_empty() {
             write!(f, "{}{}", PASSWORD_HASH_SEPARATOR, self.params)?;
         }
 
         if let Some(salt) = &self.salt {
-            write!(f, "{}{}", PASSWORD_HASH_SEPARATOR, salt)?;
+            write!(f, "{PASSWORD_HASH_SEPARATOR}{salt}")?;
 
             if let Some(hash) = &self.hash {
-                write!(f, "{}{}", PASSWORD_HASH_SEPARATOR, hash)?;
+                write!(f, "{PASSWORD_HASH_SEPARATOR}{hash}")?;
             }
         }
 

password-hash/src/output.rs

@@ -272,7 +272,7 @@ impl fmt::Display for Output {
 
 impl fmt::Debug for Output {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Output(\"{}\")", self)
+        write!(f, "Output(\"{self}\")")
     }
 }
 

password-hash/src/params.rs

@@ -60,7 +60,7 @@ impl ParamsString {
 
         // Add param name
         let offset = self.0.length;
-        if write!(self.0, "{}=", name).is_err() {
+        if write!(self.0, "{name}=").is_err() {
             self.0.length = offset;
             return Err(Error::ParamsMaxExceeded);
         }
@@ -160,7 +160,7 @@ impl ParamsString {
                 .map_err(|_| Error::ParamsMaxExceeded)?
         }
 
-        if write!(self.0, "{}={}", name, value).is_err() {
+        if write!(self.0, "{name}={value}").is_err() {
             self.0.length = orig_len;
             return Err(Error::ParamsMaxExceeded);
         }

signature/src/error.rs

@@ -61,7 +61,7 @@ impl Debug for Error {
         f.write_str("signature::Error { source: ")?;
 
         if let Some(source) = &self.source {
-            write!(f, "Some({})", source)?;
+            write!(f, "Some({source})")?;
         } else {
             f.write_str("None")?;
         }