chore: upgrade rust

this is needed for recent versions of ruma

src/api/client_server/account.rs

@@ -305,7 +305,7 @@ pub async fn register_route(body: Ruma<register::v3::Request>) -> Result<registe
 /// - Requires UIAA to verify user password
 /// - Changes the password of the sender user
 /// - The password hash is calculated using argon2 with 32 character salt, the plain password is
-/// not saved
+///   not saved
 ///
 /// If logout_devices is true it does the following for each device except the sender device:
 /// - Invalidates access token

src/api/client_server/context.rs

@@ -11,7 +11,7 @@ use tracing::error;
 /// Allows loading room history around an event.
 ///
 /// - Only works if the user is joined (TODO: always allow, but only show events if the user was
-/// joined, depending on history_visibility)
+///   joined, depending on history_visibility)
 pub async fn get_context_route(
     body: Ruma<get_context::v3::Request>,
 ) -> Result<get_context::v3::Response> {

src/api/client_server/message.rs

@@ -115,7 +115,7 @@ pub async fn send_message_event_route(
 /// Allows paginating through room history.
 ///
 /// - Only works if the user is joined (TODO: always allow, but only show events where the user was
-/// joined, depending on history_visibility)
+///   joined, depending on history_visibility)
 pub async fn get_message_events_route(
     body: Ruma<get_message_events::v3::Request>,
 ) -> Result<get_message_events::v3::Response> {

src/api/client_server/sync.rs

@@ -37,7 +37,7 @@ use tracing::{error, info};
 /// Synchronize the client's state with the latest state on the server.
 ///
 /// - This endpoint takes a `since` parameter which should be the `next_batch` value from a
-/// previous request for incremental syncs.
+///   previous request for incremental syncs.
 ///
 /// Calling this endpoint without a `since` parameter returns:
 /// - Some of the most recent events of each timeline
@@ -49,9 +49,9 @@ use tracing::{error, info};
 /// For joined rooms:
 /// - Some of the most recent events of each timeline that happened after since
 /// - If user joined the room after since: All state events (unless lazy loading is activated) and
-/// all device list updates in that room
+///   all device list updates in that room
 /// - If the user was already in the room: A list of all events that are in the state now, but were
-/// not in the state at `since`
+///   not in the state at `since`
 /// - If the state we send contains a member event: Joined and invited member counts, heroes
 /// - Device list updates that happened after `since`
 /// - If there are events in the timeline we send or the user send updated his read mark: Notification counts
@@ -65,7 +65,7 @@ use tracing::{error, info};
 /// - If the user left after `since`: prev_batch token, empty state (TODO: subset of the state at the point of the leave)
 ///
 /// - Sync is handled in an async task, multiple requests from the same device with the same
-/// `since` will be cached
+///   `since` will be cached
 pub async fn sync_events_route(
     body: Ruma<sync_events::v3::Request>,
 ) -> Result<sync_events::v3::Response, RumaResponse<UiaaResponse>> {

src/api/client_server/user_directory.rs

@@ -12,7 +12,7 @@ use ruma::{
 /// Searches all known users for a match.
 ///
 /// - Hides any local users that aren't in any public rooms (i.e. those that have the join rule set to public)
-/// and don't share a room with the sender
+///   and don't share a room with the sender
 pub async fn search_users_route(
     body: Ruma<search_users::v3::Request>,
 ) -> Result<search_users::v3::Response> {

src/api/server_server.rs

@@ -696,7 +696,7 @@ pub async fn get_server_version_route(
 /// Gets the public signing keys of this server.
 ///
 /// - Matrix does not support invalidating public keys, so the key returned by this will be valid
-/// forever.
+///   forever.
 // Response type for this endpoint is Json because we need to calculate a signature for the response
 pub async fn get_server_keys_route() -> Result<impl IntoResponse> {
     let mut verify_keys: BTreeMap<OwnedServerSigningKeyId, VerifyKey> = BTreeMap::new();
@@ -743,7 +743,7 @@ pub async fn get_server_keys_route() -> Result<impl IntoResponse> {
 /// Gets the public signing keys of this server.
 ///
 /// - Matrix does not support invalidating public keys, so the key returned by this will be valid
-/// forever.
+///   forever.
 pub async fn get_server_keys_deprecated_route() -> impl IntoResponse {
     get_server_keys_route().await
 }

src/database/key_value/rooms/edus/read_receipt.rs

@@ -1,5 +1,3 @@
-use std::mem;
-
 use ruma::{
     events::receipt::ReceiptEvent, serde::Raw, CanonicalJsonObject, OwnedUserId, RoomId, UserId,
 };
@@ -73,12 +71,13 @@ impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
                 .iter_from(&first_possible_edu, false)
                 .take_while(move |(k, _)| k.starts_with(&prefix2))
                 .map(move |(k, v)| {
-                    let count = utils::u64_from_bytes(
-                        &k[prefix.len()..prefix.len() + mem::size_of::<u64>()],
-                    )
-                    .map_err(|_| Error::bad_database("Invalid readreceiptid count in db."))?;
+                    let count =
+                        utils::u64_from_bytes(&k[prefix.len()..prefix.len() + size_of::<u64>()])
+                            .map_err(|_| {
+                                Error::bad_database("Invalid readreceiptid count in db.")
+                            })?;
                     let user_id = UserId::parse(
-                        utils::string_from_bytes(&k[prefix.len() + mem::size_of::<u64>() + 1..])
+                        utils::string_from_bytes(&k[prefix.len() + size_of::<u64>() + 1..])
                             .map_err(|_| {
                                 Error::bad_database("Invalid readreceiptid userid bytes in db.")
                             })?,

src/database/key_value/rooms/pdu_metadata.rs

@@ -1,4 +1,4 @@
-use std::{mem, sync::Arc};
+use std::sync::Arc;
 
 use ruma::{EventId, RoomId, UserId};
 
@@ -40,7 +40,7 @@ impl service::rooms::pdu_metadata::Data for KeyValueDatabase {
                 .iter_from(&current, true)
                 .take_while(move |(k, _)| k.starts_with(&prefix))
                 .map(move |(tofrom, _data)| {
-                    let from = utils::u64_from_bytes(&tofrom[(mem::size_of::<u64>())..])
+                    let from = utils::u64_from_bytes(&tofrom[(size_of::<u64>())..])
                         .map_err(|_| Error::bad_database("Invalid count in tofrom_relation."))?;
 
                     let mut pduid = shortroomid.to_be_bytes().to_vec();

src/database/key_value/rooms/threads.rs

@@ -1,5 +1,3 @@
-use std::mem;
-
 use ruma::{api::client::threads::get_threads::v1::IncludeThreads, OwnedUserId, RoomId, UserId};
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, PduEvent, Result};
@@ -28,7 +26,7 @@ impl service::rooms::threads::Data for KeyValueDatabase {
                 .iter_from(&current, true)
                 .take_while(move |(k, _)| k.starts_with(&prefix))
                 .map(move |(pduid, _users)| {
-                    let count = utils::u64_from_bytes(&pduid[(mem::size_of::<u64>())..])
+                    let count = utils::u64_from_bytes(&pduid[(size_of::<u64>())..])
                         .map_err(|_| Error::bad_database("Invalid pduid in threadid_userids."))?;
                     let mut pdu = services()
                         .rooms