Update to 2024 edition (#2001)

* Update to 2024 edition

* Update to 2024 edition; fmt, use<> and remove refs

* async functions

subxt/src/backend/chain_head/follow_stream.rs

@@ -218,8 +218,8 @@ impl<Hash> Stream for FollowStream<Hash> {
 pub(super) mod test_utils {
     use super::*;
     use crate::config::substrate::H256;
-    use std::sync::atomic::{AtomicUsize, Ordering};
     use std::sync::Arc;
+    use std::sync::atomic::{AtomicUsize, Ordering};
     use subxt_rpcs::methods::chain_head::{BestBlockChanged, Finalized, Initialized, NewBlock};
 
     /// Given some events, returns a follow stream getter that we can use in
@@ -313,7 +313,7 @@ pub mod test {
         });
 
         let s = FollowStream::new(stream_getter);
-        let out: Vec<_> = s.filter_map(|e| async move { e.ok() }).collect().await;
+        let out: Vec<_> = s.filter_map(async |e| e.ok()).collect().await;
 
         // The expected response, given the above.
         assert_eq!(

subxt/src/backend/chain_head/follow_stream_unpin.rs

@@ -2,8 +2,8 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use super::follow_stream::FollowStream;
 use super::ChainHeadRpcMethods;
+use super::follow_stream::FollowStream;
 use crate::config::{Config, Hash, HashFor};
 use crate::error::Error;
 use futures::stream::{FuturesUnordered, Stream, StreamExt};
@@ -468,7 +468,7 @@ impl<H: Hash> Drop for BlockRef<H> {
 
 #[cfg(test)]
 pub(super) mod test_utils {
-    use super::super::follow_stream::{test_utils::test_stream_getter, FollowStream};
+    use super::super::follow_stream::{FollowStream, test_utils::test_stream_getter};
     use super::*;
     use crate::config::substrate::H256;
 
@@ -573,10 +573,7 @@ mod test {
             10,
         );
 
-        let out: Vec<_> = follow_unpin
-            .filter_map(|e| async move { e.ok() })
-            .collect()
-            .await;
+        let out: Vec<_> = follow_unpin.filter_map(async |e| e.ok()).collect().await;
 
         assert_eq!(
             out,

subxt/src/backend/chain_head/mod.rs

@@ -18,8 +18,8 @@ mod storage_items;
 
 use self::follow_stream_driver::FollowStreamFinalizedHeads;
 use crate::backend::{
-    utils::retry, Backend, BlockRef, BlockRefT, RuntimeVersion, StorageResponse, StreamOf,
-    StreamOfResults, TransactionStatus,
+    Backend, BlockRef, BlockRefT, RuntimeVersion, StorageResponse, StreamOf, StreamOfResults,
+    TransactionStatus, utils::retry,
 };
 use crate::config::{Config, Hash, HashFor};
 use crate::error::{Error, RpcError};
@@ -30,10 +30,10 @@ use futures::{Stream, StreamExt};
 use std::collections::HashMap;
 use std::task::Poll;
 use storage_items::StorageItems;
+use subxt_rpcs::RpcClient;
 use subxt_rpcs::methods::chain_head::{
     FollowEvent, MethodResponse, RuntimeEvent, StorageQuery, StorageQueryType, StorageResultType,
 };
-use subxt_rpcs::RpcClient;
 
 /// Re-export RPC types and methods from [`subxt_rpcs::methods::chain_head`].
 pub mod rpc_methods {
@@ -301,7 +301,7 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for ChainHeadBackend<T> {
                 StorageItems::from_methods(queries, at, &self.follow_handle, self.methods.clone())
                     .await?;
 
-            let stream = storage_items.filter_map(|val| async move {
+            let stream = storage_items.filter_map(async |val| {
                 let val = match val {
                     Ok(val) => val,
                     Err(e) => return Some(Err(e)),
@@ -366,7 +366,7 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for ChainHeadBackend<T> {
             )
             .await?;
 
-            let storage_result_stream = storage_items.filter_map(|val| async move {
+            let storage_result_stream = storage_items.filter_map(async |val| {
                 let val = match val {
                     Ok(val) => val,
                     Err(e) => return Some(Err(e)),
@@ -686,7 +686,7 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for ChainHeadBackend<T> {
                         Poll::Ready(None) => {
                             return Poll::Ready(err_other(
                                 "chainHead_follow stream ended unexpectedly",
-                            ))
+                            ));
                         }
                         Poll::Ready(Some(follow_ev)) => Poll::Ready(follow_ev),
                         Poll::Pending => Poll::Pending,
@@ -722,7 +722,9 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for ChainHeadBackend<T> {
                                 // in which we may lose the finalized block that the TX is in. For now, just error if
                                 // this happens, to prevent the case in which we never see a finalized block and wait
                                 // forever.
-                                return Poll::Ready(err_other("chainHead_follow emitted 'stop' event during transaction submission"));
+                                return Poll::Ready(err_other(
+                                    "chainHead_follow emitted 'stop' event during transaction submission",
+                                ));
                             }
                             _ => {}
                         }
@@ -756,7 +758,11 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for ChainHeadBackend<T> {
                     // If we don't have a finalized block yet, we keep polling for tx progress events.
                     let tx_progress_ev = match tx_progress.poll_next_unpin(cx) {
                         Poll::Pending => return Poll::Pending,
-                        Poll::Ready(None) => return Poll::Ready(err_other("No more transaction progress events, but we haven't seen a Finalized one yet")),
+                        Poll::Ready(None) => {
+                            return Poll::Ready(err_other(
+                                "No more transaction progress events, but we haven't seen a Finalized one yet",
+                            ));
+                        }
                         Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e.into()))),
                         Poll::Ready(Some(Ok(ev))) => ev,
                     };