refactor(crypto): Use struct destructuring instead of separate field access in some places

In several places, we access almost all the fields of a struct to
create an `InboundGroupSession` from a pure data struct.

When new fields are added to these data structs, it's easy to
overlook updating the `InboundGroupSession` accordingly.

By using struct destructuring, we ensure that newly added fields  are
explicitly considered, making it harder to forget one of the newly added
fields.

Author: poljar

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

@@ -332,24 +332,36 @@ impl InboundGroupSession {
     /// * `pickle_mode` - The mode that was used to pickle the session, either
     ///   an unencrypted mode or an encrypted using passphrase.
     pub fn from_pickle(pickle: PickledInboundGroupSession) -> Result<Self, PickleError> {
-        let session: InnerSession = pickle.pickle.into();
+        let PickledInboundGroupSession {
+            pickle,
+            sender_key,
+            signing_key,
+            sender_data,
+            room_id,
+            imported,
+            backed_up,
+            history_visibility,
+            algorithm,
+        } = pickle;
+
+        let session: InnerSession = pickle.into();
         let first_known_index = session.first_known_index();
         let session_id = session.session_id();
 
         Ok(InboundGroupSession {
             inner: Mutex::new(session).into(),
             session_id: session_id.into(),
             creator_info: SessionCreatorInfo {
-                curve25519_key: pickle.sender_key,
-                signing_keys: pickle.signing_key.into(),
+                curve25519_key: sender_key,
+                signing_keys: signing_key.into(),
             },
-            sender_data: pickle.sender_data,
-            history_visibility: pickle.history_visibility.into(),
+            sender_data,
+            history_visibility: history_visibility.into(),
             first_known_index,
-            room_id: (*pickle.room_id).into(),
-            backed_up: AtomicBool::from(pickle.backed_up).into(),
-            algorithm: pickle.algorithm.into(),
-            imported: pickle.imported,
+            room_id,
+            backed_up: AtomicBool::from(backed_up).into(),
+            algorithm: algorithm.into(),
+            imported,
         })
     }
 
@@ -554,25 +566,35 @@ impl TryFrom<&ExportedRoomKey> for InboundGroupSession {
     type Error = SessionCreationError;
 
     fn try_from(key: &ExportedRoomKey) -> Result<Self, Self::Error> {
+        let ExportedRoomKey {
+            algorithm,
+            room_id,
+            sender_key,
+            session_id,
+            session_key,
+            sender_claimed_keys,
+            forwarding_curve25519_key_chain: _,
+        } = key;
+
         let config = OutboundGroupSession::session_config(&key.algorithm)?;
-        let session = InnerSession::import(&key.session_key, config);
+        let session = InnerSession::import(session_key, config);
         let first_known_index = session.first_known_index();
 
         Ok(InboundGroupSession {
             inner: Mutex::new(session).into(),
-            session_id: key.session_id.to_owned().into(),
+            session_id: session_id.to_owned().into(),
             creator_info: SessionCreatorInfo {
-                curve25519_key: key.sender_key,
-                signing_keys: key.sender_claimed_keys.to_owned().into(),
+                curve25519_key: *sender_key,
+                signing_keys: sender_claimed_keys.to_owned().into(),
             },
             // TODO: In future, exported keys should contain sender data that we can use here.
             // See https://github.com/matrix-org/matrix-rust-sdk/issues/3548
             sender_data: SenderData::default(),
             history_visibility: None.into(),
             first_known_index,
-            room_id: key.room_id.to_owned(),
+            room_id: room_id.to_owned(),
             imported: true,
-            algorithm: key.algorithm.to_owned().into(),
+            algorithm: algorithm.to_owned().into(),
             backed_up: AtomicBool::from(false).into(),
         })
     }

Diff for: crates/matrix-sdk-crypto/src/olm/group_sessions/mod.rs

@@ -109,21 +109,32 @@ impl ExportedRoomKey {
         session_id: String,
         room_key: BackedUpRoomKey,
     ) -> Self {
+        let BackedUpRoomKey {
+            algorithm,
+            sender_key,
+            session_key,
+            sender_claimed_keys,
+            forwarding_curve25519_key_chain,
+        } = room_key;
+
         Self {
-            algorithm: room_key.algorithm,
+            algorithm,
             room_id,
-            sender_key: room_key.sender_key,
+            sender_key,
             session_id,
-            session_key: room_key.session_key,
-            sender_claimed_keys: room_key.sender_claimed_keys,
-            forwarding_curve25519_key_chain: room_key.forwarding_curve25519_key_chain,
+            session_key,
+            sender_claimed_keys,
+            forwarding_curve25519_key_chain,
         }
     }
 }
 
-/// A backed up version of an `InboundGroupSession`
+/// A backed up version of an [`InboundGroupSession`].
+///
+/// This can be used to backup the [`InboundGroupSession`] to the server using
+/// [server-side key backups].
 ///
-/// This can be used to backup the `InboundGroupSession` to the server.
+/// [server-side key backups]: https://spec.matrix.org/unstable/client-server-api/#server-side-key-backups
 #[derive(Deserialize, Serialize)]
 #[allow(missing_debug_implementations)]
 pub struct BackedUpRoomKey {
@@ -208,13 +219,23 @@ impl TryFrom<ExportedRoomKey> for ForwardedRoomKeyContent {
 }
 
 impl From<ExportedRoomKey> for BackedUpRoomKey {
-    fn from(k: ExportedRoomKey) -> Self {
+    fn from(value: ExportedRoomKey) -> Self {
+        let ExportedRoomKey {
+            algorithm,
+            room_id: _,
+            sender_key,
+            session_id: _,
+            session_key,
+            sender_claimed_keys,
+            forwarding_curve25519_key_chain,
+        } = value;
+
         Self {
-            algorithm: k.algorithm,
-            sender_key: k.sender_key,
-            session_key: k.session_key,
-            sender_claimed_keys: k.sender_claimed_keys,
-            forwarding_curve25519_key_chain: k.forwarding_curve25519_key_chain,
+            algorithm,
+            sender_key,
+            session_key,
+            sender_claimed_keys,
+            forwarding_curve25519_key_chain,
         }
     }
 }