Refactor to async closures.

Signed-off-by: Jason Volk <jason@zemos.net>

src/api/client/keys.rs

@@ -526,7 +526,7 @@ where
 
 	let mut futures: FuturesUnordered<_> = get_over_federation
 		.into_iter()
-		.map(|(server, vec)| async move {
+		.map(async |(server, vec)| {
 			let mut device_keys_input_fed = BTreeMap::new();
 			for (user_id, keys) in vec {
 				device_keys_input_fed.insert(user_id.to_owned(), keys.clone());
@@ -656,7 +656,7 @@ pub(crate) async fn claim_keys_helper(
 
 	let mut futures: FuturesUnordered<_> = get_over_federation
 		.into_iter()
-		.map(|(server, vec)| async move {
+		.map(async |(server, vec)| {
 			let mut one_time_keys_input_fed = BTreeMap::new();
 			for (user_id, keys) in vec {
 				one_time_keys_input_fed.insert(user_id.clone(), keys.clone());

src/api/client/membership/join.rs

@@ -550,7 +550,7 @@ async fn join_room_by_id_helper_remote(
 				.validate_and_add_event_id_no_fetch(pdu, &room_version_id)
 		})
 		.ready_filter_map(Result::ok)
-		.fold(HashMap::new(), |mut state, (event_id, value)| async move {
+		.fold(HashMap::new(), async |mut state, (event_id, value)| {
 			let pdu = match PduEvent::from_id_val(&event_id, value.clone()) {
 				| Ok(pdu) => pdu,
 				| Err(e) => {

src/api/client/membership/members.rs

@@ -85,7 +85,7 @@ pub(crate) async fn joined_members_route(
 			.state_cache
 			.room_members(&body.room_id)
 			.map(ToOwned::to_owned)
-			.broad_then(|user_id| async move {
+			.broad_then(async |user_id| {
 				let (display_name, avatar_url) = join(
 					services.users.displayname(&user_id).ok(),
 					services.users.avatar_url(&user_id).ok(),

src/api/client/message.rs

@@ -151,9 +151,7 @@ pub(crate) async fn get_message_events_route(
 		.map(IterStream::stream)
 		.into_stream()
 		.flatten()
-		.broad_filter_map(|user_id| async move {
-			get_member_event(&services, room_id, &user_id).await
-		})
+		.broad_filter_map(async |user_id| get_member_event(&services, room_id, &user_id).await)
 		.collect()
 		.await;
 

src/api/client/profile.rs

@@ -350,7 +350,7 @@ pub async fn update_displayname(
 	let all_joined_rooms: Vec<_> = all_joined_rooms
 		.iter()
 		.try_stream()
-		.and_then(|room_id: &OwnedRoomId| async move {
+		.and_then(async |room_id: &OwnedRoomId| {
 			let pdu = PduBuilder::state(user_id.to_string(), &RoomMemberEventContent {
 				displayname: displayname.clone(),
 				membership: MembershipState::Join,
@@ -403,7 +403,7 @@ pub async fn update_avatar_url(
 	let all_joined_rooms: Vec<_> = all_joined_rooms
 		.iter()
 		.try_stream()
-		.and_then(|room_id: &OwnedRoomId| async move {
+		.and_then(async |room_id: &OwnedRoomId| {
 			let pdu = PduBuilder::state(user_id.to_string(), &RoomMemberEventContent {
 				avatar_url: avatar_url.clone(),
 				blurhash: blurhash.clone(),

src/api/client/search.rs

@@ -95,13 +95,13 @@ async fn category_room_events(
 		});
 
 	let results: Vec<_> = rooms
-		.filter_map(|room_id| async move {
+		.filter_map(async |room_id| {
 			check_room_visible(services, sender_user, &room_id, criteria)
 				.await
 				.is_ok()
 				.then_some(room_id)
 		})
-		.filter_map(|room_id| async move {
+		.filter_map(async |room_id| {
 			let query = RoomQuery {
 				room_id: &room_id,
 				user_id: Some(sender_user),
@@ -135,7 +135,7 @@ async fn category_room_events(
 		.iter()
 		.stream()
 		.ready_filter(|_| criteria.include_state.is_some_and(is_true!()))
-		.filter_map(|(room_id, ..)| async move {
+		.filter_map(async |(room_id, ..)| {
 			procure_room_state(services, room_id)
 				.map_ok(|state| (room_id.clone(), state))
 				.await

src/api/client/space.rs

@@ -166,7 +166,7 @@ where
 
 	let next_batch: OptionFuture<_> = queue
 		.pop_front()
-		.map(|(room, _)| async move {
+		.map(async |(room, _)| {
 			parents.insert(room);
 
 			let next_short_room_ids: Vec<_> = parents

src/api/client/sync/mod.rs

@@ -75,7 +75,7 @@ async fn share_encrypted_room(
 		.get_shared_rooms(sender_user, user_id)
 		.ready_filter(|&room_id| Some(room_id) != ignore_room)
 		.map(ToOwned::to_owned)
-		.broad_any(|other_room_id| async move {
+		.broad_any(async |other_room_id| {
 			services
 				.rooms
 				.state_accessor

src/api/client/sync/v3.rs

@@ -237,7 +237,7 @@ pub(crate) async fn build_sync_events(
 		.rooms
 		.state_cache
 		.rooms_invited(sender_user)
-		.fold_default(|mut invited_rooms: BTreeMap<_, _>, (room_id, invite_state)| async move {
+		.fold_default(async |mut invited_rooms: BTreeMap<_, _>, (room_id, invite_state)| {
 			let invite_count = services
 				.rooms
 				.state_cache
@@ -262,7 +262,7 @@ pub(crate) async fn build_sync_events(
 		.rooms
 		.state_cache
 		.rooms_knocked(sender_user)
-		.fold_default(|mut knocked_rooms: BTreeMap<_, _>, (room_id, knock_state)| async move {
+		.fold_default(async |mut knocked_rooms: BTreeMap<_, _>, (room_id, knock_state)| {
 			let knock_count = services
 				.rooms
 				.state_cache
@@ -334,7 +334,7 @@ pub(crate) async fn build_sync_events(
 	let device_list_left: HashSet<_> = left_encrypted_users
 		.into_iter()
 		.stream()
-		.broad_filter_map(|user_id| async move {
+		.broad_filter_map(async |user_id: OwnedUserId| {
 			share_encrypted_room(services, sender_user, &user_id, None)
 				.await
 				.eq(&false)
@@ -620,7 +620,7 @@ async fn load_joined_room(
 		.rooms
 		.read_receipt
 		.readreceipts_since(room_id, since)
-		.filter_map(|(read_user, _, edu)| async move {
+		.filter_map(async |(read_user, _, edu)| {
 			services
 				.users
 				.user_is_ignored(read_user, sender_user)
@@ -806,7 +806,7 @@ async fn load_joined_room(
 		.rooms
 		.typing
 		.last_typing_update(room_id)
-		.and_then(|count| async move {
+		.and_then(async |count| {
 			if count <= since {
 				return Ok(Vec::<Raw<AnySyncEphemeralRoomEvent>>::new());
 			}
@@ -1124,8 +1124,9 @@ async fn calculate_state_incremental<'a>(
 		.fold_default(|(mut dlu, mut leu): pair_of!(HashSet<_>), (content, user_id)| async move {
 			use MembershipState::*;
 
-			let shares_encrypted_room =
-				|user_id| share_encrypted_room(services, sender_user, user_id, Some(room_id));
+			let shares_encrypted_room = async |user_id| {
+				share_encrypted_room(services, sender_user, user_id, Some(room_id)).await
+			};
 
 			match content.membership {
 				| Leave => leu.insert(user_id),

src/api/client/sync/v5.rs

@@ -470,7 +470,7 @@ where
 			.rooms
 			.read_receipt
 			.readreceipts_since(room_id, *roomsince)
-			.filter_map(|(read_user, _ts, v)| async move {
+			.filter_map(async |(read_user, _ts, v)| {
 				services
 					.users
 					.user_is_ignored(read_user, sender_user)
@@ -548,7 +548,7 @@ where
 		let required_state = required_state_request
 			.iter()
 			.stream()
-			.filter_map(|state| async move {
+			.filter_map(async |state| {
 				services
 					.rooms
 					.state_accessor

src/api/client/threads.rs

@@ -1,5 +1,5 @@
 use axum::extract::State;
-use futures::StreamExt;
+use futures::{StreamExt, TryStreamExt};
 use ruma::{api::client::threads::get_threads, uint};
 use tuwunel_core::{
 	Result, at,
@@ -35,18 +35,17 @@ pub(crate) async fn get_threads_route(
 		.rooms
 		.threads
 		.threads_until(body.sender_user(), &body.room_id, from, &body.include)
-		.await?
 		.take(limit)
-		.filter_map(|(count, pdu)| async move {
-			services
+		.try_filter_map(async |(count, pdu)| {
+			Ok(services
 				.rooms
 				.state_accessor
 				.user_can_see_event(body.sender_user(), &body.room_id, &pdu.event_id)
 				.await
-				.then_some((count, pdu))
+				.then_some((count, pdu)))
 		})
-		.collect()
-		.await;
+		.try_collect()
+		.await?;
 
 	Ok(get_threads::v1::Response {
 		next_batch: threads

src/api/server/backfill.rs

@@ -64,7 +64,7 @@ pub(crate) async fn get_backfill_route(
 			.timeline
 			.pdus_rev(None, &body.room_id, Some(from.saturating_add(1)))
 			.try_take(limit)
-			.try_filter_map(|(_, pdu)| async move {
+			.try_filter_map(async |(_, pdu)| {
 				Ok(services
 					.rooms
 					.state_accessor
@@ -72,7 +72,7 @@ pub(crate) async fn get_backfill_route(
 					.await
 					.then_some(pdu))
 			})
-			.try_filter_map(|pdu| async move {
+			.try_filter_map(async |pdu| {
 				Ok(services
 					.rooms
 					.timeline

src/api/server/event_auth.rs

@@ -49,7 +49,7 @@ pub(crate) async fn get_event_authorization_route(
 		.auth_chain
 		.event_ids_iter(room_id, once(body.event_id.borrow()))
 		.ready_filter_map(Result::ok)
-		.filter_map(|id| async move {
+		.filter_map(async |id| {
 			services
 				.rooms
 				.timeline

src/api/server/hierarchy.rs

@@ -45,7 +45,7 @@ pub(crate) async fn get_hierarchy_route(
 			let (children, inaccessible_children) =
 				get_parent_children_via(&room, suggested_only)
 					.stream()
-					.broad_filter_map(|(child, _via)| async move {
+					.broad_filter_map(async |(child, _via)| {
 						match services
 							.rooms
 							.spaces

src/api/server/send.rs

@@ -158,10 +158,11 @@ async fn handle(
 	let results: ResolvedMap = pdus
 		.into_iter()
 		.try_stream()
-		.broad_and_then(|(room_id, pdus): (_, Vec<_>)| {
-			handle_room(services, client, origin, started, room_id, pdus.into_iter())
-				.map_ok(Vec::into_iter)
+		.broad_and_then(async |(room_id, pdus): (_, Vec<_>)| {
+			handle_room(services, client, origin, &started, room_id, pdus.into_iter())
+				.map_ok(ResolvedMap::into_iter)
 				.map_ok(IterStream::try_stream)
+				.await
 		})
 		.try_flatten()
 		.try_collect()
@@ -180,28 +181,27 @@ async fn handle_room(
 	services: &Services,
 	_client: &IpAddr,
 	origin: &ServerName,
-	txn_start_time: Instant,
-	room_id: OwnedRoomId,
+	txn_start_time: &Instant,
+	ref room_id: OwnedRoomId,
 	pdus: impl Iterator<Item = Pdu> + Send,
-) -> Result<Vec<(OwnedEventId, Result)>> {
+) -> Result<ResolvedMap> {
 	let _room_lock = services
 		.rooms
 		.event_handler
 		.mutex_federation
-		.lock(&room_id)
+		.lock(room_id)
 		.await;
 
-	let room_id = &room_id;
 	pdus.try_stream()
-		.and_then(|(_, event_id, value)| async move {
+		.and_then(async |(room_id, event_id, value)| {
 			services.server.check_running()?;
 			let pdu_start_time = Instant::now();
 			let result = services
 				.rooms
 				.event_handler
-				.handle_incoming_pdu(origin, room_id, &event_id, value, true)
-				.await
-				.map(|_| ());
+				.handle_incoming_pdu(origin, &room_id, &event_id, value, true)
+				.map_ok(|_| ())
+				.await;
 
 			debug!(
 				pdu_elapsed = ?pdu_start_time.elapsed(),
@@ -329,7 +329,7 @@ async fn handle_edu_receipt_room(
 		.read
 		.into_iter()
 		.stream()
-		.for_each_concurrent(automatic_width(), |(user_id, user_updates)| async move {
+		.for_each_concurrent(automatic_width(), async |(user_id, user_updates)| {
 			handle_edu_receipt_room_user(services, origin, room_id, &user_id, user_updates).await;
 		})
 		.await;
@@ -368,7 +368,7 @@ async fn handle_edu_receipt_room_user(
 		.event_ids
 		.into_iter()
 		.stream()
-		.for_each_concurrent(automatic_width(), |event_id| async move {
+		.for_each_concurrent(automatic_width(), async |event_id| {
 			let user_data = [(user_id.to_owned(), data.clone())];
 			let receipts = [(ReceiptType::Read, BTreeMap::from(user_data))];
 			let content = [(event_id.clone(), BTreeMap::from(receipts))];

src/api/server/send_join.rs

@@ -242,7 +242,7 @@ async fn create_join_event(
 		.rooms
 		.auth_chain
 		.event_ids_iter(room_id, starting_events)
-		.broad_and_then(|event_id| async move {
+		.broad_and_then(async |event_id| {
 			services
 				.rooms
 				.timeline

src/api/server/state.rs

@@ -56,7 +56,7 @@ pub(crate) async fn get_room_state_route(
 		.rooms
 		.auth_chain
 		.event_ids_iter(&body.room_id, once(body.event_id.borrow()))
-		.and_then(|id| async move { services.rooms.timeline.get_pdu_json(&id).await })
+		.and_then(async |id| services.rooms.timeline.get_pdu_json(&id).await)
 		.and_then(|pdu| {
 			services
 				.sending

src/api/server/user.rs

@@ -40,7 +40,7 @@ pub(crate) async fn get_devices_route(
 		devices: services
 			.users
 			.all_devices_metadata(user_id)
-			.filter_map(|metadata| async move {
+			.filter_map(async |metadata| {
 				let device_id = metadata.device_id.clone();
 				let device_id_clone = device_id.clone();
 				let device_id_string = device_id.as_str().to_owned();