minor: bump clippy version to 1.71.0 (#921)

Author: isabelatkinson

.evergreen/check-clippy.sh

@@ -6,7 +6,7 @@ source ./.evergreen/env.sh
 source ./.evergreen/feature-combinations.sh
 
 # Pin clippy to the latest version. This should be updated when new versions of Rust are released.
-CLIPPY_VERSION=1.67.0
+CLIPPY_VERSION=1.71.0
 
 rustup install $CLIPPY_VERSION
 

src/client/options.rs

@@ -1679,7 +1679,7 @@ impl ConnectionString {
 
         // Set username and password.
         if let Some(u) = username {
-            let mut credential = conn_str.credential.get_or_insert_with(Default::default);
+            let credential = conn_str.credential.get_or_insert_with(Default::default);
             validate_userinfo(u, "username")?;
             let decoded_u = percent_decode(u, "username must be URL encoded")?;
 
@@ -1701,7 +1701,7 @@ impl ConnectionString {
 
         match parts.auth_mechanism {
             Some(ref mechanism) => {
-                let mut credential = conn_str.credential.get_or_insert_with(Default::default);
+                let credential = conn_str.credential.get_or_insert_with(Default::default);
                 credential.source = parts.auth_source;
 
                 if let Some(mut doc) = parts.auth_mechanism_properties.take() {
@@ -1989,7 +1989,7 @@ impl ConnectionString {
                 self.heartbeat_frequency = Some(Duration::from_millis(get_duration!(value, k)));
             }
             k @ "journal" => {
-                let mut write_concern = self.write_concern.get_or_insert_with(Default::default);
+                let write_concern = self.write_concern.get_or_insert_with(Default::default);
                 write_concern.journal = Some(get_bool!(value, k));
             }
             k @ "loadbalanced" => {
@@ -2216,7 +2216,7 @@ impl ConnectionString {
                 }
             },
             "w" => {
-                let mut write_concern = self.write_concern.get_or_insert_with(Default::default);
+                let write_concern = self.write_concern.get_or_insert_with(Default::default);
 
                 match value.parse::<i32>() {
                     Ok(w) => match u32::try_from(w) {

src/sdam/description/topology/test/sdam.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Borrow, collections::HashMap, sync::Arc, time::Duration};
+use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use bson::Document;
 use serde::Deserialize;
@@ -807,7 +807,6 @@ async fn pool_cleared_error_does_not_mark_unknown() {
     assert_eq!(
         topology
             .watch()
-            .borrow()
             .server_description(&address)
             .unwrap()
             .server_type,

src/test/spec/connection_stepdown.rs

@@ -70,7 +70,6 @@ async fn run_test<F: Future>(
     test(client, db, coll).await;
 }
 
-#[function_name::named]
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn get_more() {
@@ -116,10 +115,9 @@ async fn get_more() {
         assert_eq!(client.count_pool_cleared_events(), 0);
     }
 
-    run_test(function_name!(), get_more_test).await;
+    run_test("get_more", get_more_test).await;
 }
 
-#[function_name::named]
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn notwritableprimary_keep_pool() {
@@ -167,7 +165,11 @@ async fn notwritableprimary_keep_pool() {
         assert_eq!(client.count_pool_cleared_events(), 0);
     }
 
-    run_test(function_name!(), notwritableprimary_keep_pool_test).await;
+    run_test(
+        "notwritableprimary_keep_pool",
+        notwritableprimary_keep_pool_test,
+    )
+    .await;
 }
 
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
@@ -226,7 +228,6 @@ async fn notwritableprimary_reset_pool() {
     .await;
 }
 
-#[function_name::named]
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn shutdown_in_progress() {
@@ -273,10 +274,9 @@ async fn shutdown_in_progress() {
             .expect("insert should have succeeded");
     }
 
-    run_test(function_name!(), shutdown_in_progress_test).await;
+    run_test("shutdown_in_progress", shutdown_in_progress_test).await;
 }
 
-#[function_name::named]
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn interrupted_at_shutdown() {
@@ -325,5 +325,5 @@ async fn interrupted_at_shutdown() {
         runtime::delay_for(Duration::from_millis(250)).await;
     }
 
-    run_test(function_name!(), interrupted_at_shutdown_test).await;
+    run_test("interrupted_at_shutdown", interrupted_at_shutdown_test).await;
 }

src/test/spec/transactions.rs

@@ -107,7 +107,7 @@ async fn deserialize_recovery_token() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn convenient_api_custom_error() {
-    let _guard: _ = LOCK.run_concurrently().await;
+    let _guard = LOCK.run_concurrently().await;
     let client = Client::test_builder().event_client().build().await;
     if !client.supports_transactions() {
         log_uncaptured("Skipping convenient_api_custom_error: no transaction support.");
@@ -143,7 +143,7 @@ async fn convenient_api_custom_error() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn convenient_api_returned_value() {
-    let _guard: _ = LOCK.run_concurrently().await;
+    let _guard = LOCK.run_concurrently().await;
     let client = Client::test_builder().event_client().build().await;
     if !client.supports_transactions() {
         log_uncaptured("Skipping convenient_api_returned_value: no transaction support.");
@@ -175,7 +175,7 @@ async fn convenient_api_returned_value() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn convenient_api_retry_timeout_callback() {
-    let _guard: _ = LOCK.run_concurrently().await;
+    let _guard = LOCK.run_concurrently().await;
     let client = Client::test_builder().event_client().build().await;
     if !client.supports_transactions() {
         log_uncaptured("Skipping convenient_api_retry_timeout_callback: no transaction support.");
@@ -211,7 +211,7 @@ async fn convenient_api_retry_timeout_callback() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn convenient_api_retry_timeout_commit_unknown() {
-    let _guard: _ = LOCK.run_exclusively().await;
+    let _guard = LOCK.run_exclusively().await;
     let mut options = CLIENT_OPTIONS.get().await.clone();
     if Client::test_builder().build().await.is_sharded() {
         options.direct_connection = Some(true);
@@ -267,7 +267,7 @@ async fn convenient_api_retry_timeout_commit_unknown() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn convenient_api_retry_timeout_commit_transient() {
-    let _guard: _ = LOCK.run_exclusively().await;
+    let _guard = LOCK.run_exclusively().await;
     let mut options = CLIENT_OPTIONS.get().await.clone();
     if Client::test_builder().build().await.is_sharded() {
         options.direct_connection = Some(true);

src/test/spec/unified_runner/operation.rs

@@ -2147,7 +2147,7 @@ impl TestOperation for Close {
             let target_entity = entities.get(id).unwrap();
             match target_entity {
                 Entity::Client(_) => {
-                    let mut client = entities.get_mut(id).unwrap().as_mut_client();
+                    let client = entities.get_mut(id).unwrap().as_mut_client();
                     let closed_client_topology_id = client.topology_id;
                     client.client = None;