review: refactors ProcessedToDeviceEvent to tuple variants

Simplifies the `ProcessedToDeviceEvent` enum by converting its variants to tuple variants.

This change improves code readability and conciseness by removing the need for named fields within the variants.

Author: BillCarsonFr

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

@@ -21,9 +21,9 @@ use std::{
 use itertools::Itertools;
 use matrix_sdk_common::{
     deserialized_responses::{
-        AlgorithmInfo, DecryptedRoomEvent, DeviceLinkProblem, EncryptionInfo,
-        UnableToDecryptInfo, UnableToDecryptReason,
-        UnsignedDecryptionResult, UnsignedEventLocation, VerificationLevel, VerificationState,
+        AlgorithmInfo, DecryptedRoomEvent, DeviceLinkProblem, EncryptionInfo, UnableToDecryptInfo,
+        UnableToDecryptReason, UnsignedDecryptionResult, UnsignedEventLocation, VerificationLevel,
+        VerificationState,
     },
     locks::RwLock as StdRwLock,
     BoxFuture,
@@ -95,14 +95,13 @@ use crate::{
             AnyIncomingResponse, KeysQueryRequest, OutgoingRequest, ToDeviceRequest,
             UploadSigningKeysRequest,
         },
-        EventEncryptionAlgorithm, Signatures,
+        EventEncryptionAlgorithm, ProcessedToDeviceEvent, Signatures,
     },
     utilities::timestamp_to_iso8601,
     verification::{Verification, VerificationMachine, VerificationRequest},
     CollectStrategy, CrossSigningKeyExport, CryptoStoreError, DecryptionSettings, DeviceData,
     LocalTrust, RoomEventDecryptionResult, SignatureError, TrustRequirement,
 };
-use crate::types::ProcessedToDeviceEvent;
 
 /// State machine implementation of the Olm/Megolm encryption protocol used for
 /// Matrix end to end encryption.
@@ -1320,7 +1319,7 @@ impl OlmMachine {
                             }
                         }
 
-                        return Some(ProcessedToDeviceEvent::UnableToDecrypt { event: raw_event });
+                        return Some(ProcessedToDeviceEvent::UnableToDecrypt(raw_event));
                     }
                 };
 
@@ -1373,7 +1372,7 @@ impl OlmMachine {
                     }
                 }
 
-                Some(ProcessedToDeviceEvent::Decrypted { decrypted_event: raw_event })
+                Some(ProcessedToDeviceEvent::Decrypted(raw_event))
             }
 
             e => {

crates/matrix-sdk-crypto/src/machine/tests/megolm_sender_data.rs

@@ -17,7 +17,6 @@ use std::{fmt::Debug, iter, pin::Pin};
 use assert_matches::assert_matches;
 use futures_core::Stream;
 use futures_util::{FutureExt, StreamExt};
-use crate::types::ProcessedToDeviceEvent;
 use matrix_sdk_test::async_test;
 use ruma::{room_id, user_id, RoomId, TransactionId, UserId};
 use serde::Serialize;
@@ -34,7 +33,10 @@ use crate::{
     },
     olm::{InboundGroupSession, SenderData},
     store::RoomKeyInfo,
-    types::events::{room::encrypted::ToDeviceEncryptedEventContent, EventType, ToDeviceEvent},
+    types::{
+        events::{room::encrypted::ToDeviceEncryptedEventContent, EventType, ToDeviceEvent},
+        ProcessedToDeviceEvent,
+    },
     DeviceData, EncryptionSettings, EncryptionSyncChanges, OlmMachine, Session,
 };
 

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

@@ -18,9 +18,8 @@ use assert_matches2::{assert_let, assert_matches};
 use futures_util::{pin_mut, FutureExt, StreamExt};
 use itertools::Itertools;
 use matrix_sdk_common::deserialized_responses::{
-    AlgorithmInfo, UnableToDecryptInfo, UnableToDecryptReason,
-    UnsignedDecryptionResult, UnsignedEventLocation, VerificationLevel, VerificationState,
-    WithheldCode,
+    AlgorithmInfo, UnableToDecryptInfo, UnableToDecryptReason, UnsignedDecryptionResult,
+    UnsignedEventLocation, VerificationLevel, VerificationState, WithheldCode,
 };
 use matrix_sdk_test::{async_test, message_like_event_content, ruma_response_from_json, test_json};
 use ruma::{
@@ -71,14 +70,13 @@ use crate::{
             ToDeviceEvent,
         },
         requests::{AnyOutgoingRequest, ToDeviceRequest},
-        DeviceKeys, SignedKey, SigningKeys,
+        DeviceKeys, ProcessedToDeviceEvent, SignedKey, SigningKeys,
     },
     utilities::json_convert,
     verification::tests::bob_id,
     Account, DecryptionSettings, DeviceData, EncryptionSettings, LocalTrust, MegolmError, OlmError,
     RoomEventDecryptionResult, TrustRequirement,
 };
-use crate::types::ProcessedToDeviceEvent;
 
 mod decryption_verification_state;
 mod interactive_verification;

crates/matrix-sdk-crypto/src/machine/tests/olm_encryption.rs

@@ -18,7 +18,6 @@ use std::{
 };
 
 use assert_matches2::assert_let;
-use crate::types::ProcessedToDeviceEvent;
 use matrix_sdk_test::async_test;
 use ruma::{
     device_id,
@@ -39,7 +38,7 @@ use crate::{
     },
     olm::utility::SignJson,
     store::Changes,
-    types::{events::ToDeviceEvent, DeviceKeys},
+    types::{events::ToDeviceEvent, DeviceKeys, ProcessedToDeviceEvent},
     DeviceData, OlmMachine,
 };
 
@@ -295,9 +294,7 @@ async fn test_decrypt_to_device_message_with_unsigned_sender_keys() {
 
     let event = to_device_events.first().expect("Bob did not get a to-device event").clone();
 
-    // The to-device event should remain decrypted.
-    let ProcessedToDeviceEvent::UnableToDecrypt { event } = event else {
-        panic!("Should refuse to decrypt")
-    };
+    // The to-device event should remain encrypted.
+    assert_let!(ProcessedToDeviceEvent::UnableToDecrypt(event) = event);
     assert_eq!(event.get_field("type").unwrap(), Some("m.room.encrypted"));
 }

crates/matrix-sdk-crypto/src/machine/tests/send_encrypted_to_device.rs

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 use assert_matches2::{assert_let, assert_matches};
-use crate::types::ProcessedToDeviceEvent;
 use matrix_sdk_test::async_test;
 use ruma::{events::AnyToDeviceEvent, serde::Raw, to_device::DeviceIdOrAllDevices};
 use serde_json::{json, value::to_raw_value};
@@ -26,6 +25,7 @@ use crate::{
     types::{
         events::{ToDeviceCustomEvent, ToDeviceEvent},
         requests::ToDeviceRequest,
+        ProcessedToDeviceEvent,
     },
     utilities::json_convert,
     EncryptionSyncChanges, OlmError,
@@ -87,7 +87,7 @@ async fn test_send_encrypted_to_device() {
     assert_eq!(1, decrypted.len());
     let processed_event = &decrypted[0];
 
-    assert_let!(ProcessedToDeviceEvent::Decrypted { decrypted_event, .. } = processed_event);
+    assert_let!(ProcessedToDeviceEvent::Decrypted(decrypted_event) = processed_event);
 
     let decrypted_event = decrypted_event.deserialize().unwrap();
 
@@ -208,7 +208,7 @@ async fn test_processed_to_device_variants() {
     assert_eq!(4, processed.len());
 
     let processed_event = &processed[0];
-    assert_matches!(processed_event, ProcessedToDeviceEvent::Decrypted { .. });
+    assert_matches!(processed_event, ProcessedToDeviceEvent::Decrypted(_));
 
     let processed_event = &processed[1];
     assert_matches!(processed_event, ProcessedToDeviceEvent::PlainText(_));

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

@@ -1063,11 +1063,10 @@ mod tests {
                 room_key_withheld::RoomKeyWithheldContent::{self, MegolmV1AesSha2},
             },
             requests::ToDeviceRequest,
-            DeviceKeys, EventEncryptionAlgorithm,
+            DeviceKeys, EventEncryptionAlgorithm, ProcessedToDeviceEvent,
         },
         EncryptionSettings, LocalTrust, OlmMachine,
     };
-    use crate::types::ProcessedToDeviceEvent;
 
     fn alice_id() -> &'static UserId {
         user_id!("@alice:example.org")
@@ -1824,8 +1823,7 @@ mod tests {
         assert_eq!(1, decrypted.len());
         use crate::types::events::EventType;
         assert_let!(
-            ProcessedToDeviceEvent::Decrypted { decrypted_event, .. } =
-                decrypted.first().unwrap().clone()
+            ProcessedToDeviceEvent::Decrypted(decrypted_event) = decrypted.first().unwrap().clone()
         );
         assert_eq!(
             decrypted_event.get_field::<String>("type").unwrap().unwrap(),

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

@@ -36,13 +36,13 @@ use std::{
 use as_variant::as_variant;
 use matrix_sdk_common::deserialized_responses::PrivOwnedStr;
 use ruma::{
-    serde::StringEnum, DeviceKeyAlgorithm, DeviceKeyId, OwnedDeviceKeyId, OwnedUserId, UserId,
+    events::AnyToDeviceEvent,
+    serde::{Raw, StringEnum},
+    DeviceKeyAlgorithm, DeviceKeyId, OwnedDeviceKeyId, OwnedUserId, UserId,
 };
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use vodozemac::{Curve25519PublicKey, Ed25519PublicKey, Ed25519Signature, KeyError};
 use zeroize::{Zeroize, ZeroizeOnDrop};
-use ruma::serde::Raw;
-use ruma::events::AnyToDeviceEvent;
 
 mod backup;
 mod cross_signing;
@@ -633,16 +633,11 @@ mod test {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum ProcessedToDeviceEvent {
     /// A successfully-decrypted encrypted event.
-    Decrypted {
-        /// The decrypted to device event
-        decrypted_event: Raw<AnyToDeviceEvent>,
-    },
+    /// Contains the raw decrypted event .
+    Decrypted(Raw<AnyToDeviceEvent>),
 
     /// An encrypted event which could not be decrypted.
-    UnableToDecrypt {
-        /// The `m.room.encrypted` to device event.
-        event: Raw<AnyToDeviceEvent>,
-    },
+    UnableToDecrypt(Raw<AnyToDeviceEvent>),
 
     /// An unencrypted event.
     PlainText(Raw<AnyToDeviceEvent>),
@@ -652,13 +647,14 @@ pub enum ProcessedToDeviceEvent {
 }
 
 impl ProcessedToDeviceEvent {
-    /// Converts a ProcessedToDeviceEvent to the Raw<AnyToDeviceEvent> it encapsulates
+    /// Converts a ProcessedToDeviceEvent to the Raw<AnyToDeviceEvent> it
+    /// encapsulates
     pub fn to_raw(&self) -> Raw<AnyToDeviceEvent> {
         match self {
-            ProcessedToDeviceEvent::Decrypted { decrypted_event, .. } => decrypted_event.clone(),
-            ProcessedToDeviceEvent::UnableToDecrypt { event } => event.clone(),
+            ProcessedToDeviceEvent::Decrypted(decrypted_event) => decrypted_event.clone(),
+            ProcessedToDeviceEvent::UnableToDecrypt(event) => event.clone(),
             ProcessedToDeviceEvent::PlainText(event) => event.clone(),
             ProcessedToDeviceEvent::NotProcessed(event) => event.clone(),
         }
     }
-}
+}