Fix remaining errors

Signed-off-by: Kévin Commaille <zecakeh@tedomum.fr>

Author: zecakeh

benchmarks/benches/crypto_bench.rs

@@ -1,4 +1,4 @@
-use std::{ops::Deref, sync::Arc};
+use std::sync::Arc;
 
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use matrix_sdk_crypto::{EncryptionSettings, OlmMachine};
@@ -199,11 +199,7 @@ pub fn room_key_sharing(c: &mut Criterion) {
     group.bench_function(BenchmarkId::new("Room key sharing [memory]", &name), |b| {
         b.to_async(&runtime).iter(|| async {
             let requests = machine
-                .share_room_key(
-                    room_id,
-                    users.iter().map(Deref::deref),
-                    EncryptionSettings::default(),
-                )
+                .share_room_key(room_id, users.iter(), EncryptionSettings::default())
                 .await
                 .unwrap();
 
@@ -231,11 +227,7 @@ pub fn room_key_sharing(c: &mut Criterion) {
     group.bench_function(BenchmarkId::new("Room key sharing [SQLite]", &name), |b| {
         b.to_async(&runtime).iter(|| async {
             let requests = machine
-                .share_room_key(
-                    room_id,
-                    users.iter().map(Deref::deref),
-                    EncryptionSettings::default(),
-                )
+                .share_room_key(room_id, users.iter(), EncryptionSettings::default())
                 .await
                 .unwrap();
 
@@ -278,7 +270,7 @@ pub fn devices_missing_sessions_collecting(c: &mut Criterion) {
 
     group.bench_function(BenchmarkId::new("Devices collecting [memory]", &name), |b| {
         b.to_async(&runtime).iter_with_large_drop(|| async {
-            machine.get_missing_sessions(users.iter().map(Deref::deref)).await.unwrap()
+            machine.get_missing_sessions(users.iter()).await.unwrap()
         })
     });
 
@@ -294,9 +286,8 @@ pub fn devices_missing_sessions_collecting(c: &mut Criterion) {
     runtime.block_on(machine.mark_request_as_sent(&txn_id, &response)).unwrap();
 
     group.bench_function(BenchmarkId::new("Devices collecting [SQLite]", &name), |b| {
-        b.to_async(&runtime).iter(|| async {
-            machine.get_missing_sessions(users.iter().map(Deref::deref)).await.unwrap()
-        })
+        b.to_async(&runtime)
+            .iter(|| async { machine.get_missing_sessions(users.iter()).await.unwrap() })
     });
 
     {

benchmarks/benches/event_cache.rs

@@ -324,7 +324,7 @@ fn find_event_relations(c: &mut Criterion) {
                                     .await
                                     .unwrap()
                                     .unwrap();
-                                assert_eq!(target.event_id().as_deref().unwrap(), target_event_id);
+                                assert_eq!(target.event_id().unwrap(), target_event_id);
                                 assert_eq!(relations.len(), num_related_events as usize);
                             },
                             criterion::BatchSize::PerIteration,

bindings/matrix-sdk-crypto-ffi/src/lib.rs

@@ -285,7 +285,7 @@ async fn migrate_data(
         .map(|k| BackupDecryptionKey::from_base58(k.as_str()))
         .transpose()?;
 
-    let cross_signing = PrivateCrossSigningIdentity::empty((*user_id).into());
+    let cross_signing = PrivateCrossSigningIdentity::empty(&user_id);
     cross_signing
         .import_secrets_unchecked(
             data.cross_signing.master_key.as_deref(),
@@ -307,7 +307,7 @@ async fn migrate_data(
         .filter_map(|s| parse_user_id(&s).ok().map(|u| (u, true)))
         .collect();
 
-    let tracked_users: Vec<_> = tracked_users.iter().map(|(u, d)| (&**u, *d)).collect();
+    let tracked_users: Vec<_> = tracked_users.iter().map(|(u, d)| (u, *d)).collect();
     store.save_tracked_users(tracked_users.as_slice()).await?;
 
     processed_steps += 1;

bindings/matrix-sdk-crypto-ffi/src/machine.rs

@@ -2,7 +2,6 @@ use std::{
     collections::{BTreeMap, HashMap},
     io::Cursor,
     mem::ManuallyDrop,
-    ops::Deref,
     sync::Arc,
     time::Duration,
 };
@@ -205,7 +204,7 @@ impl OlmMachine {
         mut passphrase: Option<String>,
     ) -> Result<Arc<Self>, CryptoStoreError> {
         let user_id = parse_user_id(&user_id)?;
-        let device_id = device_id.as_str().into();
+        let device_id = device_id.into();
         let runtime = Runtime::new().expect("Couldn't create a tokio runtime");
 
         let store = runtime
@@ -215,7 +214,7 @@ impl OlmMachine {
 
         let inner = runtime.block_on(InnerMachine::with_store(
             &user_id,
-            device_id,
+            &device_id,
             Arc::new(store),
             None,
         ))?;
@@ -353,7 +352,7 @@ impl OlmMachine {
 
         Ok(self
             .runtime
-            .block_on(self.inner.get_device(&user_id, device_id.as_str().into(), timeout))?
+            .block_on(self.inner.get_device(&user_id, &device_id.into(), timeout))?
             .map(|d| d.into()))
     }
 
@@ -378,7 +377,7 @@ impl OlmMachine {
         let user_id = UserId::parse(user_id)?;
         let device = self.runtime.block_on(self.inner.get_device(
             &user_id,
-            device_id.as_str().into(),
+            &device_id.clone().into(),
             None,
         ))?;
 
@@ -399,11 +398,8 @@ impl OlmMachine {
     ) -> Result<(), CryptoStoreError> {
         let user_id = parse_user_id(&user_id)?;
 
-        let device = self.runtime.block_on(self.inner.get_device(
-            &user_id,
-            device_id.as_str().into(),
-            None,
-        ))?;
+        let device =
+            self.runtime.block_on(self.inner.get_device(&user_id, &device_id.into(), None))?;
 
         if let Some(device) = device {
             self.runtime.block_on(device.set_local_trust(trust_state))?;
@@ -587,7 +583,7 @@ impl OlmMachine {
     pub fn update_tracked_users(&self, users: Vec<String>) -> Result<(), CryptoStoreError> {
         let users: Vec<UserId> = users.into_iter().filter_map(|u| UserId::parse(u).ok()).collect();
 
-        self.runtime.block_on(self.inner.update_tracked_users(users.iter().map(Deref::deref)))?;
+        self.runtime.block_on(self.inner.update_tracked_users(users.iter()))?;
 
         Ok(())
     }
@@ -621,10 +617,7 @@ impl OlmMachine {
     ) -> Result<Option<Request>, CryptoStoreError> {
         let users: Vec<UserId> = users.into_iter().filter_map(|u| UserId::parse(u).ok()).collect();
 
-        Ok(self
-            .runtime
-            .block_on(self.inner.get_missing_sessions(users.iter().map(Deref::deref)))?
-            .map(|r| r.into()))
+        Ok(self.runtime.block_on(self.inner.get_missing_sessions(users.iter()))?.map(|r| r.into()))
     }
 
     /// Get the stored room settings, such as the encryption algorithm or
@@ -750,11 +743,8 @@ impl OlmMachine {
         let users: Vec<UserId> = users.into_iter().filter_map(|u| UserId::parse(u).ok()).collect();
 
         let room_id = RoomId::parse(room_id)?;
-        let requests = self.runtime.block_on(self.inner.share_room_key(
-            &room_id,
-            users.iter().map(Deref::deref),
-            settings,
-        ))?;
+        let requests =
+            self.runtime.block_on(self.inner.share_room_key(&room_id, users.iter(), settings))?;
 
         Ok(requests.into_iter().map(|r| r.as_ref().into()).collect())
     }
@@ -835,10 +825,10 @@ impl OlmMachine {
         share_strategy: CollectStrategy,
     ) -> Result<Option<Request>, CryptoStoreError> {
         let user_id = parse_user_id(&user_id)?;
-        let device_id = device_id.as_str().into();
+        let device_id = device_id.into();
         let content = serde_json::from_str(&content)?;
 
-        let device = self.runtime.block_on(self.inner.get_device(&user_id, device_id, None))?;
+        let device = self.runtime.block_on(self.inner.get_device(&user_id, &device_id, None))?;
 
         if let Some(device) = device {
             let encrypted_content = self.runtime.block_on(device.encrypt_event_raw(
@@ -848,7 +838,7 @@ impl OlmMachine {
             ))?;
 
             let request = ToDeviceRequest::new(
-                user_id.as_ref(),
+                &user_id,
                 DeviceIdOrAllDevices::DeviceId(device_id.to_owned()),
                 "m.room.encrypted",
                 encrypted_content.cast(),
@@ -1265,13 +1255,13 @@ impl OlmMachine {
         methods: Vec<String>,
     ) -> Result<Option<RequestVerificationResult>, CryptoStoreError> {
         let user_id = parse_user_id(&user_id)?;
-        let device_id = device_id.as_str().into();
+        let device_id = device_id.into();
 
         let methods = methods.into_iter().map(VerificationMethod::from).collect();
 
         Ok(
             if let Some(device) =
-                self.runtime.block_on(self.inner.get_device(&user_id, device_id, None))?
+                self.runtime.block_on(self.inner.get_device(&user_id, &device_id, None))?
             {
                 let (verification, request) = device.request_verification_with_methods(methods);
 
@@ -1357,11 +1347,11 @@ impl OlmMachine {
         device_id: String,
     ) -> Result<Option<StartSasResult>, CryptoStoreError> {
         let user_id = parse_user_id(&user_id)?;
-        let device_id = device_id.as_str().into();
+        let device_id = device_id.into();
 
         Ok(
             if let Some(device) =
-                self.runtime.block_on(self.inner.get_device(&user_id, device_id, None))?
+                self.runtime.block_on(self.inner.get_device(&user_id, &device_id, None))?
             {
                 let (sas, request) = self.runtime.block_on(device.start_verification())?;
 

bindings/matrix-sdk-ffi/src/client.rs

@@ -1600,8 +1600,8 @@ impl Client {
     }
 
     pub async fn get_profile(&self, user_id: String) -> Result<UserProfile, ClientError> {
-        let user_id = <&UserId>::try_from(user_id.as_str())?;
-        UserProfile::fetch(&self.inner.account(), user_id).await
+        let user_id = UserId::try_from(user_id)?;
+        UserProfile::fetch(&self.inner.account(), &user_id).await
     }
 
     pub async fn notification_client(
@@ -1686,8 +1686,8 @@ impl Client {
     /// Otherwise use `join_room_by_id_or_alias` so you can pass a list of
     /// server names for the homeserver to find the room.
     pub async fn join_room_by_id(&self, room_id: String) -> Result<Arc<Room>, ClientError> {
-        let room_id = RoomId::parse(room_id)?;
-        let room = self.inner.join_room_by_id(room_id.as_ref()).await?;
+        let room_id = RoomId::try_from(room_id)?;
+        let room = self.inner.join_room_by_id(&room_id).await?;
         Ok(Arc::new(Room::new(room, self.utd_hook_manager.get().cloned())))
     }
 
@@ -1702,13 +1702,12 @@ impl Client {
         room_id_or_alias: String,
         server_names: Vec<String>,
     ) -> Result<Arc<Room>, ClientError> {
-        let room_id = RoomOrAliasId::parse(&room_id_or_alias)?;
+        let room_id = RoomOrAliasId::try_from(room_id_or_alias)?;
         let server_names = server_names
             .iter()
             .map(|name| ServerName::try_from(name.as_str()))
             .collect::<Result<Vec<_>, _>>()?;
-        let room =
-            self.inner.join_room_by_id_or_alias(room_id.as_ref(), server_names.as_ref()).await?;
+        let room = self.inner.join_room_by_id_or_alias(&room_id, server_names.as_ref()).await?;
         Ok(Arc::new(Room::new(room, self.utd_hook_manager.get().cloned())))
     }
 
@@ -1776,19 +1775,15 @@ impl Client {
         room_id: String,
         via_servers: Vec<String>,
     ) -> Result<Arc<RoomPreview>, ClientError> {
-        let room_id = RoomId::parse(&room_id).context("room_id is not a valid room id")?;
+        let room_id = RoomId::try_from(room_id).context("room_id is not a valid room id")?;
 
         let via_servers = via_servers
             .into_iter()
             .map(ServerName::parse)
             .collect::<Result<Vec<_>, _>>()
             .context("at least one `via` server name is invalid")?;
 
-        // The `into()` call below doesn't work if I do `(&room_id).into()`, so I let
-        // rustc win that one fight.
-        let room_id: &RoomId = &room_id;
-
-        let room_preview = self.inner.get_room_preview(room_id.into(), via_servers).await?;
+        let room_preview = self.inner.get_room_preview(&room_id.into(), via_servers).await?;
 
         Ok(Arc::new(RoomPreview::new(self.inner.clone(), room_preview)))
     }
@@ -1799,13 +1794,9 @@ impl Client {
         room_alias: String,
     ) -> Result<Arc<RoomPreview>, ClientError> {
         let room_alias =
-            RoomAliasId::parse(&room_alias).context("room_alias is not a valid room alias")?;
-
-        // The `into()` call below doesn't work if I do `(&room_id).into()`, so I let
-        // rustc win that one fight.
-        let room_alias: &RoomAliasId = &room_alias;
+            RoomAliasId::try_from(room_alias).context("room_alias is not a valid room alias")?;
 
-        let room_preview = self.inner.get_room_preview(room_alias.into(), Vec::new()).await?;
+        let room_preview = self.inner.get_room_preview(&room_alias.into(), Vec::new()).await?;
 
         Ok(Arc::new(RoomPreview::new(self.inner.clone(), room_preview)))
     }

bindings/matrix-sdk-ffi/src/client_builder.rs

@@ -406,7 +406,7 @@ impl ClientBuilder {
             None => {
                 if let Some(username) = builder.username {
                     let user = UserId::parse(username)?;
-                    inner_builder.server_name(user.server_name())
+                    inner_builder.server_name(&user.server_name())
                 } else {
                     return Err(ClientBuildError::Generic {
                         message: "Failed to build: One of homeserver_url, server_name, server_name_or_homeserver_url or username must be called.".to_owned(),

bindings/matrix-sdk-ffi/src/encryption.rs

@@ -20,6 +20,7 @@ use matrix_sdk::{
     encryption::{backups, recovery},
 };
 use matrix_sdk_common::{SendOutsideWasm, SyncOutsideWasm};
+use ruma::UserId;
 use thiserror::Error;
 use tracing::{error, info};
 use zeroize::Zeroize;
@@ -466,7 +467,8 @@ impl Encryption {
         user_id: String,
         fallback_to_server: bool,
     ) -> Result<Option<Arc<UserIdentity>>, ClientError> {
-        match self.inner.get_user_identity(user_id.as_str().try_into()?).await {
+        let user_id = UserId::try_from(user_id)?;
+        match self.inner.get_user_identity(&user_id).await {
             Ok(Some(identity)) => {
                 return Ok(Some(Arc::new(UserIdentity { inner: identity })));
             }
@@ -481,7 +483,7 @@ impl Encryption {
         info!("Requesting identity from the server.");
 
         if fallback_to_server {
-            let identity = self.inner.request_user_identity(user_id.as_str().try_into()?).await?;
+            let identity = self.inner.request_user_identity(&user_id).await?;
             Ok(identity.map(|identity| Arc::new(UserIdentity { inner: identity })))
         } else {
             Ok(None)

bindings/matrix-sdk-ffi/src/room/mod.rs

@@ -594,9 +594,8 @@ impl Room {
     }
 
     pub async fn invite_user_by_id(&self, user_id: String) -> Result<(), ClientError> {
-        let user =
-            <&UserId>::try_from(user_id.as_str()).context("Could not create user from string")?;
-        self.inner.invite_user_by_id(user).await?;
+        let user = UserId::try_from(user_id).context("Could not create user from string")?;
+        self.inner.invite_user_by_id(&user).await?;
         Ok(())
     }
 
@@ -728,13 +727,17 @@ impl Room {
         updates: Vec<UserPowerLevelUpdate>,
     ) -> Result<(), ClientError> {
         let updates = updates
-            .iter()
+            .into_iter()
             .map(|update| {
-                let user_id: &UserId = update.user_id.as_str().try_into()?;
+                let user_id: UserId = update.user_id.try_into()?;
                 let power_level = Int::new(update.power_level).context("Invalid power level")?;
                 Ok((user_id, power_level))
             })
             .collect::<Result<Vec<_>>>()?;
+        let updates = updates
+            .iter()
+            .map(|(user_id, power_level)| (user_id, *power_level))
+            .collect::<Vec<_>>();
 
         self.inner.update_power_levels(updates).await.map_err(ClientError::from_err)?;
         Ok(())
@@ -814,7 +817,7 @@ impl Room {
         thread_root: Option<String>,
     ) -> Result<(), ClientError> {
         let thread_root = thread_root.map(EventId::parse).transpose()?;
-        Ok(self.inner.save_composer_draft(draft.try_into()?, thread_root.as_deref()).await?)
+        Ok(self.inner.save_composer_draft(draft.try_into()?, thread_root.as_ref()).await?)
     }
 
     /// Retrieve the `ComposerDraft` stored in the state store for this room.
@@ -823,7 +826,7 @@ impl Room {
         thread_root: Option<String>,
     ) -> Result<Option<ComposerDraft>, ClientError> {
         let thread_root = thread_root.map(EventId::parse).transpose()?;
-        Ok(self.inner.load_composer_draft(thread_root.as_deref()).await?.map(Into::into))
+        Ok(self.inner.load_composer_draft(thread_root.as_ref()).await?.map(Into::into))
     }
 
     /// Remove the `ComposerDraft` stored in the state store for this room.
@@ -832,7 +835,7 @@ impl Room {
         thread_root: Option<String>,
     ) -> Result<(), ClientError> {
         let thread_root = thread_root.map(EventId::parse).transpose()?;
-        Ok(self.inner.clear_composer_draft(thread_root.as_deref()).await?)
+        Ok(self.inner.clear_composer_draft(thread_root.as_ref()).await?)
     }
 
     /// Edit an event given its event id.