minor: bump clippy to 1.84 (mongodb#1307)

Author: isabelatkinson

src/action/find_and_modify.rs

@@ -27,12 +27,12 @@ use crate::{
 use super::{action_impl, deeplink, export_doc, option_setters, options_doc};
 
 impl<T: DeserializeOwned + Send + Sync> Collection<T> {
-    async fn find_and_modify<'a>(
+    async fn find_and_modify(
         &self,
         filter: Document,
         modification: Modification,
         mut options: Option<FindAndModifyOptions>,
-        session: Option<&'a mut ClientSession>,
+        session: Option<&mut ClientSession>,
     ) -> Result<Option<T>> {
         resolve_write_concern_with_session!(self, options, session.as_ref())?;
 

src/client.rs

@@ -261,7 +261,7 @@ impl Client {
             .read()
             .await
             .as_ref()
-            .map_or(false, |cs| cs.exec().mongocryptd_spawned())
+            .is_some_and(|cs| cs.exec().mongocryptd_spawned())
     }
 
     #[cfg(all(test, feature = "in-use-encryption"))]
@@ -271,7 +271,7 @@ impl Client {
             .read()
             .await
             .as_ref()
-            .map_or(false, |cs| cs.exec().has_mongocryptd_client())
+            .is_some_and(|cs| cs.exec().has_mongocryptd_client())
     }
 
     fn test_command_event_channel(&self) -> Option<&options::TestEventSender> {

src/client/action/perf.rs

@@ -10,7 +10,7 @@ impl<'a> Action for crate::action::WarmConnectionPool<'a> {
             .inner
             .options
             .min_pool_size
-            .map_or(false, |s| s > 0)
+            .is_some_and(|size| size > 0)
         {
             // No-op when min_pool_size is zero.
             return;

src/client/auth/aws.rs

@@ -542,7 +542,7 @@ impl ServerFirst {
                 MECH_NAME,
                 "sts host must be non-empty",
             ))
-        } else if self.sts_host.as_bytes().len() > 255 {
+        } else if self.sts_host.len() > 255 {
             Err(Error::authentication_error(
                 MECH_NAME,
                 "sts host cannot be more than 255 bytes",

src/client/auth/oidc.rs

@@ -968,7 +968,7 @@ pub(super) fn validate_credential(credential: &Credential) -> Result<()> {
     if credential
         .source
         .as_ref()
-        .map_or(false, |s| s != "$external")
+        .is_some_and(|source| source != "$external")
     {
         return Err(Error::invalid_argument(format!(
             "source must be $external for {} authentication, found: {:?}",

src/client/csfle/client_encryption.rs

@@ -183,7 +183,7 @@ impl ClientEncryption {
 
     /// Decrypts an encrypted value (BSON binary of subtype 6).
     /// Returns the original BSON value.
-    pub async fn decrypt<'a>(&self, value: RawBinaryRef<'a>) -> Result<bson::RawBson> {
+    pub async fn decrypt(&self, value: RawBinaryRef<'_>) -> Result<bson::RawBson> {
         if value.subtype != BinarySubtype::Encrypted {
             return Err(Error::invalid_argument(format!(
                 "Invalid binary subtype for decrypt: expected {:?}, got {:?}",

src/client/options/test.rs

@@ -154,9 +154,7 @@ async fn run_tests(path: &[&str], skipped_files: &[&str]) {
 
                         let (_, actual_value) = actual_options
                             .iter()
-                            .find(|(actual_key, _)| {
-                                actual_key.to_ascii_lowercase() == expected_key.to_ascii_lowercase()
-                            })
+                            .find(|(actual_key, _)| actual_key.eq_ignore_ascii_case(expected_key))
                             .unwrap_or_else(|| {
                                 panic!(
                                     "{}: parsed options missing {} key",

src/client/session/action.rs

@@ -99,7 +99,7 @@ impl<'a> Action for StartTransaction<&'a mut ClientSession> {
     }
 }
 
-impl<'a> StartTransaction<&'a mut ClientSession> {
+impl StartTransaction<&mut ClientSession> {
     /// Starts a transaction, runs the given callback, and commits or aborts the transaction.
     /// Transient transaction errors will cause the callback or the commit to be retried;
     /// other errors will cause the transaction to be aborted and the error returned to the

src/cmap/conn/stream_description.rs

@@ -76,6 +76,6 @@ impl StreamDescription {
     pub(crate) fn supports_retryable_writes(&self) -> bool {
         self.initial_server_type != ServerType::Standalone
             && self.logical_session_timeout.is_some()
-            && self.max_wire_version.map_or(false, |version| version >= 6)
+            && self.max_wire_version.is_some_and(|version| version >= 6)
     }
 }

src/cmap/establish/handshake.rs

@@ -217,15 +217,15 @@ impl RuntimeEnvironment {
 }
 
 fn var_set(name: &str) -> bool {
-    env::var_os(name).map_or(false, |v| !v.is_empty())
+    env::var_os(name).is_some_and(|v| !v.is_empty())
 }
 
 impl FaasEnvironmentName {
     pub(crate) fn new() -> Option<Self> {
         use FaasEnvironmentName::*;
         let mut found: Option<Self> = None;
         let lambda_env = env::var_os("AWS_EXECUTION_ENV")
-            .map_or(false, |v| v.to_string_lossy().starts_with("AWS_Lambda_"));
+            .is_some_and(|v| v.to_string_lossy().starts_with("AWS_Lambda_"));
         if lambda_env || var_set("AWS_LAMBDA_RUNTIME_API") {
             found = Some(AwsLambda);
         }