Fix new rustc + clippy warnings

Author: jplatte

crates/matrix-sdk-crypto/src/backups/mod.rs

@@ -357,14 +357,10 @@ impl BackupMachine {
             let private_identity = self.store.private_identity();
             let identity = private_identity.lock().await;
 
-            if let Some(key_id) = identity.master_key_id().await {
-                if let Ok(signature) = identity.sign(&canonical_json).await {
-                    data.signatures.add_signature(
-                        self.store.user_id().to_owned(),
-                        key_id,
-                        signature,
-                    );
-                }
+            if let Some(key_id) = identity.master_key_id().await
+                && let Ok(signature) = identity.sign(&canonical_json).await
+            {
+                data.signatures.add_signature(self.store.user_id().to_owned(), key_id, signature);
             }
 
             let cache = self.store.cache().await?;

crates/matrix-sdk-crypto/src/gossiping/machine.rs

@@ -781,14 +781,14 @@ impl GossipMachine {
         room_id: &RoomId,
         event: &EncryptedEvent,
     ) -> Result<bool, CryptoStoreError> {
-        if let Some(info) = event.room_key_info(room_id).map(|i| i.into()) {
-            if self.should_request_key(&info).await? {
-                // Size of the request_key_helper future should not impact this
-                // async fn since it is likely enough that this branch won't be
-                // entered.
-                Box::pin(self.request_key_helper(info)).await?;
-                return Ok(true);
-            }
+        if let Some(info) = event.room_key_info(room_id).map(|i| i.into())
+            && self.should_request_key(&info).await?
+        {
+            // Size of the request_key_helper future should not impact this
+            // async fn since it is likely enough that this branch won't be
+            // entered.
+            Box::pin(self.request_key_helper(info)).await?;
+            return Ok(true);
         }
 
         Ok(false)

crates/matrix-sdk-crypto/src/machine/mod.rs

@@ -1583,15 +1583,14 @@ impl OlmMachine {
                     ToDeviceUnableToDecryptReason::DecryptionFailure
                 };
 
-                if let OlmError::SessionWedged(sender, curve_key) = err {
-                    if let Err(e) =
+                if let OlmError::SessionWedged(sender, curve_key) = err
+                    && let Err(e) =
                         self.inner.session_manager.mark_device_as_wedged(&sender, curve_key).await
-                    {
-                        error!(
-                            error = ?e,
-                            "Couldn't mark device to be unwedged",
-                        );
-                    }
+                {
+                    error!(
+                        error = ?e,
+                        "Couldn't mark device to be unwedged",
+                    );
                 }
 
                 return Some(ProcessedToDeviceEvent::UnableToDecrypt {

crates/matrix-sdk-crypto/src/olm/account.rs

@@ -1700,15 +1700,14 @@ impl Account {
                 DeviceLinkProblem::MissingDevice,
             )));
 
-        let encryption_info = EncryptionInfo {
+        EncryptionInfo {
             sender: sender_id.to_owned(),
             sender_device: sender_device.as_ref().map(|d| d.device_id().to_owned()),
             algorithm_info: AlgorithmInfo::OlmV1Curve25519AesSha2 {
                 curve25519_public_key_base64: sender_key.to_base64(),
             },
             verification_state,
-        };
-        encryption_info
+        }
     }
 
     /// If the plaintext of the decrypted message includes a

crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs

@@ -629,12 +629,10 @@ impl InboundGroupSession {
 
         if let Some(decrypted_content) =
             decrypted_object.get_mut("content").and_then(|c| c.as_object_mut())
+            && !decrypted_content.contains_key("m.relates_to")
+            && let Some(relation) = &event.content.relates_to
         {
-            if !decrypted_content.contains_key("m.relates_to") {
-                if let Some(relation) = &event.content.relates_to {
-                    decrypted_content.insert("m.relates_to".to_owned(), relation.to_owned());
-                }
-            }
+            decrypted_content.insert("m.relates_to".to_owned(), relation.to_owned());
         }
 
         Ok((decrypted_object, decrypted.message_index))

crates/matrix-sdk-crypto/src/secret_storage.rs

@@ -495,15 +495,13 @@ impl SecretStorageKey {
         bytes.zeroize();
 
         // The string is formatted into groups of four characters separated by spaces.
-        let ret = base_58
+        base_58
             .chars()
             .collect::<Vec<char>>()
             .chunks(DISPLAY_CHUNK_SIZE)
             .map(|c| c.iter().collect::<String>())
             .collect::<Vec<_>>()
-            .join(" ");
-
-        ret
+            .join(" ")
     }
 
     /// Encrypt a given secret string as a Secrets Storage secret with the

crates/matrix-sdk-crypto/src/session_manager/group_sessions/mod.rs

@@ -1297,10 +1297,10 @@ mod tests {
                         let withheld: RoomKeyWithheldContent =
                             content.deserialize_as_unchecked::<RoomKeyWithheldContent>().unwrap();
 
-                        if let MegolmV1AesSha2(content) = withheld {
-                            if content.withheld_code() == code {
-                                count += 1;
-                            }
+                        if let MegolmV1AesSha2(content) = withheld
+                            && content.withheld_code() == code
+                        {
+                            count += 1;
                         }
                     })
                 }

crates/matrix-sdk-crypto/src/session_manager/group_sessions/share_strategy.rs

@@ -388,14 +388,11 @@ fn update_recipients_for_user(
     // rotated for other reasons, we also need to check whether any
     // of the devices in the session got deleted or blacklisted in the
     // meantime. If so, we should also rotate the session.
-    if let Some(outbound) = outbound {
-        if !recipients.should_rotate {
-            recipients.should_rotate = is_session_overshared_for_user(
-                outbound,
-                user_id,
-                &recipient_devices.allowed_devices,
-            )
-        }
+    if let Some(outbound) = outbound
+        && !recipients.should_rotate
+    {
+        recipients.should_rotate =
+            is_session_overshared_for_user(outbound, user_id, &recipient_devices.allowed_devices)
     }
 
     recipients

crates/matrix-sdk-crypto/src/session_manager/sessions.rs

@@ -106,30 +106,30 @@ impl SessionManager {
         sender: &UserId,
         curve_key: Curve25519PublicKey,
     ) -> OlmResult<()> {
-        if let Some(device) = self.store.get_device_from_curve_key(sender, curve_key).await? {
-            if let Some(session) = device.get_most_recent_session().await? {
-                info!(sender_key = ?curve_key, "Marking session to be unwedged");
-
-                let creation_time = Duration::from_secs(session.creation_time.get().into());
-                let now = Duration::from_secs(SecondsSinceUnixEpoch::now().get().into());
-
-                let should_unwedge = now
-                    .checked_sub(creation_time)
-                    .map(|elapsed| elapsed > Self::UNWEDGING_INTERVAL)
-                    .unwrap_or(true);
-
-                if should_unwedge {
-                    self.users_for_key_claim
-                        .write()
-                        .entry(device.user_id().to_owned())
-                        .or_default()
-                        .insert(device.device_id().into());
-                    self.wedged_devices
-                        .write()
-                        .entry(device.user_id().to_owned())
-                        .or_default()
-                        .insert(device.device_id().into());
-                }
+        if let Some(device) = self.store.get_device_from_curve_key(sender, curve_key).await?
+            && let Some(session) = device.get_most_recent_session().await?
+        {
+            info!(sender_key = ?curve_key, "Marking session to be unwedged");
+
+            let creation_time = Duration::from_secs(session.creation_time.get().into());
+            let now = Duration::from_secs(SecondsSinceUnixEpoch::now().get().into());
+
+            let should_unwedge = now
+                .checked_sub(creation_time)
+                .map(|elapsed| elapsed > Self::UNWEDGING_INTERVAL)
+                .unwrap_or(true);
+
+            if should_unwedge {
+                self.users_for_key_claim
+                    .write()
+                    .entry(device.user_id().to_owned())
+                    .or_default()
+                    .insert(device.device_id().into());
+                self.wedged_devices
+                    .write()
+                    .entry(device.user_id().to_owned())
+                    .or_default()
+                    .insert(device.device_id().into());
             }
         }
 
@@ -148,29 +148,26 @@ impl SessionManager {
     ///
     /// If the device was wedged this will queue up a dummy to-device message.
     async fn check_if_unwedged(&self, user_id: &UserId, device_id: &DeviceId) -> OlmResult<()> {
-        if self.wedged_devices.write().get_mut(user_id).is_some_and(|d| d.remove(device_id)) {
-            if let Some(device) = self.store.get_device(user_id, device_id).await? {
-                let (_, content) =
-                    device.encrypt("m.dummy", ToDeviceDummyEventContent::new()).await?;
-
-                let event_type = content.event_type().to_owned();
-
-                let request = ToDeviceRequest::new(
-                    device.user_id(),
-                    device.device_id().to_owned(),
-                    &event_type,
-                    content.cast(),
-                );
+        if self.wedged_devices.write().get_mut(user_id).is_some_and(|d| d.remove(device_id))
+            && let Some(device) = self.store.get_device(user_id, device_id).await?
+        {
+            let (_, content) = device.encrypt("m.dummy", ToDeviceDummyEventContent::new()).await?;
 
-                let request = OutgoingRequest {
-                    request_id: request.txn_id.clone(),
-                    request: Arc::new(request.into()),
-                };
+            let event_type = content.event_type().to_owned();
 
-                self.outgoing_to_device_requests
-                    .write()
-                    .insert(request.request_id.clone(), request);
-            }
+            let request = ToDeviceRequest::new(
+                device.user_id(),
+                device.device_id().to_owned(),
+                &event_type,
+                content.cast(),
+            );
+
+            let request = OutgoingRequest {
+                request_id: request.txn_id.clone(),
+                request: Arc::new(request.into()),
+            };
+
+            self.outgoing_to_device_requests.write().insert(request.request_id.clone(), request);
         }
 
         Ok(())

crates/matrix-sdk-crypto/src/store/crypto_store_wrapper.rs

@@ -227,14 +227,12 @@ impl CryptoStoreWrapper {
                 .await?
                 .as_ref()
                 .and_then(|i| i.other())
+                && !other_identity.was_previously_verified()
+                && own_identity_after.is_identity_signed(other_identity)
             {
-                if !other_identity.was_previously_verified()
-                    && own_identity_after.is_identity_signed(other_identity)
-                {
-                    trace!(?tracked_user.user_id, "Marking set verified_latch to true.");
-                    other_identity.mark_as_previously_verified();
-                    updated_identities.push(other_identity.clone().into());
-                }
+                trace!(?tracked_user.user_id, "Marking set verified_latch to true.");
+                other_identity.mark_as_previously_verified();
+                updated_identities.push(other_identity.clone().into());
             }
         }