run cargo fix for rust 2024 changes and rustfmt

Signed-off-by: June Clementine Strawberry <strawberry@puppygock.gay>

src/api/client/sync/mod.rs

@@ -3,25 +3,25 @@ mod v4;
 mod v5;
 
 use conduwuit::{
-	utils::{
-		stream::{BroadbandExt, ReadyExt, TryIgnore},
-		IterStream,
-	},
 	PduCount,
+	utils::{
+		IterStream,
+		stream::{BroadbandExt, ReadyExt, TryIgnore},
+	},
 };
-use futures::{pin_mut, StreamExt};
+use futures::{StreamExt, pin_mut};
 use ruma::{
+	RoomId, UserId,
 	directory::RoomTypeFilter,
 	events::TimelineEventType::{
 		self, Beacon, CallInvite, PollStart, RoomEncrypted, RoomMessage, Sticker,
 	},
-	RoomId, UserId,
 };
 
 pub(crate) use self::{
 	v3::sync_events_route, v4::sync_events_v4_route, v5::sync_events_v5_route,
 };
-use crate::{service::Services, Error, PduEvent, Result};
+use crate::{Error, PduEvent, Result, service::Services};
 
 pub(crate) const DEFAULT_BUMP_TYPES: &[TimelineEventType; 6] =
 	&[CallInvite, PollStart, Beacon, RoomEncrypted, RoomMessage, Sticker];

src/api/client/sync/v3.rs

@@ -6,57 +6,55 @@ use std::{
 
 use axum::extract::State;
 use conduwuit::{
-	at, err, error, extract_variant, is_equal_to, pair_of,
+	PduCount, PduEvent, Result, at, err, error, extract_variant, is_equal_to, pair_of,
 	pdu::{Event, EventHash},
 	ref_at,
 	result::FlatOk,
 	utils::{
-		self,
+		self, BoolExt, IterStream, ReadyExt, TryFutureExtExt,
 		math::ruma_from_u64,
 		stream::{BroadbandExt, Tools, TryExpect, WidebandExt},
-		BoolExt, IterStream, ReadyExt, TryFutureExtExt,
 	},
-	PduCount, PduEvent, Result,
 };
 use conduwuit_service::{
+	Services,
 	rooms::{
 		lazy_loading,
 		lazy_loading::{Options, Witness},
 		short::ShortStateHash,
 	},
-	Services,
 };
 use futures::{
-	future::{join, join3, join4, join5, try_join, try_join4, OptionFuture},
 	FutureExt, StreamExt, TryFutureExt, TryStreamExt,
+	future::{OptionFuture, join, join3, join4, join5, try_join, try_join4},
 };
 use ruma::{
+	DeviceId, EventId, OwnedEventId, OwnedRoomId, OwnedUserId, RoomId, UserId,
 	api::client::{
 		filter::FilterDefinition,
 		sync::sync_events::{
-			self,
+			self, DeviceLists, UnreadNotificationsCount,
 			v3::{
 				Ephemeral, Filter, GlobalAccountData, InviteState, InvitedRoom, JoinedRoom,
 				KnockState, KnockedRoom, LeftRoom, Presence, RoomAccountData, RoomSummary, Rooms,
 				State as RoomState, Timeline, ToDevice,
 			},
-			DeviceLists, UnreadNotificationsCount,
 		},
 		uiaa::UiaaResponse,
 	},
 	events::{
-		presence::{PresenceEvent, PresenceEventContent},
-		room::member::{MembershipState, RoomMemberEventContent},
 		AnyRawAccountDataEvent, AnySyncEphemeralRoomEvent, StateEventType,
 		TimelineEventType::*,
+		presence::{PresenceEvent, PresenceEventContent},
+		room::member::{MembershipState, RoomMemberEventContent},
 	},
 	serde::Raw,
-	uint, DeviceId, EventId, OwnedEventId, OwnedRoomId, OwnedUserId, RoomId, UserId,
+	uint,
 };
 use service::rooms::short::{ShortEventId, ShortStateKey};
 
 use super::{load_timeline, share_encrypted_room};
-use crate::{client::ignored_filter, Ruma, RumaResponse};
+use crate::{Ruma, RumaResponse, client::ignored_filter};
 
 #[derive(Default)]
 struct StateChanges {
@@ -168,8 +166,8 @@ pub(crate) async fn build_sync_events(
 	let full_state = body.body.full_state;
 	let filter = match body.body.filter.as_ref() {
 		| None => FilterDefinition::default(),
-		| Some(Filter::FilterDefinition(ref filter)) => filter.clone(),
-		| Some(Filter::FilterId(ref filter_id)) => services
+		| Some(Filter::FilterDefinition(filter)) => filter.clone(),
+		| Some(Filter::FilterId(filter_id)) => services
 			.users
 			.get_filter(sender_user, filter_id)
 			.await
@@ -1016,34 +1014,37 @@ async fn calculate_state_incremental<'a>(
 	let lazy_state_ids: OptionFuture<_> = witness
 		.filter(|_| !full_state && !encrypted_room)
 		.map(|witness| {
-			witness
-				.iter()
-				.stream()
-				.broad_filter_map(|user_id| state_get_shorteventid(user_id))
-				.into_future()
+			StreamExt::into_future(
+				witness
+					.iter()
+					.stream()
+					.broad_filter_map(|user_id| state_get_shorteventid(user_id)),
+			)
 		})
 		.into();
 
 	let state_diff: OptionFuture<_> = (!full_state && state_changed)
 		.then(|| {
-			services
-				.rooms
-				.state_accessor
-				.state_added((since_shortstatehash, current_shortstatehash))
-				.boxed()
-				.into_future()
+			StreamExt::into_future(
+				services
+					.rooms
+					.state_accessor
+					.state_added((since_shortstatehash, current_shortstatehash))
+					.boxed(),
+			)
 		})
 		.into();
 
 	let current_state_ids: OptionFuture<_> = full_state
 		.then(|| {
-			services
-				.rooms
-				.state_accessor
-				.state_full_shortids(current_shortstatehash)
-				.expect_ok()
-				.boxed()
-				.into_future()
+			StreamExt::into_future(
+				services
+					.rooms
+					.state_accessor
+					.state_full_shortids(current_shortstatehash)
+					.expect_ok()
+					.boxed(),
+			)
 		})
 		.into();
 

src/api/client/sync/v4.rs

@@ -6,37 +6,37 @@ use std::{
 
 use axum::extract::State;
 use conduwuit::{
-	debug, error, extract_variant,
+	Error, PduCount, Result, debug, error, extract_variant,
 	utils::{
-		math::{ruma_from_usize, usize_from_ruma, usize_from_u64_truncated},
 		BoolExt, IterStream, ReadyExt, TryFutureExtExt,
+		math::{ruma_from_usize, usize_from_ruma, usize_from_u64_truncated},
 	},
-	warn, Error, PduCount, Result,
+	warn,
 };
 use futures::{FutureExt, StreamExt, TryFutureExt};
 use ruma::{
+	MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, RoomId, UInt, UserId,
 	api::client::{
 		error::ErrorKind,
 		sync::sync_events::{
-			self,
+			self, DeviceLists, UnreadNotificationsCount,
 			v4::{SlidingOp, SlidingSyncRoomHero},
-			DeviceLists, UnreadNotificationsCount,
 		},
 	},
 	events::{
-		room::member::{MembershipState, RoomMemberEventContent},
 		AnyRawAccountDataEvent, AnySyncEphemeralRoomEvent, StateEventType,
 		TimelineEventType::*,
+		room::member::{MembershipState, RoomMemberEventContent},
 	},
 	serde::Raw,
-	uint, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, RoomId, UInt, UserId,
+	uint,
 };
 use service::rooms::read_receipt::pack_receipts;
 
 use super::{load_timeline, share_encrypted_room};
 use crate::{
-	client::{filter_rooms, ignored_filter, sync::v5::TodoRooms, DEFAULT_BUMP_TYPES},
 	Ruma,
+	client::{DEFAULT_BUMP_TYPES, filter_rooms, ignored_filter, sync::v5::TodoRooms},
 };
 
 pub(crate) const SINGLE_CONNECTION_SYNC: &str = "single_connection_sync";
@@ -700,14 +700,13 @@ pub(crate) async fn sync_events_v4_route(
 				.await
 				.ok()
 				.or(name),
-			avatar: if let Some(heroes_avatar) = heroes_avatar {
-				ruma::JsOption::Some(heroes_avatar)
-			} else {
-				match services.rooms.state_accessor.get_avatar(room_id).await {
+			avatar: match heroes_avatar {
+				| Some(heroes_avatar) => ruma::JsOption::Some(heroes_avatar),
+				| _ => match services.rooms.state_accessor.get_avatar(room_id).await {
 					| ruma::JsOption::Some(avatar) => ruma::JsOption::from_option(avatar.url),
 					| ruma::JsOption::Null => ruma::JsOption::Null,
 					| ruma::JsOption::Undefined => ruma::JsOption::Undefined,
-				}
+				},
 			},
 			initial: Some(roomsince == &0),
 			is_dm: None,

src/api/client/sync/v5.rs

@@ -6,32 +6,33 @@ use std::{
 
 use axum::extract::State;
 use conduwuit::{
-	debug, error, extract_variant, trace,
+	Error, Result, TypeStateKey, debug, error, extract_variant, trace,
 	utils::{
-		math::{ruma_from_usize, usize_from_ruma},
 		BoolExt, IterStream, ReadyExt, TryFutureExtExt,
+		math::{ruma_from_usize, usize_from_ruma},
 	},
-	warn, Error, Result, TypeStateKey,
+	warn,
 };
 use futures::{FutureExt, StreamExt, TryFutureExt};
 use ruma::{
+	DeviceId, OwnedEventId, OwnedRoomId, RoomId, UInt, UserId,
 	api::client::{
 		error::ErrorKind,
 		sync::sync_events::{self, DeviceLists, UnreadNotificationsCount},
 	},
 	events::{
-		room::member::{MembershipState, RoomMemberEventContent},
 		AnyRawAccountDataEvent, AnySyncEphemeralRoomEvent, StateEventType, TimelineEventType,
+		room::member::{MembershipState, RoomMemberEventContent},
 	},
 	serde::Raw,
-	uint, DeviceId, OwnedEventId, OwnedRoomId, RoomId, UInt, UserId,
+	uint,
 };
-use service::{rooms::read_receipt::pack_receipts, PduCount};
+use service::{PduCount, rooms::read_receipt::pack_receipts};
 
 use super::{filter_rooms, share_encrypted_room};
 use crate::{
-	client::{ignored_filter, sync::load_timeline, DEFAULT_BUMP_TYPES},
 	Ruma,
+	client::{DEFAULT_BUMP_TYPES, ignored_filter, sync::load_timeline},
 };
 
 type SyncInfo<'a> = (&'a UserId, &'a DeviceId, u64, &'a sync_events::v5::Request);
@@ -572,14 +573,13 @@ async fn process_rooms(
 				.await
 				.ok()
 				.or(name),
-			avatar: if let Some(heroes_avatar) = heroes_avatar {
-				ruma::JsOption::Some(heroes_avatar)
-			} else {
-				match services.rooms.state_accessor.get_avatar(room_id).await {
+			avatar: match heroes_avatar {
+				| Some(heroes_avatar) => ruma::JsOption::Some(heroes_avatar),
+				| _ => match services.rooms.state_accessor.get_avatar(room_id).await {
 					| ruma::JsOption::Some(avatar) => ruma::JsOption::from_option(avatar.url),
 					| ruma::JsOption::Null => ruma::JsOption::Null,
 					| ruma::JsOption::Undefined => ruma::JsOption::Undefined,
-				}
+				},
 			},
 			initial: Some(roomsince == &0),
 			is_dm: None,