clippy: Removes redundant async blocks (#31526)

core/src/tower_storage.rs

@@ -241,8 +241,7 @@ impl EtcdTowerStorage {
             .unwrap();
 
         let client = runtime
-            .block_on(async {
-                etcd_client::Client::connect(
+            .block_on(etcd_client::Client::connect(
                 endpoints,
                 tls_config.map(|tls_config| {
                     etcd_client::ConnectOptions::default().with_tls(
@@ -257,9 +256,7 @@ impl EtcdTowerStorage {
                             )),
                     )
                 }),
-                )
-                .await
-            })
+            ))
             .map_err(Self::etdc_to_tower_error)?;
 
         Ok(Self {

program-test/tests/fuzz.rs

@@ -36,21 +36,17 @@ fn simulate_fuzz() {
         processor!(process_instruction),
     );
 
-    let (mut banks_client, payer, last_blockhash) =
-        rt.block_on(async { program_test.start().await });
+    let (mut banks_client, payer, last_blockhash) = rt.block_on(program_test.start());
 
     // the honggfuzz `fuzz!` macro does not allow for async closures,
     // so we have to use the runtime directly to run async functions
-    rt.block_on(async {
-        run_fuzz_instructions(
+    rt.block_on(run_fuzz_instructions(
         &[1, 2, 3, 4, 5],
         &mut banks_client,
         &payer,
         last_blockhash,
         &program_id,
-        )
-        .await
-    });
+    ));
 }
 
 #[test]
@@ -64,20 +60,17 @@ fn simulate_fuzz_with_context() {
         processor!(process_instruction),
     );
 
-    let mut context = rt.block_on(async { program_test.start_with_context().await });
+    let mut context = rt.block_on(program_test.start_with_context());
 
     // the honggfuzz `fuzz!` macro does not allow for async closures,
     // so we have to use the runtime directly to run async functions
-    rt.block_on(async {
-        run_fuzz_instructions(
+    rt.block_on(run_fuzz_instructions(
         &[1, 2, 3, 4, 5],
         &mut context.banks_client,
         &context.payer,
         context.last_blockhash,
         &program_id,
-        )
-        .await
-    });
+    ));
 }
 
 async fn run_fuzz_instructions(

quic-client/src/quic_client.rs

@@ -161,14 +161,14 @@ impl ClientConnection for QuicClientConnection {
         let _lock = ASYNC_TASK_SEMAPHORE.acquire();
         let inner = self.inner.clone();
 
-        let _handle = RUNTIME.spawn(async move { send_data_async(inner, data).await });
+        let _handle = RUNTIME.spawn(send_data_async(inner, data));
         Ok(())
     }
 
     fn send_data_batch_async(&self, buffers: Vec<Vec<u8>>) -> TransportResult<()> {
         let _lock = ASYNC_TASK_SEMAPHORE.acquire();
         let inner = self.inner.clone();
-        let _handle = RUNTIME.spawn(async move { send_data_batch_async(inner, buffers).await });
+        let _handle = RUNTIME.spawn(send_data_batch_async(inner, buffers));
         Ok(())
     }
 

tpu-client/src/nonblocking/tpu_client.rs

@@ -614,16 +614,13 @@ impl LeaderTpuService {
         let t_leader_tpu_service = Some({
             let recent_slots = recent_slots.clone();
             let leader_tpu_cache = leader_tpu_cache.clone();
-            tokio::spawn(async move {
-                Self::run(
+            tokio::spawn(Self::run(
                 rpc_client,
                 recent_slots,
                 leader_tpu_cache,
                 pubsub_client,
                 exit,
-                )
-                .await
-            })
+            ))
         });
 
         Ok(LeaderTpuService {