Auto merge of #120361 - compiler-errors:async-closures, r=oli-obk

Rework support for async closures; allow them to return futures that borrow from the closure's captures

This PR implements a new lowering for async closures via `TyKind::CoroutineClosure` which handles the curious relationship between the closure and the coroutine that it returns.

I wrote up a bunch in [this hackmd](https://hackmd.io/`@compiler-errors/S1HvqQxca)` which will be copied to the dev guide after this PR lands, and hopefully left sufficient comments in the source code explaining why this change is as large as it is.

This also necessitates that they begin implementing the `AsyncFn`-family of traits, rather than the `Fn`-family of traits -- if you need `Fn` implementations, you should probably use the non-sugar `|| async {}` syntax instead.

Notably this PR does not yet implement `async Fn()` syntax sugar for bounds, but I expect to add those soon (**edit:** #120392). For now, users must use `AsyncFn()` traits directly, which necessitates adding the `async_fn_traits` feature gate as well. I will add this as a follow-up very soon.

r? oli-obk

This is based on top of #120322, but that PR is minimal.

39 files changed, 613 insertions, 93 deletions

diff --git a/tests/ui/async-await/async-borrowck-escaping-closure-error.rs b/tests/ui/async-await/async-borrowck-escaping-closure-error.rs
index f8ff9186842..2a3e382e118 100644
--- a/tests/ui/async-await/async-borrowck-escaping-closure-error.rs
+++ b/tests/ui/async-await/async-borrowck-escaping-closure-error.rs
@@ -1,10 +1,11 @@
 // edition:2018
-// check-pass
 
 #![feature(async_closure)]
 fn foo() -> Box<dyn std::future::Future<Output = u32>> {
     let x = 0u32;
     Box::new((async || x)())
+    //~^ ERROR cannot return value referencing local variable `x`
+    //~| ERROR cannot return value referencing temporary value
 }
 
 fn main() {
diff --git a/tests/ui/async-await/async-borrowck-escaping-closure-error.stderr b/tests/ui/async-await/async-borrowck-escaping-closure-error.stderr
new file mode 100644
index 00000000000..be67c78221a
--- /dev/null
+++ b/tests/ui/async-await/async-borrowck-escaping-closure-error.stderr
@@ -0,0 +1,21 @@
+error[E0515]: cannot return value referencing local variable `x`
+  --> $DIR/async-borrowck-escaping-closure-error.rs:6:5
+   |
+LL |     Box::new((async || x)())
+   |     ^^^^^^^^^------------^^^
+   |     |        |
+   |     |        `x` is borrowed here
+   |     returns a value referencing data owned by the current function
+
+error[E0515]: cannot return value referencing temporary value
+  --> $DIR/async-borrowck-escaping-closure-error.rs:6:5
+   |
+LL |     Box::new((async || x)())
+   |     ^^^^^^^^^------------^^^
+   |     |        |
+   |     |        temporary value created here
+   |     returns a value referencing data owned by the current function
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/async-await/async-closures/arg-mismatch.rs b/tests/ui/async-await/async-closures/arg-mismatch.rs
new file mode 100644
index 00000000000..650e13677bc
--- /dev/null
+++ b/tests/ui/async-await/async-closures/arg-mismatch.rs
@@ -0,0 +1,15 @@
+// aux-build:block-on.rs
+// edition:2021
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn main() {
+    block_on::block_on(async {
+        let c = async |x| {};
+        c(1i32).await;
+        c(2usize).await;
+        //~^ ERROR mismatched types
+    });
+}
diff --git a/tests/ui/async-await/async-closures/arg-mismatch.stderr b/tests/ui/async-await/async-closures/arg-mismatch.stderr
new file mode 100644
index 00000000000..70853ae2815
--- /dev/null
+++ b/tests/ui/async-await/async-closures/arg-mismatch.stderr
@@ -0,0 +1,21 @@
+error[E0308]: mismatched types
+  --> $DIR/arg-mismatch.rs:12:11
+   |
+LL |         c(2usize).await;
+   |         - ^^^^^^ expected `i32`, found `usize`
+   |         |
+   |         arguments to this function are incorrect
+   |
+note: closure parameter defined here
+  --> $DIR/arg-mismatch.rs:10:24
+   |
+LL |         let c = async |x| {};
+   |                        ^
+help: change the type of the numeric literal from `usize` to `i32`
+   |
+LL |         c(2i32).await;
+   |            ~~~
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/async-closures/async-fn-mut-for-async-fn.rs b/tests/ui/async-await/async-closures/async-fn-mut-for-async-fn.rs
new file mode 100644
index 00000000000..8d7dc6a276b
--- /dev/null
+++ b/tests/ui/async-await/async-closures/async-fn-mut-for-async-fn.rs
@@ -0,0 +1,23 @@
+// aux-build:block-on.rs
+// edition:2021
+// run-pass
+
+// FIXME(async_closures): When `fn_sig_for_fn_abi` is fixed, remove this.
+// ignore-pass (test emits codegen-time warnings)
+
+#![feature(async_closure, async_fn_traits)]
+
+extern crate block_on;
+
+use std::ops::AsyncFnMut;
+
+fn main() {
+    block_on::block_on(async {
+        let x = async || {};
+
+        async fn needs_async_fn_mut(mut x: impl AsyncFnMut()) {
+            x().await;
+        }
+        needs_async_fn_mut(x).await;
+    });
+}
diff --git a/tests/ui/async-await/async-closures/async-fn-once-for-async-fn.rs b/tests/ui/async-await/async-closures/async-fn-once-for-async-fn.rs
new file mode 100644
index 00000000000..4afc43fe6bd
--- /dev/null
+++ b/tests/ui/async-await/async-closures/async-fn-once-for-async-fn.rs
@@ -0,0 +1,23 @@
+// aux-build:block-on.rs
+// edition:2021
+// run-pass
+
+// FIXME(async_closures): When `fn_sig_for_fn_abi` is fixed, remove this.
+// ignore-pass (test emits codegen-time warnings)
+
+#![feature(async_closure, async_fn_traits)]
+
+extern crate block_on;
+
+use std::ops::AsyncFnOnce;
+
+fn main() {
+    block_on::block_on(async {
+        let x = async || {};
+
+        async fn needs_async_fn_once(x: impl AsyncFnOnce()) {
+            x().await;
+        }
+        needs_async_fn_once(x).await;
+    });
+}
diff --git a/tests/ui/async-await/async-closures/auxiliary/block-on.rs b/tests/ui/async-await/async-closures/auxiliary/block-on.rs
new file mode 100644
index 00000000000..3c27548b865
--- /dev/null
+++ b/tests/ui/async-await/async-closures/auxiliary/block-on.rs
@@ -0,0 +1,20 @@
+// edition: 2021
+
+#![feature(async_closure, noop_waker, async_fn_traits)]
+
+use std::future::Future;
+use std::pin::pin;
+use std::task::*;
+
+pub fn block_on<T>(fut: impl Future<Output = T>) -> T {
+    let mut fut = pin!(fut);
+    // Poll loop, just to test the future...
+    let ctx = &mut Context::from_waker(Waker::noop());
+
+    loop {
+        match unsafe { fut.as_mut().poll(ctx) } {
+            Poll::Pending => {}
+            Poll::Ready(t) => break t,
+        }
+    }
+}
diff --git a/tests/ui/async-await/async-closures/await-inference-guidance.rs b/tests/ui/async-await/async-closures/await-inference-guidance.rs
new file mode 100644
index 00000000000..3702915cbad
--- /dev/null
+++ b/tests/ui/async-await/async-closures/await-inference-guidance.rs
@@ -0,0 +1,16 @@
+// aux-build:block-on.rs
+// edition:2021
+// run-pass
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn main() {
+    block_on::block_on(async {
+        let x = async |x: &str| -> String { x.to_owned() };
+        let mut s = x("hello, world").await;
+        s.truncate(4);
+        println!("{s}");
+    });
+}
diff --git a/tests/ui/async-await/async-closures/brand.rs b/tests/ui/async-await/async-closures/brand.rs
new file mode 100644
index 00000000000..3bda7737bb4
--- /dev/null
+++ b/tests/ui/async-await/async-closures/brand.rs
@@ -0,0 +1,26 @@
+// aux-build:block-on.rs
+// edition:2021
+// build-pass
+
+#![feature(async_closure, async_fn_traits)]
+
+extern crate block_on;
+
+use std::future::Future;
+use std::marker::PhantomData;
+use std::ops::AsyncFn;
+
+struct S;
+struct B<'b>(PhantomData<&'b mut &'b mut ()>);
+
+impl S {
+    async fn q<F: AsyncFn(B<'_>)>(self, f: F) {
+        f(B(PhantomData)).await;
+    }
+}
+
+fn main() {
+    block_on::block_on(async {
+        S.q(async |b: B<'_>| { println!("...") }).await;
+    });
+}
diff --git a/tests/ui/async-await/async-closures/def-path.rs b/tests/ui/async-await/async-closures/def-path.rs
index 2883a1715b0..87e99ddda64 100644
--- a/tests/ui/async-await/async-closures/def-path.rs
+++ b/tests/ui/async-await/async-closures/def-path.rs
@@ -8,7 +8,7 @@ fn main() {
     //~^ NOTE the expected `async` closure body
     let () = x();
     //~^ ERROR mismatched types
-    //~| NOTE this expression has type `{static main::{closure#0}::{closure#0} upvar_tys=
+    //~| NOTE this expression has type `{static main::{closure#0}::{closure#0}<
     //~| NOTE expected `async` closure body, found `()`
-    //~| NOTE expected `async` closure body `{static main::{closure#0}::{closure#0}
+    //~| NOTE expected `async` closure body `{static main::{closure#0}::{closure#0}<
 }
diff --git a/tests/ui/async-await/async-closures/def-path.stderr b/tests/ui/async-await/async-closures/def-path.stderr
index 4b37e50aac4..dae45825f37 100644
--- a/tests/ui/async-await/async-closures/def-path.stderr
+++ b/tests/ui/async-await/async-closures/def-path.stderr
@@ -5,11 +5,11 @@ LL |     let x = async || {};
    |                      -- the expected `async` closure body
 LL |
 LL |     let () = x();
-   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0} upvar_tys=?7t witness=?8t}`
+   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0}<?7t> upvar_tys=?15t witness=?6t}`
    |         |
    |         expected `async` closure body, found `()`
    |
-   = note: expected `async` closure body `{static main::{closure#0}::{closure#0} upvar_tys=?7t witness=?8t}`
+   = note: expected `async` closure body `{static main::{closure#0}::{closure#0}<?7t> upvar_tys=?15t witness=?6t}`
                          found unit type `()`
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/async-await/async-closures/drop.rs b/tests/ui/async-await/async-closures/drop.rs
new file mode 100644
index 00000000000..1b7f2f8a600
--- /dev/null
+++ b/tests/ui/async-await/async-closures/drop.rs
@@ -0,0 +1,40 @@
+// aux-build:block-on.rs
+// edition:2018
+// run-pass
+// check-run-results
+
+#![feature(async_closure, async_fn_traits)]
+#![allow(unused)]
+
+extern crate block_on;
+
+use std::ops::AsyncFnOnce;
+
+struct DropMe(i32);
+
+impl Drop for DropMe {
+    fn drop(&mut self) {
+        println!("{} was dropped", self.0);
+    }
+}
+
+async fn call_once(f: impl AsyncFnOnce()) {
+    println!("before call");
+    let fut = Box::pin(f());
+    println!("after call");
+    drop(fut);
+    println!("future dropped");
+}
+
+fn main() {
+    block_on::block_on(async {
+        let d = DropMe(42);
+        let async_closure = async move || {
+            let d = &d;
+            println!("called");
+        };
+
+        call_once(async_closure).await;
+        println!("after");
+    });
+}
diff --git a/tests/ui/async-await/async-closures/drop.run.stdout b/tests/ui/async-await/async-closures/drop.run.stdout
new file mode 100644
index 00000000000..ab233f491ba
--- /dev/null
+++ b/tests/ui/async-await/async-closures/drop.run.stdout
@@ -0,0 +1,5 @@
+before call
+after call
+42 was dropped
+future dropped
+after
diff --git a/tests/ui/async-await/async-closures/higher-ranked-return.rs b/tests/ui/async-await/async-closures/higher-ranked-return.rs
new file mode 100644
index 00000000000..d98779c6ea3
--- /dev/null
+++ b/tests/ui/async-await/async-closures/higher-ranked-return.rs
@@ -0,0 +1,18 @@
+// aux-build:block-on.rs
+// edition:2021
+
+// known-bug: unknown
+// Borrow checking doesn't like that higher-ranked output...
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn main() {
+    block_on::block_on(async {
+        let x = async move |x: &str| -> &str {
+            x
+        };
+        let s = x("hello!").await;
+    });
+}
diff --git a/tests/ui/async-await/async-closures/higher-ranked-return.stderr b/tests/ui/async-await/async-closures/higher-ranked-return.stderr
new file mode 100644
index 00000000000..268631f67cd
--- /dev/null
+++ b/tests/ui/async-await/async-closures/higher-ranked-return.stderr
@@ -0,0 +1,14 @@
+error: lifetime may not live long enough
+  --> $DIR/higher-ranked-return.rs:13:46
+   |
+LL |           let x = async move |x: &str| -> &str {
+   |  ________________________________-________----_^
+   | |                                |        |
+   | |                                |        return type of async closure `{async closure body@$DIR/higher-ranked-return.rs:13:46: 15:10}` contains a lifetime `'2`
+   | |                                let's call the lifetime of this reference `'1`
+LL | |             x
+LL | |         };
+   | |_________^ returning this value requires that `'1` must outlive `'2`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/async-closures/higher-ranked.rs b/tests/ui/async-await/async-closures/higher-ranked.rs
index f0bdcf691ae..17b5116cceb 100644
--- a/tests/ui/async-await/async-closures/higher-ranked.rs
+++ b/tests/ui/async-await/async-closures/higher-ranked.rs
@@ -1,12 +1,16 @@
+// aux-build:block-on.rs
 // edition:2021
+// build-pass
 
 #![feature(async_closure)]
 
+extern crate block_on;
+
 fn main() {
-    let x = async move |x: &str| {
-        //~^ ERROR lifetime may not live long enough
-        // This error is proof that the `&str` type is higher-ranked.
-        // This won't work until async closures are fully impl'd.
-        println!("{x}");
-    };
+    block_on::block_on(async {
+        let x = async move |x: &str| {
+            println!("{x}");
+        };
+        x("hello!").await;
+    });
 }
diff --git a/tests/ui/async-await/async-closures/higher-ranked.stderr b/tests/ui/async-await/async-closures/higher-ranked.stderr
deleted file mode 100644
index fb02a15b079..00000000000
--- a/tests/ui/async-await/async-closures/higher-ranked.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error: lifetime may not live long enough
-  --> $DIR/higher-ranked.rs:6:34
-   |
-LL |       let x = async move |x: &str| {
-   |  ____________________________-___-_^
-   | |                            |   |
-   | |                            |   return type of closure `{async closure body@$DIR/higher-ranked.rs:6:34: 11:6}` contains a lifetime `'2`
-   | |                            let's call the lifetime of this reference `'1`
-LL | |
-LL | |         // This error is proof that the `&str` type is higher-ranked.
-LL | |         // This won't work until async closures are fully impl'd.
-LL | |         println!("{x}");
-LL | |     };
-   | |_____^ returning this value requires that `'1` must outlive `'2`
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/async-await/async-closures/is-not-fn.rs b/tests/ui/async-await/async-closures/is-not-fn.rs
new file mode 100644
index 00000000000..94c8e8563bd
--- /dev/null
+++ b/tests/ui/async-await/async-closures/is-not-fn.rs
@@ -0,0 +1,12 @@
+// edition:2021
+
+#![feature(async_closure)]
+
+fn main() {
+    fn needs_fn(x: impl FnOnce()) {}
+    needs_fn(async || {});
+    //~^ ERROR expected a `FnOnce()` closure, found `{coroutine-closure@
+    // FIXME(async_closures): This should explain in more detail how async fns don't
+    // implement the regular `Fn` traits. Or maybe we should just fix it and make them
+    // when there are no upvars or whatever.
+}
diff --git a/tests/ui/async-await/async-closures/is-not-fn.stderr b/tests/ui/async-await/async-closures/is-not-fn.stderr
new file mode 100644
index 00000000000..12da4b1fc6f
--- /dev/null
+++ b/tests/ui/async-await/async-closures/is-not-fn.stderr
@@ -0,0 +1,19 @@
+error[E0277]: expected a `FnOnce()` closure, found `{coroutine-closure@$DIR/is-not-fn.rs:7:14: 7:22}`
+  --> $DIR/is-not-fn.rs:7:14
+   |
+LL |     needs_fn(async || {});
+   |     -------- ^^^^^^^^^^^ expected an `FnOnce()` closure, found `{coroutine-closure@$DIR/is-not-fn.rs:7:14: 7:22}`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the trait `FnOnce<()>` is not implemented for `{coroutine-closure@$DIR/is-not-fn.rs:7:14: 7:22}`
+   = note: wrap the `{coroutine-closure@$DIR/is-not-fn.rs:7:14: 7:22}` in a closure with no arguments: `|| { /* code */ }`
+note: required by a bound in `needs_fn`
+  --> $DIR/is-not-fn.rs:6:25
+   |
+LL |     fn needs_fn(x: impl FnOnce()) {}
+   |                         ^^^^^^^^ required by this bound in `needs_fn`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/async-closures/mangle.rs b/tests/ui/async-await/async-closures/mangle.rs
new file mode 100644
index 00000000000..98065c3c711
--- /dev/null
+++ b/tests/ui/async-await/async-closures/mangle.rs
@@ -0,0 +1,36 @@
+// aux-build:block-on.rs
+// edition:2021
+// build-pass
+// revisions: v0 legacy
+//[v0] compile-flags: -Csymbol-mangling-version=v0
+//[legacy] compile-flags: -Csymbol-mangling-version=legacy -Zunstable-options
+
+// FIXME(async_closures): When `fn_sig_for_fn_abi` is fixed, remove this.
+// ignore-pass (test emits codegen-time warnings)
+
+#![feature(async_closure, noop_waker, async_fn_traits)]
+
+extern crate block_on;
+
+use std::future::Future;
+use std::ops::{AsyncFnMut, AsyncFnOnce};
+use std::pin::pin;
+use std::task::*;
+
+async fn call_mut(f: &mut impl AsyncFnMut()) {
+    f().await;
+}
+
+async fn call_once(f: impl AsyncFnOnce()) {
+    f().await;
+}
+
+fn main() {
+    block_on::block_on(async {
+        let mut async_closure = async move || {
+            println!("called");
+        };
+        call_mut(&mut async_closure).await;
+        call_once(async_closure).await;
+    });
+}
diff --git a/tests/ui/async-await/async-closures/move-consuming-capture.rs b/tests/ui/async-await/async-closures/move-consuming-capture.rs
new file mode 100644
index 00000000000..b8964c571f9
--- /dev/null
+++ b/tests/ui/async-await/async-closures/move-consuming-capture.rs
@@ -0,0 +1,20 @@
+// aux-build:block-on.rs
+// edition:2021
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+struct NoCopy;
+
+fn main() {
+    block_on::block_on(async {
+        let s = NoCopy;
+        let x = async move || {
+            drop(s);
+        };
+        x().await;
+        x().await;
+        //~^ ERROR use of moved value: `x`
+    });
+}
diff --git a/tests/ui/async-await/async-closures/move-consuming-capture.stderr b/tests/ui/async-await/async-closures/move-consuming-capture.stderr
new file mode 100644
index 00000000000..2c2a0d1162d
--- /dev/null
+++ b/tests/ui/async-await/async-closures/move-consuming-capture.stderr
@@ -0,0 +1,17 @@
+error[E0382]: use of moved value: `x`
+  --> $DIR/move-consuming-capture.rs:17:9
+   |
+LL |         let x = async move || {
+   |             - move occurs because `x` has type `{coroutine-closure@$DIR/move-consuming-capture.rs:13:17: 13:30}`, which does not implement the `Copy` trait
+...
+LL |         x().await;
+   |         --- `x` moved due to this method call
+LL |         x().await;
+   |         ^ value used here after move
+   |
+note: `async_call_once` takes ownership of the receiver `self`, which moves `x`
+  --> $SRC_DIR/core/src/ops/async_function.rs:LL:COL
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/async-await/async-closures/move-is-async-fn.rs b/tests/ui/async-await/async-closures/move-is-async-fn.rs
new file mode 100644
index 00000000000..943c0629541
--- /dev/null
+++ b/tests/ui/async-await/async-closures/move-is-async-fn.rs
@@ -0,0 +1,21 @@
+// aux-build:block-on.rs
+// edition:2021
+// build-pass
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn main() {
+    block_on::block_on(async {
+        let s = String::from("hello, world");
+        let c = async move || {
+            println!("{s}");
+        };
+        c().await;
+        c().await;
+
+        fn is_static<T: 'static>(_: T) {}
+        is_static(c);
+    });
+}
diff --git a/tests/ui/async-await/async-closures/mutate.rs b/tests/ui/async-await/async-closures/mutate.rs
new file mode 100644
index 00000000000..cc1df5f034f
--- /dev/null
+++ b/tests/ui/async-await/async-closures/mutate.rs
@@ -0,0 +1,19 @@
+// aux-build:block-on.rs
+// edition:2021
+// run-pass
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn main() {
+    block_on::block_on(async {
+        let mut prefix = String::from("Hello");
+        let mut c = async move |x: &str| {
+            prefix.push(',');
+            println!("{prefix} {x}!")
+        };
+        c("world").await;
+        c("rust").await;
+    });
+}
diff --git a/tests/ui/async-await/async-closures/not-lending.rs b/tests/ui/async-await/async-closures/not-lending.rs
new file mode 100644
index 00000000000..90832e1a074
--- /dev/null
+++ b/tests/ui/async-await/async-closures/not-lending.rs
@@ -0,0 +1,21 @@
+// aux-build:block-on.rs
+// edition:2021
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+// Make sure that we can't make an async closure that evaluates to a self-borrow.
+// i.e. that the generator may reference captures, but the future's return type can't.
+
+fn main() {
+    block_on::block_on(async {
+        let s = String::new();
+        let x = async move || -> &String { &s };
+        //~^ ERROR lifetime may not live long enough
+
+        let s = String::new();
+        let x = async move || { &s };
+        //~^ ERROR lifetime may not live long enough
+    });
+}
diff --git a/tests/ui/async-await/async-closures/not-lending.stderr b/tests/ui/async-await/async-closures/not-lending.stderr
new file mode 100644
index 00000000000..1713e49b551
--- /dev/null
+++ b/tests/ui/async-await/async-closures/not-lending.stderr
@@ -0,0 +1,24 @@
+error: lifetime may not live long enough
+  --> $DIR/not-lending.rs:14:42
+   |
+LL |         let x = async move || -> &String { &s };
+   |                 ------------------------ ^^^^^^ returning this value requires that `'1` must outlive `'2`
+   |                 |                |
+   |                 |                return type of async closure `{async closure body@$DIR/not-lending.rs:14:42: 14:48}` contains a lifetime `'2`
+   |                 lifetime `'1` represents this closure's body
+   |
+   = note: closure implements `Fn`, so references to captured variables can't escape the closure
+
+error: lifetime may not live long enough
+  --> $DIR/not-lending.rs:18:31
+   |
+LL |         let x = async move || { &s };
+   |                 ------------- ^^^^^^ returning this value requires that `'1` must outlive `'2`
+   |                 |           |
+   |                 |           return type of async closure `{async closure body@$DIR/not-lending.rs:18:31: 18:37}` contains a lifetime `'2`
+   |                 lifetime `'1` represents this closure's body
+   |
+   = note: closure implements `Fn`, so references to captured variables can't escape the closure
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/async-closures/return-type-mismatch.rs b/tests/ui/async-await/async-closures/return-type-mismatch.rs
new file mode 100644
index 00000000000..9ad6be0b6e6
--- /dev/null
+++ b/tests/ui/async-await/async-closures/return-type-mismatch.rs
@@ -0,0 +1,14 @@
+// aux-build:block-on.rs
+// edition:2021
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn main() {
+    block_on::block_on(async {
+        let x = async || -> i32 { 0 };
+        let y: usize = x().await;
+        //~^ ERROR mismatched types
+    });
+}
diff --git a/tests/ui/async-await/async-closures/return-type-mismatch.stderr b/tests/ui/async-await/async-closures/return-type-mismatch.stderr
new file mode 100644
index 00000000000..53841f62777
--- /dev/null
+++ b/tests/ui/async-await/async-closures/return-type-mismatch.stderr
@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/return-type-mismatch.rs:11:24
+   |
+LL |         let y: usize = x().await;
+   |                        ^^^^^^^^^ expected `usize`, found `i32`
+   |
+help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit
+   |
+LL |         let y: usize = x().await.try_into().unwrap();
+   |                                 ++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/async-closures/wrong-fn-kind.rs b/tests/ui/async-await/async-closures/wrong-fn-kind.rs
new file mode 100644
index 00000000000..24828832531
--- /dev/null
+++ b/tests/ui/async-await/async-closures/wrong-fn-kind.rs
@@ -0,0 +1,18 @@
+// edition:2021
+
+// FIXME(async_closures): This needs a better error message!
+
+#![feature(async_closure, async_fn_traits)]
+
+use std::ops::AsyncFn;
+
+fn main() {
+    fn needs_async_fn(_: impl AsyncFn()) {}
+
+    let mut x = 1;
+    needs_async_fn(async || {
+        //~^ ERROR i16: ops::async_function::internal_implementation_detail::AsyncFnKindHelper<i8>
+        // FIXME: Should say "closure is AsyncFnMut but it needs AsyncFn" or sth.
+        x += 1;
+    });
+}
diff --git a/tests/ui/async-await/async-closures/wrong-fn-kind.stderr b/tests/ui/async-await/async-closures/wrong-fn-kind.stderr
new file mode 100644
index 00000000000..ef95e6a211c
--- /dev/null
+++ b/tests/ui/async-await/async-closures/wrong-fn-kind.stderr
@@ -0,0 +1,22 @@
+error[E0277]: the trait bound `i16: ops::async_function::internal_implementation_detail::AsyncFnKindHelper<i8>` is not satisfied
+  --> $DIR/wrong-fn-kind.rs:13:20
+   |
+LL |       needs_async_fn(async || {
+   |  _____--------------_^
+   | |     |
+   | |     required by a bound introduced by this call
+LL | |
+LL | |         // FIXME: Should say "closure is AsyncFnMut but it needs AsyncFn" or sth.
+LL | |         x += 1;
+LL | |     });
+   | |_____^ the trait `ops::async_function::internal_implementation_detail::AsyncFnKindHelper<i8>` is not implemented for `i16`
+   |
+note: required by a bound in `needs_async_fn`
+  --> $DIR/wrong-fn-kind.rs:10:31
+   |
+LL |     fn needs_async_fn(_: impl AsyncFn()) {}
+   |                               ^^^^^^^^^ required by this bound in `needs_async_fn`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/issue-74072-lifetime-name-annotations.rs b/tests/ui/async-await/issue-74072-lifetime-name-annotations.rs
index 95683241aba..904d28fb0a7 100644
--- a/tests/ui/async-await/issue-74072-lifetime-name-annotations.rs
+++ b/tests/ui/async-await/issue-74072-lifetime-name-annotations.rs
@@ -12,6 +12,8 @@ pub async fn async_fn(x: &mut i32) -> &i32 {
 
 pub fn async_closure(x: &mut i32) -> impl Future<Output=&i32> {
     (async move || {
+        //~^ ERROR lifetime may not live long enough
+        //~| ERROR temporary value dropped while borrowed
         let y = &*x;
         *x += 1; //~ ERROR cannot assign to `*x` because it is borrowed
         y
@@ -20,6 +22,8 @@ pub fn async_closure(x: &mut i32) -> impl Future<Output=&i32> {
 
 pub fn async_closure_explicit_return_type(x: &mut i32) -> impl Future<Output=&i32> {
     (async move || -> &i32 {
+        //~^ ERROR lifetime may not live long enough
+        //~| ERROR temporary value dropped while borrowed
         let y = &*x;
         *x += 1; //~ ERROR cannot assign to `*x` because it is borrowed
         y
diff --git a/tests/ui/async-await/issue-74072-lifetime-name-annotations.stderr b/tests/ui/async-await/issue-74072-lifetime-name-annotations.stderr
index 628ba1a4818..bdf2820887c 100644
--- a/tests/ui/async-await/issue-74072-lifetime-name-annotations.stderr
+++ b/tests/ui/async-await/issue-74072-lifetime-name-annotations.stderr
@@ -11,7 +11,7 @@ LL |     y
    |     - returning this value requires that `*x` is borrowed for `'1`
 
 error[E0506]: cannot assign to `*x` because it is borrowed
-  --> $DIR/issue-74072-lifetime-name-annotations.rs:16:9
+  --> $DIR/issue-74072-lifetime-name-annotations.rs:18:9
    |
 LL |         let y = &*x;
    |                 --- `*x` is borrowed here
@@ -22,20 +22,92 @@ LL |         y
 LL |     })()
    |     - return type of async closure is &'1 i32
 
+error: lifetime may not live long enough
+  --> $DIR/issue-74072-lifetime-name-annotations.rs:14:20
+   |
+LL |       (async move || {
+   |  ______-------------_^
+   | |      |           |
+   | |      |           return type of async closure `{async closure body@$DIR/issue-74072-lifetime-name-annotations.rs:14:20: 20:6}` contains a lifetime `'2`
+   | |      lifetime `'1` represents this closure's body
+LL | |
+LL | |
+LL | |         let y = &*x;
+LL | |         *x += 1;
+LL | |         y
+LL | |     })()
+   | |_____^ returning this value requires that `'1` must outlive `'2`
+   |
+   = note: closure implements `FnMut`, so references to captured variables can't escape the closure
+
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/issue-74072-lifetime-name-annotations.rs:14:5
+   |
+LL |    pub fn async_closure(x: &mut i32) -> impl Future<Output=&i32> {
+   |                            - let's call the lifetime of this reference `'1`
+LL | //     (async move || {
+LL | ||
+LL | ||
+LL | ||         let y = &*x;
+LL | ||         *x += 1;
+LL | ||         y
+LL | ||     })()
+   | ||______^_- argument requires that borrow lasts for `'1`
+   | |_______|
+   |         creates a temporary value which is freed while still in use
+LL |    }
+   |    - temporary value is freed at the end of this statement
+
 error[E0506]: cannot assign to `*x` because it is borrowed
-  --> $DIR/issue-74072-lifetime-name-annotations.rs:24:9
+  --> $DIR/issue-74072-lifetime-name-annotations.rs:28:9
    |
-LL |     (async move || -> &i32 {
-   |                       - let's call the lifetime of this reference `'1`
 LL |         let y = &*x;
    |                 --- `*x` is borrowed here
 LL |         *x += 1;
    |         ^^^^^^^ `*x` is assigned to here but it was already borrowed
 LL |         y
    |         - returning this value requires that `*x` is borrowed for `'1`
+LL |     })()
+   |     - return type of async closure is &'1 i32
+
+error: lifetime may not live long enough
+  --> $DIR/issue-74072-lifetime-name-annotations.rs:24:28
+   |
+LL |       (async move || -> &i32 {
+   |  ______---------------------_^
+   | |      |                |
+   | |      |                return type of async closure `{async closure body@$DIR/issue-74072-lifetime-name-annotations.rs:24:28: 30:6}` contains a lifetime `'2`
+   | |      lifetime `'1` represents this closure's body
+LL | |
+LL | |
+LL | |         let y = &*x;
+LL | |         *x += 1;
+LL | |         y
+LL | |     })()
+   | |_____^ returning this value requires that `'1` must outlive `'2`
+   |
+   = note: closure implements `FnMut`, so references to captured variables can't escape the closure
+
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/issue-74072-lifetime-name-annotations.rs:24:5
+   |
+LL |    pub fn async_closure_explicit_return_type(x: &mut i32) -> impl Future<Output=&i32> {
+   |                                                 - let's call the lifetime of this reference `'1`
+LL | //     (async move || -> &i32 {
+LL | ||
+LL | ||
+LL | ||         let y = &*x;
+LL | ||         *x += 1;
+LL | ||         y
+LL | ||     })()
+   | ||______^_- argument requires that borrow lasts for `'1`
+   | |_______|
+   |         creates a temporary value which is freed while still in use
+LL |    }
+   |    - temporary value is freed at the end of this statement
 
 error[E0506]: cannot assign to `*x` because it is borrowed
-  --> $DIR/issue-74072-lifetime-name-annotations.rs:32:9
+  --> $DIR/issue-74072-lifetime-name-annotations.rs:36:9
    |
 LL |         let y = &*x;
    |                 --- `*x` is borrowed here
@@ -46,6 +118,7 @@ LL |         y
 LL |     }
    |     - return type of async block is &'1 i32
 
-error: aborting due to 4 previous errors
+error: aborting due to 8 previous errors
 
-For more information about this error, try `rustc --explain E0506`.
+Some errors have detailed explanations: E0506, E0716.
+For more information about an error, try `rustc --explain E0506`.
diff --git a/tests/ui/closures/binder/async-closure-with-binder.rs b/tests/ui/closures/binder/async-closure-with-binder.rs
index 4fa599d37cb..69d30f369e9 100644
--- a/tests/ui/closures/binder/async-closure-with-binder.rs
+++ b/tests/ui/closures/binder/async-closure-with-binder.rs
@@ -1,8 +1,9 @@
 // edition:2021
+// check-pass
+
 #![feature(closure_lifetime_binder)]
 #![feature(async_closure)]
+
 fn main() {
-    for<'a> async || ();
-    //~^ ERROR `for<...>` binders on `async` closures are not currently supported
-    //~^^ ERROR implicit types in closure signatures are forbidden when `for<...>` is present
+    for<'a> async || -> () {};
 }
diff --git a/tests/ui/closures/binder/async-closure-with-binder.stderr b/tests/ui/closures/binder/async-closure-with-binder.stderr
deleted file mode 100644
index 1d4628b1a49..00000000000
--- a/tests/ui/closures/binder/async-closure-with-binder.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: `for<...>` binders on `async` closures are not currently supported
-  --> $DIR/async-closure-with-binder.rs:5:5
-   |
-LL |     for<'a> async || ();
-   |     ^^^^^^^
-
-error: implicit types in closure signatures are forbidden when `for<...>` is present
-  --> $DIR/async-closure-with-binder.rs:5:5
-   |
-LL |     for<'a> async || ();
-   |     -------^^^^^^^^^
-   |     |
-   |     `for<...>` is here
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.rs b/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.rs
index a9d678c1e6a..66a432be357 100644
--- a/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.rs
+++ b/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.rs
@@ -9,7 +9,7 @@ impl Numberer {
     //~^ ERROR `async fn` is not permitted in Rust 2015
         interval: Duration,
         //~^ ERROR cannot find type `Duration` in this scope
-    ) -> Numberer { //~WARN: changes to closure capture in Rust 2021
+    ) -> Numberer {
         Numberer {}
     }
 }
diff --git a/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.stderr b/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.stderr
index 71e9e7602e8..60433e1c284 100644
--- a/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.stderr
+++ b/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.stderr
@@ -18,32 +18,7 @@ help: consider importing this struct
 LL + use std::time::Duration;
    |
 
-warning: changes to closure capture in Rust 2021 will affect drop order
-  --> $DIR/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.rs:12:19
-   |
-LL |           interval: Duration,
-   |           -------- in Rust 2018, this causes the closure to capture `interval`, but in Rust 2021, it has no effect
-LL |
-LL |       ) -> Numberer {
-   |  _________________-_^
-   | |                 |
-   | |                 in Rust 2018, `interval` is dropped here along with the closure, but in Rust 2021 `interval` is not part of the closure
-LL | |         Numberer {}
-LL | |     }
-   | |_____^
-   |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
-note: the lint level is defined here
-  --> $DIR/drop-location-span-error-rust-2021-incompatible-closure-captures-96258.rs:1:9
-   |
-LL | #![warn(rust_2021_incompatible_closure_captures)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: add a dummy let to cause `interval` to be fully captured
-   |
-LL |     ) -> Numberer { let _ = &interval;
-   |                     ++++++++++++++++++
-
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0412, E0670.
 For more information about an error, try `rustc --explain E0412`.
diff --git a/tests/ui/suggestions/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.stderr b/tests/ui/suggestions/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.stderr
index 3065f83ea3d..dc4ec5d3ee2 100644
--- a/tests/ui/suggestions/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.stderr
+++ b/tests/ui/suggestions/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.stderr
@@ -18,25 +18,21 @@ help: use parentheses to call this function
 LL |     bar(foo());
    |            ++
 
-error[E0277]: `{closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33}` is not a future
+error[E0277]: `{coroutine-closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33}` is not a future
   --> $DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:12:9
    |
 LL |     bar(async_closure);
-   |     --- ^^^^^^^^^^^^^ `{closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33}` is not a future
+   |     --- ^^^^^^^^^^^^^ `{coroutine-closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33}` is not a future
    |     |
    |     required by a bound introduced by this call
    |
-   = help: the trait `Future` is not implemented for closure `{closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33}`
-   = note: {closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33} must be a future or must implement `IntoFuture` to be awaited
+   = help: the trait `Future` is not implemented for `{coroutine-closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33}`
+   = note: {coroutine-closure@$DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:11:25: 11:33} must be a future or must implement `IntoFuture` to be awaited
 note: required by a bound in `bar`
   --> $DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:7:16
    |
 LL | fn bar(f: impl Future<Output=()>) {}
    |                ^^^^^^^^^^^^^^^^^ required by this bound in `bar`
-help: use parentheses to call this closure
-   |
-LL |     bar(async_closure());
-   |                      ++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/symbol-names/basic.legacy.stderr b/tests/ui/symbol-names/basic.legacy.stderr
index 61d27ec69f4..c1cbefac828 100644
--- a/tests/ui/symbol-names/basic.legacy.stderr
+++ b/tests/ui/symbol-names/basic.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN5basic4main17h9308686d0228fa1dE)
+error: symbol-name(_ZN5basic4main17h6fc0c8d27b1a289fE)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(basic::main::h9308686d0228fa1d)
+error: demangling(basic::main::h6fc0c8d27b1a289f)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
diff --git a/tests/ui/symbol-names/issue-60925.legacy.stderr b/tests/ui/symbol-names/issue-60925.legacy.stderr
index eb65f3b58ff..7dd68e6e3a8 100644
--- a/tests/ui/symbol-names/issue-60925.legacy.stderr
+++ b/tests/ui/symbol-names/issue-60925.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h84ab5dafbd2a1508E)
+error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17hab58a402db4ebf3aE)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::h84ab5dafbd2a1508)
+error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::hab58a402db4ebf3a)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]