refactor(lib): reduce clippy warnings (#3805)

linyihai · web-flow · commit 0bd4adfed2bf · 2024-12-06T11:04:54.000-05:00
diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
@@ -82,7 +82,7 @@ fn http1_parallel_x10_req_10kb_100_chunks(b: &mut test::Bencher) {
 #[bench]
 #[ignore]
 fn http1_parallel_x10_res_1mb(b: &mut test::Bencher) {
-    let body = &[b'x'; 1024 * 1024 * 1];
+    let body = &[b'x'; 1024 * 1024];
     opts().parallel(10).response_body(body).bench(b)
 }
 
@@ -177,7 +177,7 @@ fn http2_parallel_x10_req_10kb_100_chunks_max_window(b: &mut test::Bencher) {
 
 #[bench]
 fn http2_parallel_x10_res_1mb(b: &mut test::Bencher) {
-    let body = &[b'x'; 1024 * 1024 * 1];
+    let body = &[b'x'; 1024 * 1024];
     opts()
         .http2()
         .parallel(10)
diff --git a/benches/support/tokiort.rs b/benches/support/tokiort.rs
@@ -44,7 +44,7 @@ impl Timer for TokioTimer {
 
     fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
         if let Some(sleep) = sleep.as_mut().downcast_mut_pin::<TokioSleep>() {
-            sleep.reset(new_deadline.into())
+            sleep.reset(new_deadline)
         }
     }
 }
diff --git a/examples/client.rs b/examples/client.rs
@@ -71,7 +71,7 @@ async fn fetch_url(url: hyper::Uri) -> Result<()> {
     while let Some(next) = res.frame().await {
         let frame = next?;
         if let Some(chunk) = frame.data_ref() {
-            io::stdout().write_all(&chunk).await?;
+            io::stdout().write_all(chunk).await?;
         }
     }
 
diff --git a/examples/gateway.rs b/examples/gateway.rs
@@ -15,7 +15,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let in_addr: SocketAddr = ([127, 0, 0, 1], 3001).into();
     let out_addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
 
-    let out_addr_clone = out_addr.clone();
+    let out_addr_clone = out_addr;
 
     let listener = TcpListener::bind(in_addr).await?;
 
diff --git a/examples/http_proxy.rs b/examples/http_proxy.rs
@@ -111,7 +111,7 @@ async fn proxy(
 }
 
 fn host_addr(uri: &http::Uri) -> Option<String> {
-    uri.authority().and_then(|auth| Some(auth.to_string()))
+    uri.authority().map(|auth| auth.to_string())
 }
 
 fn empty() -> BoxBody<Bytes, hyper::Error> {
diff --git a/examples/single_threaded.rs b/examples/single_threaded.rs
@@ -207,7 +207,7 @@ async fn http1_client(url: hyper::Uri) -> Result<(), Box<dyn std::error::Error>>
         while let Some(next) = res.frame().await {
             let frame = next?;
             if let Some(chunk) = frame.data_ref() {
-                stdout.write_all(&chunk).await.unwrap();
+                stdout.write_all(chunk).await.unwrap();
             }
         }
         stdout.write_all(b"\n-----------------\n").await.unwrap();
@@ -308,7 +308,7 @@ async fn http2_client(url: hyper::Uri) -> Result<(), Box<dyn std::error::Error>>
         while let Some(next) = res.frame().await {
             let frame = next?;
             if let Some(chunk) = frame.data_ref() {
-                stdout.write_all(&chunk).await.unwrap();
+                stdout.write_all(chunk).await.unwrap();
             }
         }
         stdout.write_all(b"\n-----------------\n").await.unwrap();
diff --git a/examples/upgrades.rs b/examples/upgrades.rs
@@ -169,7 +169,6 @@ async fn main() {
                             res = &mut conn => {
                                 if let Err(err) = res {
                                     println!("Error serving connection: {:?}", err);
-                                    return;
                                 }
                             }
                             // Continue polling the connection after enabling graceful shutdown.
@@ -187,7 +186,7 @@ async fn main() {
     });
 
     // Client requests a HTTP connection upgrade.
-    let request = client_upgrade_request(addr.clone());
+    let request = client_upgrade_request(addr);
     if let Err(e) = request.await {
         eprintln!("client error: {}", e);
     }
diff --git a/examples/web_api.rs b/examples/web_api.rs
@@ -117,7 +117,7 @@ async fn main() -> Result<()> {
         let io = TokioIo::new(stream);
 
         tokio::task::spawn(async move {
-            let service = service_fn(move |req| response_examples(req));
+            let service = service_fn(response_examples);
 
             if let Err(err) = http1::Builder::new().serve_connection(io, service).await {
                 println!("Failed to serve connection: {:?}", err);
diff --git a/src/ext/h1_reason_phrase.rs b/src/ext/h1_reason_phrase.rs
@@ -174,26 +174,26 @@ mod tests {
 
     #[test]
     fn basic_valid() {
-        const PHRASE: &'static [u8] = b"OK";
+        const PHRASE: &[u8] = b"OK";
         assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
         assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
     }
 
     #[test]
     fn empty_valid() {
-        const PHRASE: &'static [u8] = b"";
+        const PHRASE: &[u8] = b"";
         assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
         assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
     }
 
     #[test]
     fn obs_text_valid() {
-        const PHRASE: &'static [u8] = b"hyp\xe9r";
+        const PHRASE: &[u8] = b"hyp\xe9r";
         assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
         assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
     }
 
-    const NEWLINE_PHRASE: &'static [u8] = b"hyp\ner";
+    const NEWLINE_PHRASE: &[u8] = b"hyp\ner";
 
     #[test]
     #[should_panic]
@@ -206,7 +206,7 @@ mod tests {
         assert!(ReasonPhrase::try_from(NEWLINE_PHRASE).is_err());
     }
 
-    const CR_PHRASE: &'static [u8] = b"hyp\rer";
+    const CR_PHRASE: &[u8] = b"hyp\rer";
 
     #[test]
     #[should_panic]
diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
@@ -693,7 +693,7 @@ mod tests {
     use std::pin::Pin;
     use std::time::Duration;
 
-    impl<'a> MemRead for &'a [u8] {
+    impl MemRead for &[u8] {
         fn read_mem(&mut self, _: &mut Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
             let n = std::cmp::min(len, self.len());
             if n > 0 {
@@ -707,12 +707,12 @@ mod tests {
         }
     }
 
-    impl<'a> MemRead for &'a mut (dyn Read + Unpin) {
+    impl MemRead for &mut (dyn Read + Unpin) {
         fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
             let mut v = vec![0; len];
             let mut buf = ReadBuf::new(&mut v);
             ready!(Pin::new(self).poll_read(cx, buf.unfilled())?);
-            Poll::Ready(Ok(Bytes::copy_from_slice(&buf.filled())))
+            Poll::Ready(Ok(Bytes::copy_from_slice(buf.filled())))
         }
     }
 
@@ -761,7 +761,7 @@ mod tests {
                 })
                 .await;
                 let desc = format!("read_size failed for {:?}", s);
-                state = result.expect(desc.as_str());
+                state = result.expect(&desc);
                 if state == ChunkedState::Body || state == ChunkedState::EndCr {
                     break;
                 }
diff --git a/src/proto/h1/dispatch.rs b/src/proto/h1/dispatch.rs
@@ -488,7 +488,7 @@ impl<'a, T> OptGuard<'a, T> {
     }
 }
 
-impl<'a, T> Drop for OptGuard<'a, T> {
+impl<T> Drop for OptGuard<'_, T> {
     fn drop(&mut self) {
         if self.1 {
             self.0.set(None);
diff --git a/src/proto/h1/encode.rs b/src/proto/h1/encode.rs
@@ -535,19 +535,16 @@ mod tests {
         let trailers = vec![HeaderValue::from_static("chunky-trailer")];
         let encoder = encoder.into_chunked_with_trailing_fields(trailers);
 
-        let headers = HeaderMap::from_iter(
-            vec![
-                (
-                    HeaderName::from_static("chunky-trailer"),
-                    HeaderValue::from_static("header data"),
-                ),
-                (
-                    HeaderName::from_static("should-not-be-included"),
-                    HeaderValue::from_static("oops"),
-                ),
-            ]
-            .into_iter(),
-        );
+        let headers = HeaderMap::from_iter(vec![
+            (
+                HeaderName::from_static("chunky-trailer"),
+                HeaderValue::from_static("header data"),
+            ),
+            (
+                HeaderName::from_static("should-not-be-included"),
+                HeaderValue::from_static("oops"),
+            ),
+        ]);
 
         let buf1 = encoder.encode_trailers::<&[u8]>(headers, false).unwrap();
 
@@ -565,19 +562,16 @@ mod tests {
         ];
         let encoder = encoder.into_chunked_with_trailing_fields(trailers);
 
-        let headers = HeaderMap::from_iter(
-            vec![
-                (
-                    HeaderName::from_static("chunky-trailer"),
-                    HeaderValue::from_static("header data"),
-                ),
-                (
-                    HeaderName::from_static("chunky-trailer-2"),
-                    HeaderValue::from_static("more header data"),
-                ),
-            ]
-            .into_iter(),
-        );
+        let headers = HeaderMap::from_iter(vec![
+            (
+                HeaderName::from_static("chunky-trailer"),
+                HeaderValue::from_static("header data"),
+            ),
+            (
+                HeaderName::from_static("chunky-trailer-2"),
+                HeaderValue::from_static("more header data"),
+            ),
+        ]);
 
         let buf1 = encoder.encode_trailers::<&[u8]>(headers, false).unwrap();
 
@@ -593,13 +587,10 @@ mod tests {
     fn chunked_with_no_trailer_header() {
         let encoder = Encoder::chunked();
 
-        let headers = HeaderMap::from_iter(
-            vec![(
-                HeaderName::from_static("chunky-trailer"),
-                HeaderValue::from_static("header data"),
-            )]
-            .into_iter(),
-        );
+        let headers = HeaderMap::from_iter(vec![(
+            HeaderName::from_static("chunky-trailer"),
+            HeaderValue::from_static("header data"),
+        )]);
 
         assert!(encoder
             .encode_trailers::<&[u8]>(headers.clone(), false)
@@ -656,13 +647,10 @@ mod tests {
         let trailers = vec![HeaderValue::from_static("chunky-trailer")];
         let encoder = encoder.into_chunked_with_trailing_fields(trailers);
 
-        let headers = HeaderMap::from_iter(
-            vec![(
-                HeaderName::from_static("chunky-trailer"),
-                HeaderValue::from_static("header data"),
-            )]
-            .into_iter(),
-        );
+        let headers = HeaderMap::from_iter(vec![(
+            HeaderName::from_static("chunky-trailer"),
+            HeaderValue::from_static("header data"),
+        )]);
         let buf1 = encoder.encode_trailers::<&[u8]>(headers, true).unwrap();
 
         let mut dst = Vec::new();
diff --git a/src/proto/h1/io.rs b/src/proto/h1/io.rs
@@ -320,7 +320,7 @@ where
     }
 
     #[cfg(test)]
-    fn flush<'a>(&'a mut self) -> impl std::future::Future<Output = io::Result<()>> + 'a {
+    fn flush(&mut self) -> impl std::future::Future<Output = io::Result<()>> + '_ {
         futures_util::future::poll_fn(move |cx| self.poll_flush(cx))
     }
 }
diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
@@ -100,10 +100,8 @@ fn is_complete_fast(bytes: &[u8], prev_len: usize) -> bool {
             if bytes[i + 1..].chunks(3).next() == Some(&b"\n\r\n"[..]) {
                 return true;
             }
-        } else if b == b'\n' {
-            if bytes.get(i + 1) == Some(&b'\n') {
-                return true;
-            }
+        } else if b == b'\n' && bytes.get(i + 1) == Some(&b'\n') {
+            return true;
         }
     }
 
@@ -1622,7 +1620,7 @@ fn write_headers_original_case(
 struct FastWrite<'a>(&'a mut Vec<u8>);
 
 #[cfg(feature = "client")]
-impl<'a> fmt::Write for FastWrite<'a> {
+impl fmt::Write for FastWrite<'_> {
     #[inline]
     fn write_str(&mut self, s: &str) -> fmt::Result {
         extend(self.0, s.as_bytes());
@@ -1721,7 +1719,7 @@ mod tests {
         Server::parse(&mut raw, ctx).unwrap_err();
     }
 
-    const H09_RESPONSE: &'static str = "Baguettes are super delicious, don't you agree?";
+    const H09_RESPONSE: &str = "Baguettes are super delicious, don't you agree?";
 
     #[test]
     fn test_parse_response_h09_allowed() {
@@ -1766,7 +1764,7 @@ mod tests {
         assert_eq!(raw, H09_RESPONSE);
     }
 
-    const RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &'static str =
+    const RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &str =
         "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Credentials : true\r\n\r\n";
 
     #[test]
@@ -1842,14 +1840,12 @@ mod tests {
         assert_eq!(
             orig_headers
                 .get_all_internal(&HeaderName::from_static("host"))
-                .into_iter()
                 .collect::<Vec<_>>(),
             vec![&Bytes::from("Host")]
         );
         assert_eq!(
             orig_headers
                 .get_all_internal(&HeaderName::from_static("x-bread"))
-                .into_iter()
                 .collect::<Vec<_>>(),
             vec![&Bytes::from("X-BREAD")]
         );
diff --git a/src/proto/h2/ping.rs b/src/proto/h2/ping.rs
@@ -10,14 +10,14 @@
 /// # BDP Algorithm
 ///
 /// 1. When receiving a DATA frame, if a BDP ping isn't outstanding:
-///   1a. Record current time.
-///   1b. Send a BDP ping.
+///    1a. Record current time.
+///    1b. Send a BDP ping.
 /// 2. Increment the number of received bytes.
 /// 3. When the BDP ping ack is received:
-///   3a. Record duration from sent time.
-///   3b. Merge RTT with a running average.
-///   3c. Calculate bdp as bytes/rtt.
-///   3d. If bdp is over 2/3 max, set new max to bdp and update windows.
+///    3a. Record duration from sent time.
+///    3b. Merge RTT with a running average.
+///    3c. Calculate bdp as bytes/rtt.
+///    3d. If bdp is over 2/3 max, set new max to bdp and update windows.
 use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
diff --git a/src/proto/h2/server.rs b/src/proto/h2/server.rs
@@ -181,13 +181,11 @@ where
         match self.state {
             State::Handshaking { .. } => {
                 self.close_pending = true;
-                return;
             }
             State::Serving(ref mut srv) => {
                 if srv.closing.is_none() {
                     srv.conn.graceful_shutdown();
                 }
-                return;
             }
         }
     }
@@ -227,7 +225,7 @@ where
                 }
                 State::Serving(ref mut srv) => {
                     // graceful_shutdown was called before handshaking finished,
-                    if true == me.close_pending && srv.closing.is_none() {
+                    if me.close_pending && srv.closing.is_none() {
                         srv.conn.graceful_shutdown();
                     }
                     ready!(srv.poll_server(cx, &mut me.service, &mut me.exec))?;
diff --git a/src/rt/io.rs b/src/rt/io.rs
diff --git a/src/service/service.rs b/src/service/service.rs
diff --git a/tests/client.rs b/tests/client.rs
diff --git a/tests/server.rs b/tests/server.rs
diff --git a/tests/support/mod.rs b/tests/support/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ impl Timer for TokioTimer {`
`44`	`44`
`45`	`45`	`fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {`
`46`	`46`	`if let Some(sleep) = sleep.as_mut().downcast_mut_pin::<TokioSleep>() {`
`47`		`- sleep.reset(new_deadline.into())`
	`47`	`+ sleep.reset(new_deadline)`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ async fn fetch_url(url: hyper::Uri) -> Result<()> {`
`71`	`71`	`while let Some(next) = res.frame().await {`
`72`	`72`	`let frame = next?;`
`73`	`73`	`if let Some(chunk) = frame.data_ref() {`
`74`		`- io::stdout().write_all(&chunk).await?;`
	`74`	`+ io::stdout().write_all(chunk).await?;`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ async fn proxy(`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`fn host_addr(uri: &http::Uri) -> Option<String> {`
`114`		`- uri.authority().and_then(\|auth\| Some(auth.to_string()))`
	`114`	`+ uri.authority().map(\|auth\| auth.to_string())`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`fn empty() -> BoxBody<Bytes, hyper::Error> {`
Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,7 @@ async fn http1_client(url: hyper::Uri) -> Result<(), Box<dyn std::error::Error>>`
`207`	`207`	`while let Some(next) = res.frame().await {`
`208`	`208`	`let frame = next?;`
`209`	`209`	`if let Some(chunk) = frame.data_ref() {`
`210`		`- stdout.write_all(&chunk).await.unwrap();`
	`210`	`+ stdout.write_all(chunk).await.unwrap();`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`	`stdout.write_all(b"\n-----------------\n").await.unwrap();`
`@@ -308,7 +308,7 @@ async fn http2_client(url: hyper::Uri) -> Result<(), Box<dyn std::error::Error>>`
`308`	`308`	`while let Some(next) = res.frame().await {`
`309`	`309`	`let frame = next?;`
`310`	`310`	`if let Some(chunk) = frame.data_ref() {`
`311`		`- stdout.write_all(&chunk).await.unwrap();`
	`311`	`+ stdout.write_all(chunk).await.unwrap();`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`	`stdout.write_all(b"\n-----------------\n").await.unwrap();`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,6 @@ async fn main() {`
`169`	`169`	`res = &mut conn => {`
`170`	`170`	`if let Err(err) = res {`
`171`	`171`	`println!("Error serving connection: {:?}", err);`
`172`		`- return;`
`173`	`172`	`}`
`174`	`173`	`}`
`175`	`174`	`// Continue polling the connection after enabling graceful shutdown.`
`@@ -187,7 +186,7 @@ async fn main() {`
`187`	`186`	`});`
`188`	`187`
`189`	`188`	`// Client requests a HTTP connection upgrade.`
`190`		`- let request = client_upgrade_request(addr.clone());`
	`189`	`+ let request = client_upgrade_request(addr);`
`191`	`190`	`if let Err(e) = request.await {`
`192`	`191`	`eprintln!("client error: {}", e);`
`193`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -693,7 +693,7 @@ mod tests {`
`693`	`693`	`use std::pin::Pin;`
`694`	`694`	`use std::time::Duration;`
`695`	`695`
`696`		`- impl<'a> MemRead for &'a [u8] {`
	`696`	`+ impl MemRead for &[u8] {`
`697`	`697`	`fn read_mem(&mut self, _: &mut Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {`
`698`	`698`	`let n = std::cmp::min(len, self.len());`
`699`	`699`	`if n > 0 {`
`@@ -707,12 +707,12 @@ mod tests {`
`707`	`707`	`}`
`708`	`708`	`}`
`709`	`709`
`710`		`- impl<'a> MemRead for &'a mut (dyn Read + Unpin) {`
	`710`	`+ impl MemRead for &mut (dyn Read + Unpin) {`
`711`	`711`	`fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {`
`712`	`712`	`let mut v = vec![0; len];`
`713`	`713`	`let mut buf = ReadBuf::new(&mut v);`
`714`	`714`	`ready!(Pin::new(self).poll_read(cx, buf.unfilled())?);`
`715`		`- Poll::Ready(Ok(Bytes::copy_from_slice(&buf.filled())))`
	`715`	`+ Poll::Ready(Ok(Bytes::copy_from_slice(buf.filled())))`
`716`	`716`	`}`
`717`	`717`	`}`
`718`	`718`
`@@ -761,7 +761,7 @@ mod tests {`
`761`	`761`	`})`
`762`	`762`	`.await;`
`763`	`763`	`let desc = format!("read_size failed for {:?}", s);`
`764`		`- state = result.expect(desc.as_str());`
	`764`	`+ state = result.expect(&desc);`
`765`	`765`	`if state == ChunkedState::Body \|\| state == ChunkedState::EndCr {`
`766`	`766`	`break;`
`767`	`767`	`}`