Use more async closures

Author: shepmaster

compiler/base/orchestrator/src/coordinator.rs

@@ -947,7 +947,7 @@ where
         use versions_error::*;
 
         let [stable, beta, nightly] =
-            [Channel::Stable, Channel::Beta, Channel::Nightly].map(|c| async move {
+            [Channel::Stable, Channel::Beta, Channel::Nightly].map(async |c| {
                 let c = self.select_channel(c).await?;
                 c.versions().await.map_err(VersionsChannelError::from)
             });
@@ -1144,11 +1144,9 @@ where
         let token = mem::take(token);
         token.cancel();
 
-        let channels = [stable, beta, nightly].map(|c| async {
-            match c.take() {
-                Some(c) => c.shutdown().await,
-                _ => Ok(()),
-            }
+        let channels = [stable, beta, nightly].map(async |c| match c.take() {
+            Some(c) => c.shutdown().await,
+            _ => Ok(()),
         });
 
         let [stable, beta, nightly] = channels;
@@ -3081,7 +3079,7 @@ mod tests {
             (Mode::Release, "[optimized]"),
         ];
 
-        let tests = params.into_iter().map(|(mode, expected)| async move {
+        let tests = params.into_iter().map(async |(mode, expected)| {
             let coordinator = new_coordinator();
 
             let request = ExecuteRequest {
@@ -3116,8 +3114,10 @@ mod tests {
         ];
 
         let tests = params.into_iter().flat_map(|(code, works_in)| {
-            Edition::ALL.into_iter().zip(works_in).map(
-                move |(edition, expected_to_work)| async move {
+            Edition::ALL
+                .into_iter()
+                .zip(works_in)
+                .map(async |(edition, expected_to_work)| {
                     let coordinator = new_coordinator();
 
                     let request = ExecuteRequest {
@@ -3137,8 +3137,7 @@ mod tests {
                     coordinator.shutdown().await?;
 
                     Ok::<_, Error>(())
-                },
-            )
+                })
         });
 
         try_join_all(tests).with_timeout().await?;
@@ -3157,7 +3156,7 @@ mod tests {
             ),
         ];
 
-        let tests = params.into_iter().map(|(crate_type, expected)| async move {
+        let tests = params.into_iter().map(async |(crate_type, expected)| {
             let coordinator = new_coordinator();
 
             let request = ExecuteRequest {
@@ -3190,7 +3189,7 @@ mod tests {
 
         let params = [(false, "Running `"), (true, "Running unittests")];
 
-        let tests = params.into_iter().map(|(tests, expected)| async move {
+        let tests = params.into_iter().map(async |(tests, expected)| {
             let coordinator = new_coordinator();
 
             let request = ExecuteRequest {
@@ -3223,7 +3222,7 @@ mod tests {
             (true, "stack backtrace:"),
         ];
 
-        let tests = params.into_iter().map(|(backtrace, expected)| async move {
+        let tests = params.into_iter().map(async |(backtrace, expected)| {
             let coordinator = new_coordinator();
 
             let request = ExecuteRequest {

ui/src/server_axum.rs

@@ -230,7 +230,7 @@ async fn evaluate(
     Extension(db): Extension<Handle>,
     Json(req): Json<api::EvaluateRequest>,
 ) -> Result<Json<api::EvaluateResponse>> {
-    attempt_record_request(db, req, |req| async {
+    attempt_record_request(db, req, async |req| {
         with_coordinator(&factory.0, req, async |c, req| {
             c.execute(req).context(EvaluateSnafu).await
         })
@@ -245,7 +245,7 @@ async fn compile(
     Extension(db): Extension<Handle>,
     Json(req): Json<api::CompileRequest>,
 ) -> Result<Json<api::CompileResponse>> {
-    attempt_record_request(db, req, |req| async {
+    attempt_record_request(db, req, async |req| {
         with_coordinator(&factory.0, req, async |c, req| {
             c.compile(req).context(CompileSnafu).await
         })
@@ -260,7 +260,7 @@ async fn execute(
     Extension(db): Extension<Handle>,
     Json(req): Json<api::ExecuteRequest>,
 ) -> Result<Json<api::ExecuteResponse>> {
-    attempt_record_request(db, req, |req| async {
+    attempt_record_request(db, req, async |req| {
         with_coordinator(&factory.0, req, async |c, req| {
             c.execute(req).context(ExecuteSnafu).await
         })
@@ -275,7 +275,7 @@ async fn format(
     Extension(db): Extension<Handle>,
     Json(req): Json<api::FormatRequest>,
 ) -> Result<Json<api::FormatResponse>> {
-    attempt_record_request(db, req, |req| async {
+    attempt_record_request(db, req, async |req| {
         with_coordinator(&factory.0, req, async |c, req| {
             c.format(req).context(FormatSnafu).await
         })
@@ -290,7 +290,7 @@ async fn clippy(
     Extension(db): Extension<Handle>,
     Json(req): Json<api::ClippyRequest>,
 ) -> Result<Json<api::ClippyResponse>> {
-    attempt_record_request(db, req, |req| async {
+    attempt_record_request(db, req, async |req| {
         with_coordinator(&factory.0, req, async |c, req| {
             c.clippy(req).context(ClippySnafu).await
         })
@@ -305,7 +305,7 @@ async fn miri(
     Extension(db): Extension<Handle>,
     Json(req): Json<api::MiriRequest>,
 ) -> Result<Json<api::MiriResponse>> {
-    attempt_record_request(db, req, |req| async {
+    attempt_record_request(db, req, async |req| {
         with_coordinator(&factory.0, req, async |c, req| {
             c.miri(req).context(MiriSnafu).await
         })
@@ -320,7 +320,7 @@ async fn macro_expansion(
     Extension(db): Extension<Handle>,
     Json(req): Json<api::MacroExpansionRequest>,
 ) -> Result<Json<api::MacroExpansionResponse>> {
-    attempt_record_request(db, req, |req| async {
+    attempt_record_request(db, req, async |req| {
         with_coordinator(&factory.0, req, async |c, req| {
             c.macro_expansion(req).context(MacroExpansionSnafu).await
         })

ui/src/server_axum/websocket.rs

@@ -568,7 +568,7 @@ async fn handle_msg(
                 .spawn({
                     let tx = tx.clone();
                     let meta = meta.clone();
-                    |coordinator| async {
+                    async |coordinator| {
                         let r = handle_execute(
                             token,
                             execution_rx,
@@ -706,13 +706,13 @@ async fn handle_execute_inner(
 
     let mut stdin_tx = Some(stdin_tx);
 
-    let send_stdout = |payload| async {
+    let send_stdout = async |payload| {
         let meta = meta.clone();
         tx.send(Ok(MessageResponse::ExecuteStdout { payload, meta }))
             .await
     };
 
-    let send_stderr = |payload| async {
+    let send_stderr = async |payload| {
         let meta = meta.clone();
         tx.send(Ok(MessageResponse::ExecuteStderr { payload, meta }))
             .await