Make clippy happy (#3350)

Cargo.toml

@@ -33,7 +33,6 @@ inefficient_to_string = "warn"
 linkedlist = "warn"
 lossy_float_literal = "warn"
 macro_use_imports = "warn"
-match_on_vec_items = "warn"
 match_wildcard_for_single_variants = "warn"
 mem_forget = "warn"
 needless_borrow = "warn"

axum-macros/src/from_request/mod.rs

@@ -775,10 +775,11 @@ fn impl_struct_by_extracting_all_at_once(
         .chain(via_marker_type)
         .collect::<Punctuated<Type, Token![,]>>();
 
-    let ident_generics = generic_ident
+    let ident_generics = if generic_ident.is_some() {
-        .is_some()
+        quote! { <T> }
-        .then(|| quote! { <T> })
+    } else {
-        .unwrap_or_default();
+        TokenStream::new()
+    };
 
     let rejection_bound = rejection.as_ref().map(|rejection| {
         match (tr, generic_ident.is_some()) {

examples/http-proxy/src/main.rs

@@ -77,7 +77,7 @@ async fn main() {
                 .with_upgrades()
                 .await
             {
-                println!("Failed to serve connection: {:?}", err);
+                println!("Failed to serve connection: {err:?}");
             }
         });
     }

examples/reverse-proxy/src/main.rs

@@ -45,7 +45,7 @@ async fn handler(State(client): State<Client>, mut req: Request) -> Result<Respo
         .map(|v| v.as_str())
         .unwrap_or(path);
 
-    let uri = format!("http://127.0.0.1:3000{}", path_query);
+    let uri = format!("http://127.0.0.1:3000{path_query}");
 
     *req.uri_mut() = Uri::try_from(uri).unwrap();
 

examples/sse/src/main.rs

@@ -85,19 +85,19 @@ mod tests {
         async fn spawn_app(host: impl Into<String>) -> String {
             let host = host.into();
             // Bind to localhost at the port 0, which will let the OS assign an available port to us
-            let listener = TcpListener::bind(format!("{}:0", host)).await.unwrap();
+            let listener = TcpListener::bind(format!("{host}:0")).await.unwrap();
             // Retrieve the port assigned to us by the OS
             let port = listener.local_addr().unwrap().port();
             tokio::spawn(async {
                 axum::serve(listener, app()).await.unwrap();
             });
             // Returns address (e.g. http://127.0.0.1{random_port})
-            format!("http://{}:{}", host, port)
+            format!("http://{host}:{port}")
         }
         let listening_url = spawn_app("127.0.0.1").await;
 
         let mut event_stream = reqwest::Client::new()
-            .get(format!("{}/sse", listening_url))
+            .get(format!("{listening_url}/sse"))
             .header("User-Agent", "integration_test")
             .send()
             .await

examples/unix-domain-socket/src/main.rs

@@ -59,7 +59,7 @@ mod unix {
         let (mut sender, conn) = hyper::client::conn::http1::handshake(stream).await.unwrap();
         tokio::task::spawn(async move {
             if let Err(err) = conn.await {
-                println!("Connection failed: {:?}", err);
+                println!("Connection failed: {err:?}");
             }
         });
 
@@ -79,7 +79,7 @@ mod unix {
     }
 
     async fn handler(ConnectInfo(info): ConnectInfo<UdsConnectInfo>) -> &'static str {
-        println!("new connection from `{:?}`", info);
+        println!("new connection from `{info:?}`");
 
         "Hello, World!"
     }

examples/websockets/src/client.rs

@@ -129,13 +129,13 @@ fn process_message(msg: Message, who: usize) -> ControlFlow<(), ()> {
             println!(">>> {who} got str: {t:?}");
         }
         Message::Binary(d) => {
-            println!(">>> {} got {} bytes: {:?}", who, d.len(), d);
+            println!(">>> {who} got {} bytes: {d:?}", d.len());
         }
         Message::Close(c) => {
             if let Some(cf) = c {
                 println!(
-                    ">>> {} got close with code {} and reason `{}`",
+                    ">>> {who} got close with code {} and reason `{}`",
-                    who, cf.code, cf.reason
+                    cf.code, cf.reason
                 );
             } else {
                 println!(">>> {who} somehow got close message without CloseFrame");

examples/websockets/src/main.rs

@@ -220,13 +220,13 @@ fn process_message(msg: Message, who: SocketAddr) -> ControlFlow<(), ()> {
             println!(">>> {who} sent str: {t:?}");
         }
         Message::Binary(d) => {
-            println!(">>> {} sent {} bytes: {:?}", who, d.len(), d);
+            println!(">>> {who} sent {} bytes: {d:?}", d.len());
         }
         Message::Close(c) => {
             if let Some(cf) = c {
                 println!(
-                    ">>> {} sent close with code {} and reason `{}`",
+                    ">>> {who} sent close with code {} and reason `{}`",
-                    who, cf.code, cf.reason
+                    cf.code, cf.reason
                 );
             } else {
                 println!(">>> {who} somehow sent close message without CloseFrame");