Fix compiler and lint warnings/errors

kezhuw · kezhuw · commit d2d483a90bc3 · 2025-07-01T22:57:16.000+08:00
diff --git a/src/acl.rs b/src/acl.rs
@@ -76,7 +76,7 @@ impl std::fmt::Display for Permission {
         .into_iter()
         .filter_map(|(perm, str)| if self.has(perm) { Some(str) } else { None })
         .enumerate()
-        .try_for_each(|(i, str)| if i == 0 { f.write_str(str) } else { write!(f, "|{}", str) })
+        .try_for_each(|(i, str)| if i == 0 { f.write_str(str) } else { write!(f, "|{str}") })
     }
 }
 
diff --git a/src/client/mod.rs b/src/client/mod.rs
@@ -376,14 +376,11 @@ impl Client {
     fn parse_sequence(client_path: &str, prefix: &str) -> Result<CreateSequence> {
         if let Some(sequence_path) = client_path.strip_prefix(prefix) {
             match sequence_path.parse::<i64>() {
-                Err(_) => Err(Error::UnexpectedError(format!("sequential node get no i32 path {}", client_path))),
+                Err(_) => Err(Error::UnexpectedError(format!("sequential node get no i32 path {client_path}"))),
                 Ok(i) => Ok(CreateSequence(i)),
             }
         } else {
-            Err(Error::UnexpectedError(format!(
-                "sequential path {} does not contain prefix path {}",
-                client_path, prefix
-            )))
+            Err(Error::UnexpectedError(format!("sequential path {client_path} does not contain prefix path {prefix}",)))
         }
     }
 
@@ -1049,7 +1046,7 @@ impl Client {
             std::mem::forget(guard);
             let prefix_len = prefix.len();
             let mut path = prefix;
-            write!(&mut path, "{}", sequence).unwrap();
+            write!(&mut path, "{sequence}").unwrap();
             let sequence_len = path.len() - prefix_len;
             return Ok((path, sequence_len));
         }
diff --git a/src/error.rs b/src/error.rs
@@ -101,7 +101,7 @@ impl Display for CustomError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match (self.message.as_ref(), self.source.as_ref()) {
             (Some(message), None) => f.write_str(message),
-            (Some(message), Some(err)) => write!(f, "{}: {}", message, err),
+            (Some(message), Some(err)) => write!(f, "{message}: {err}"),
             (None, Some(err)) => err.fmt(f),
             _ => unreachable!("no error message or source"),
         }
diff --git a/src/proto/acl.rs b/src/proto/acl.rs
@@ -33,7 +33,7 @@ impl TryFrom<i32> for Permission {
     fn try_from(raw: i32) -> Result<Permission, Self::Error> {
         let all_bits = Permission::ALL.into_raw();
         if (raw & !all_bits) != 0 {
-            return Err(InvalidData::UnmarshalError(format!("invalid permission bits: {:#b}", raw)));
+            return Err(InvalidData::UnmarshalError(format!("invalid permission bits: {raw:#b}")));
         }
         Ok(Permission::from_raw(raw))
     }
diff --git a/src/proto/multi.rs b/src/proto/multi.rs
@@ -82,8 +82,7 @@ impl DeserializableRecord<'_> for Vec<MultiReadResponse> {
                 },
                 op => {
                     return Err(DeserializeError::UnmarshalError(format!(
-                        "unexpected op code {} in multi read response",
-                        op
+                        "unexpected op code {op} in multi read response"
                     )))
                 },
             }
@@ -136,8 +135,7 @@ impl<'a> DeserializableRecord<'a> for Vec<MultiWriteResponse<'a>> {
                 },
                 op => {
                     return Err(DeserializeError::UnmarshalError(format!(
-                        "unexpected op code {} in multi write response",
-                        op
+                        "unexpected op code {op} in multi write response",
                     )))
                 },
             }
diff --git a/src/record.rs b/src/record.rs
@@ -42,9 +42,7 @@ impl DeserializeError {
     pub fn with_entity(self, entity: &'static str) -> ZkError {
         match self {
             DeserializeError::InsufficientBuf => ZkError::UnmarshalError { entity, reason: &"insufficient buf" },
-            DeserializeError::UnexpectedOpCode(code) => {
-                ZkError::UnexpectedError(format!("unexpected op code {}", code))
-            },
+            DeserializeError::UnexpectedOpCode(code) => ZkError::UnexpectedError(format!("unexpected op code {code}")),
             DeserializeError::UnexpectedErrorCode(code) => ZkError::UnexpectedErrorCode(code),
             DeserializeError::UnmarshalError(err) => ZkError::UnexpectedError(err),
         }
@@ -284,7 +282,7 @@ impl UnsafeRead<'_> for bool {
         match buf.get_unchecked_u8() {
             0 => Ok(false),
             1 => Ok(true),
-            u => Err(InvalidData::UnmarshalError(format!("invalid value {} for bool", u))),
+            u => Err(InvalidData::UnmarshalError(format!("invalid value {u} for bool"))),
         }
     }
 }
diff --git a/src/sasl/mechanisms/digest_md5.rs b/src/sasl/mechanisms/digest_md5.rs
@@ -83,7 +83,7 @@ impl<'a> Parser<'a> {
     pub fn new(challenge: &'a [u8]) -> Result<Self, DigestError> {
         let challenge = match std::str::from_utf8(challenge) {
             Ok(s) => s,
-            Err(err) => return Err(DigestError::new_parse(format!("support only utf8 for now: {}", err))),
+            Err(err) => return Err(DigestError::new_parse(format!("support only utf8 for now: {err}"))),
         };
         Ok(Self { s: challenge })
     }
@@ -94,7 +94,7 @@ impl<'a> Parser<'a> {
         };
         self.skip_assignment();
         let Some((value, kind)) = self.read_value()? else {
-            return Err(DigestError::new_parse(format!("directive {} has no value", key)));
+            return Err(DigestError::new_parse(format!("directive {key} has no value")));
         };
         Ok(Some(Directive { key, value, kind }))
     }
@@ -116,7 +116,7 @@ impl<'a> Parser<'a> {
         self.skip_lws();
         if key.is_empty() {
             if !self.s.is_empty() {
-                return Err(DigestError::new_parse(format!("no valid key from {}", s)));
+                return Err(DigestError::new_parse(format!("no valid key from {s}")));
             }
             return Ok(None);
         }
@@ -377,7 +377,7 @@ impl DigestSession {
     fn gen_nonce() -> [u8; 32] {
         let r = fastrand::u128(0..u128::MAX);
         let mut buf = [0; 32];
-        write!(buf.as_mut_slice(), "{:x}", r).unwrap();
+        write!(buf.as_mut_slice(), "{r:x}").unwrap();
         buf
     }
 }
@@ -397,21 +397,21 @@ impl Authentication for DigestSession {
                     None => return Err(DigestError::new_parse("no charset").into()),
                     Some("utf-8") => true,
                     Some(charset) => {
-                        return Err(DigestError::new_parse(format!("expect charset utf-8, but got {}", charset)).into())
+                        return Err(DigestError::new_parse(format!("expect charset utf-8, but got {charset}")).into())
                     },
                 };
                 match directives.get_algorithm() {
                     None => return Err(DigestError::new_parse("no algorithm").into()),
                     Some("md5-sess") => {},
                     Some(algorithm) => {
                         return Err(
-                            DigestError::new_parse(format!("expect algorithm md5-sess, but got {}", algorithm)).into()
+                            DigestError::new_parse(format!("expect algorithm md5-sess, but got {algorithm}")).into()
                         )
                     },
                 };
                 if let Some(qop) = directives.get_qop() {
                     if !qop.split(',').any(|s| s == "auth") {
-                        return Err(DigestError::new_protocol(format!("unsupported qop {}", qop)).into());
+                        return Err(DigestError::new_protocol(format!("unsupported qop {qop}")).into());
                     }
                 };
                 let Some(nonce) = directives.get_nonce() else {
@@ -430,13 +430,12 @@ impl Authentication for DigestSession {
                         *realm
                     } else {
                         return Err(DigestError::new_protocol(format!(
-                            "can not choose realm {} from {:?}",
-                            client_realm, realms
+                            "can not choose realm {client_realm} from {realms:?}",
                         ))
                         .into());
                     }
                 } else {
-                    return Err(DigestError::new_protocol(format!("choose no realm from {:?}", realms)).into());
+                    return Err(DigestError::new_protocol(format!("choose no realm from {realms:?}")).into());
                 };
                 let username = session.need_with::<AuthId, _, _>(&EmptyProvider, |auth_id| Ok(auth_id.to_string()))?;
                 let password =
@@ -451,8 +450,7 @@ impl Authentication for DigestSession {
                 };
                 let response = context.client_response();
                 write!(writer,
-                    r#"username="{}",realm="{}",nonce="{}",cnonce="{}",nc=00000001,qop=auth,digest-uri="zookeeper/zk-sasl-md5",response={},charset="utf-8""#,
-                    username, realm, nonce,
+                    r#"username="{username}",realm="{realm}",nonce="{nonce}",cnonce="{}",nc=00000001,qop=auth,digest-uri="zookeeper/zk-sasl-md5",response={},charset="utf-8""#,
                     unsafe { std::str::from_utf8_unchecked(cnonce.as_slice()) },
                     unsafe { std::str::from_utf8_unchecked(response.as_slice()) },
                 ).unwrap();
diff --git a/src/session/connection.rs b/src/session/connection.rs
@@ -32,7 +32,7 @@ use crate::endpoint::{EndpointRef, IterableEndpoints};
 pub enum Connection {
     Raw(TcpStream),
     #[cfg(feature = "tls")]
-    Tls(TlsStream<TcpStream>),
+    Tls(Box<TlsStream<TcpStream>>),
 }
 
 pub trait AsyncReadToBuf: AsyncReadExt {
@@ -143,7 +143,7 @@ impl Connection {
 
     #[cfg(feature = "tls")]
     pub fn new_tls(stream: TlsStream<TcpStream>) -> Self {
-        Self::Tls(stream)
+        Self::Tls(stream.into())
     }
 
     pub async fn command(mut self, cmd: &str) -> Result<String> {
diff --git a/src/session/depot.rs b/src/session/depot.rs
@@ -101,7 +101,7 @@ impl Depot {
 
     pub fn pop_request(&mut self, xid: i32) -> Result<SessionOperation, Error> {
         match self.written_operations.remove(&xid) {
-            None => Err(Error::UnexpectedError(format!("recv response with xid {} but no pending request", xid))),
+            None => Err(Error::UnexpectedError(format!("recv response with xid {xid} but no pending request"))),
             Some(operation) => Ok(operation),
         }
     }
diff --git a/src/session/mod.rs b/src/session/mod.rs
@@ -563,7 +563,7 @@ impl Session {
             select! {
                 Some(endpoint) = Self::poll(&mut seek_for_writable), if seek_for_writable.is_some() => {
                     seek_for_writable = None;
-                    err = Some(Error::with_message(format!("encounter writable server {}", endpoint)));
+                    err = Some(Error::with_message(format!("encounter writable server {endpoint}")));
                     channel_halted = true;
                 },
                 r = reader.read_to_buf(buf) => match r.map_err(Error::other)? {
diff --git a/src/session/request.rs b/src/session/request.rs
@@ -204,7 +204,7 @@ impl Future for StateReceiver {
             Poll::Pending => Poll::Pending,
             Poll::Ready(result) => match result {
                 Err(_) => {
-                    Poll::Ready(Err(Error::UnexpectedError(format!("BUG: {} expect response, but got none", code))))
+                    Poll::Ready(Err(Error::UnexpectedError(format!("BUG: {code} expect response, but got none"))))
                 },
                 Ok(r) => Poll::Ready(r),
             },
diff --git a/src/session/types.rs b/src/session/types.rs
@@ -88,7 +88,7 @@ impl SessionState {
     pub(crate) fn from_server(state: i32) -> Result<SessionState, Error> {
         let session_state = match state {
             3 => SessionState::SyncConnected,
-            _ => return Err(Error::UnexpectedError(format!("keeper state value should not be {}", state))),
+            _ => return Err(Error::UnexpectedError(format!("keeper state value should not be {state}"))),
         };
         Ok(session_state)
     }
@@ -108,7 +108,7 @@ impl SessionState {
             SessionState::AuthFailed => Error::AuthFailed,
             SessionState::Expired => Error::SessionExpired,
             SessionState::Closed => Error::ClientClosed,
-            _ => Error::UnexpectedError(format!("expect error state, got {:?}", self)),
+            _ => Error::UnexpectedError(format!("expect error state, got {self:?}")),
         }
     }
 }
@@ -180,7 +180,7 @@ impl EventType {
             2 => EventType::NodeDeleted,
             3 => EventType::NodeDataChanged,
             4 => EventType::NodeChildrenChanged,
-            _ => return Err(Error::UnexpectedError(format!("event type should not be {}", i))),
+            _ => return Err(Error::UnexpectedError(format!("event type should not be {i}"))),
         };
         Ok(event_type)
     }
diff --git a/src/util.rs b/src/util.rs
@@ -67,7 +67,7 @@ pub fn strip_root_path<'a>(server_path: &'a str, root: &str) -> Result<&'a str,
         }
         return Ok(client_path);
     }
-    Err(Error::UnexpectedError(format!("server path {} is not descendant of root {}", server_path, root)))
+    Err(Error::UnexpectedError(format!("server path {server_path} is not descendant of root {root}")))
 }
 
 pub fn drain_root_path(server_path: &mut String, root: &str) -> Result<(), Error> {
@@ -78,7 +78,7 @@ pub fn drain_root_path(server_path: &mut String, root: &str) -> Result<(), Error
         }
         return Ok(());
     }
-    Err(Error::UnexpectedError(format!("server path {} is not descendant of root {}", server_path, root)))
+    Err(Error::UnexpectedError(format!("server path {server_path} is not descendant of root {root}")))
 }
 
 #[allow(dead_code)]

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ impl std::fmt::Display for Permission {`
`76`	`76`	`.into_iter()`
`77`	`77`	`.filter_map(\|(perm, str)\| if self.has(perm) { Some(str) } else { None })`
`78`	`78`	`.enumerate()`
`79`		`- .try_for_each(\|(i, str)\| if i == 0 { f.write_str(str) } else { write!(f, "\|{}", str) })`
	`79`	`+ .try_for_each(\|(i, str)\| if i == 0 { f.write_str(str) } else { write!(f, "\|{str}") })`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
Original file line number	Diff line number	Diff line change
`@@ -376,14 +376,11 @@ impl Client {`
`376`	`376`	`fn parse_sequence(client_path: &str, prefix: &str) -> Result<CreateSequence> {`
`377`	`377`	`if let Some(sequence_path) = client_path.strip_prefix(prefix) {`
`378`	`378`	`match sequence_path.parse::<i64>() {`
`379`		`- Err(_) => Err(Error::UnexpectedError(format!("sequential node get no i32 path {}", client_path))),`
	`379`	`+ Err(_) => Err(Error::UnexpectedError(format!("sequential node get no i32 path {client_path}"))),`
`380`	`380`	`Ok(i) => Ok(CreateSequence(i)),`
`381`	`381`	`}`
`382`	`382`	`} else {`
`383`		`- Err(Error::UnexpectedError(format!(`
`384`		`- "sequential path {} does not contain prefix path {}",`
`385`		`- client_path, prefix`
`386`		`- )))`
	`383`	`+ Err(Error::UnexpectedError(format!("sequential path {client_path} does not contain prefix path {prefix}",)))`
`387`	`384`	`}`
`388`	`385`	`}`
`389`	`386`
`@@ -1049,7 +1046,7 @@ impl Client {`
`1049`	`1046`	`std::mem::forget(guard);`
`1050`	`1047`	`let prefix_len = prefix.len();`
`1051`	`1048`	`let mut path = prefix;`
`1052`		`- write!(&mut path, "{}", sequence).unwrap();`
	`1049`	`+ write!(&mut path, "{sequence}").unwrap();`
`1053`	`1050`	`let sequence_len = path.len() - prefix_len;`
`1054`	`1051`	`return Ok((path, sequence_len));`
`1055`	`1052`	`}`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ impl Display for CustomError {`
`101`	`101`	`fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {`
`102`	`102`	`match (self.message.as_ref(), self.source.as_ref()) {`
`103`	`103`	`(Some(message), None) => f.write_str(message),`
`104`		`- (Some(message), Some(err)) => write!(f, "{}: {}", message, err),`
	`104`	`+ (Some(message), Some(err)) => write!(f, "{message}: {err}"),`
`105`	`105`	`(None, Some(err)) => err.fmt(f),`
`106`	`106`	`_ => unreachable!("no error message or source"),`
`107`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ impl TryFrom<i32> for Permission {`
`33`	`33`	`fn try_from(raw: i32) -> Result<Permission, Self::Error> {`
`34`	`34`	`let all_bits = Permission::ALL.into_raw();`
`35`	`35`	`if (raw & !all_bits) != 0 {`
`36`		`- return Err(InvalidData::UnmarshalError(format!("invalid permission bits: {:#b}", raw)));`
	`36`	`+ return Err(InvalidData::UnmarshalError(format!("invalid permission bits: {raw:#b}")));`
`37`	`37`	`}`
`38`	`38`	`Ok(Permission::from_raw(raw))`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,9 +42,7 @@ impl DeserializeError {`
`42`	`42`	`pub fn with_entity(self, entity: &'static str) -> ZkError {`
`43`	`43`	`match self {`
`44`	`44`	`DeserializeError::InsufficientBuf => ZkError::UnmarshalError { entity, reason: &"insufficient buf" },`
`45`		`- DeserializeError::UnexpectedOpCode(code) => {`
`46`		`- ZkError::UnexpectedError(format!("unexpected op code {}", code))`
`47`		`- },`
	`45`	`+ DeserializeError::UnexpectedOpCode(code) => ZkError::UnexpectedError(format!("unexpected op code {code}")),`
`48`	`46`	`DeserializeError::UnexpectedErrorCode(code) => ZkError::UnexpectedErrorCode(code),`
`49`	`47`	`DeserializeError::UnmarshalError(err) => ZkError::UnexpectedError(err),`
`50`	`48`	`}`
`@@ -284,7 +282,7 @@ impl UnsafeRead<'_> for bool {`
`284`	`282`	`match buf.get_unchecked_u8() {`
`285`	`283`	`0 => Ok(false),`
`286`	`284`	`1 => Ok(true),`
`287`		`- u => Err(InvalidData::UnmarshalError(format!("invalid value {} for bool", u))),`
	`285`	`+ u => Err(InvalidData::UnmarshalError(format!("invalid value {u} for bool"))),`
`288`	`286`	`}`
`289`	`287`	`}`
`290`	`288`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ use crate::endpoint::{EndpointRef, IterableEndpoints};`
`32`	`32`	`pub enum Connection {`
`33`	`33`	`Raw(TcpStream),`
`34`	`34`	`#[cfg(feature = "tls")]`
`35`		`- Tls(TlsStream<TcpStream>),`
	`35`	`+ Tls(Box<TlsStream<TcpStream>>),`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`pub trait AsyncReadToBuf: AsyncReadExt {`
`@@ -143,7 +143,7 @@ impl Connection {`
`143`	`143`
`144`	`144`	`#[cfg(feature = "tls")]`
`145`	`145`	`pub fn new_tls(stream: TlsStream<TcpStream>) -> Self {`
`146`		`- Self::Tls(stream)`
	`146`	`+ Self::Tls(stream.into())`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`pub async fn command(mut self, cmd: &str) -> Result<String> {`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ impl Depot {`
`101`	`101`
`102`	`102`	`pub fn pop_request(&mut self, xid: i32) -> Result<SessionOperation, Error> {`
`103`	`103`	`match self.written_operations.remove(&xid) {`
`104`		`- None => Err(Error::UnexpectedError(format!("recv response with xid {} but no pending request", xid))),`
	`104`	`+ None => Err(Error::UnexpectedError(format!("recv response with xid {xid} but no pending request"))),`
`105`	`105`	`Some(operation) => Ok(operation),`
`106`	`106`	`}`
`107`	`107`	`}`