Gate async fn trait bound modifier on async_trait_bounds

compiler-errors · compiler-errors · commit e2368f5fc97a · 2024-11-25T02:59:46.000Z
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -516,6 +516,11 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
         "async closures are unstable",
         "to use an async block, remove the `||`: `async {`"
     );
+    gate_all!(
+        async_trait_bounds,
+        "`async` trait bounds are unstable",
+        "use the desugared name of the async trait, such as `AsyncFn`"
+    );
     gate_all!(async_for_loop, "`for await` loops are experimental");
     gate_all!(
         closure_lifetime_binder,
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -390,6 +390,8 @@ declare_features! (
     (unstable, async_fn_track_caller, "1.73.0", Some(110011)),
     /// Allows `for await` loops.
     (unstable, async_for_loop, "1.77.0", Some(118898)),
+    /// Allows `async` trait bound modifier.
+    (unstable, async_trait_bounds, "CURRENT_RUSTC_VERSION", Some(62290)),
     /// Allows using C-variadics.
     (unstable, c_variadic, "1.34.0", Some(44930)),
     /// Allows the use of `#[cfg(<true/false>)]`.
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
@@ -943,7 +943,7 @@ impl<'a> Parser<'a> {
         let asyncness = if self.token.uninterpolated_span().at_least_rust_2018()
             && self.eat_keyword(kw::Async)
         {
-            self.psess.gated_spans.gate(sym::async_closure, self.prev_token.span);
+            self.psess.gated_spans.gate(sym::async_trait_bounds, self.prev_token.span);
             BoundAsyncness::Async(self.prev_token.span)
         } else if self.may_recover()
             && self.token.uninterpolated_span().is_rust_2015()
@@ -954,7 +954,7 @@ impl<'a> Parser<'a> {
                 span: self.prev_token.span,
                 help: HelpUseLatestEdition::new(),
             });
-            self.psess.gated_spans.gate(sym::async_closure, self.prev_token.span);
+            self.psess.gated_spans.gate(sym::async_trait_bounds, self.prev_token.span);
             BoundAsyncness::Async(self.prev_token.span)
         } else {
             BoundAsyncness::Normal
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -464,6 +464,7 @@ symbols! {
         async_for_loop,
         async_iterator,
         async_iterator_poll_next,
+        async_trait_bounds,
         atomic,
         atomic_mod,
         atomics,
diff --git a/src/tools/miri/tests/pass/async-closure-captures.rs b/src/tools/miri/tests/pass/async-closure-captures.rs
@@ -1,6 +1,6 @@
 // Same as rustc's `tests/ui/async-await/async-closures/captures.rs`, keep in sync
 
-#![feature(async_closure, noop_waker)]
+#![feature(async_closure, noop_waker, async_trait_bounds)]
 
 use std::future::Future;
 use std::pin::pin;
diff --git a/src/tools/miri/tests/pass/async-closure-drop.rs b/src/tools/miri/tests/pass/async-closure-drop.rs
@@ -1,4 +1,4 @@
-#![feature(async_closure, noop_waker, async_fn_traits)]
+#![feature(async_closure, noop_waker, async_trait_bounds)]
 
 use std::future::Future;
 use std::pin::pin;
diff --git a/tests/coverage/async_closure.cov-map b/tests/coverage/async_closure.cov-map
@@ -1,19 +1,19 @@
 Function name: async_closure::call_once::<async_closure::main::{closure#0}>
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 01, 00, 2c]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 01, 00, 2b]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 7, 1) to (start + 0, 44)
+- Code(Counter(0)) at (prev + 7, 1) to (start + 0, 43)
 Highest counter ID seen: c0
 
 Function name: async_closure::call_once::<async_closure::main::{closure#0}>::{closure#0}
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 07, 2c, 01, 0e, 05, 02, 01, 00, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 07, 2b, 01, 0e, 05, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 7, 44) to (start + 1, 14)
+- Code(Counter(0)) at (prev + 7, 43) to (start + 1, 14)
 - Code(Counter(1)) at (prev + 2, 1) to (start + 0, 2)
 Highest counter ID seen: c1
 
diff --git a/tests/coverage/async_closure.rs b/tests/coverage/async_closure.rs
@@ -4,7 +4,7 @@
 //@ aux-build: executor.rs
 extern crate executor;
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 
diff --git a/tests/crashes/124020.rs b/tests/crashes/124020.rs
@@ -1,7 +1,7 @@
 //@ known-bug: #124020
 //@ compile-flags: -Zpolymorphize=on --edition=2018 --crate-type=lib
 
-#![feature(async_closure, noop_waker, async_fn_traits)]
+#![feature(async_closure, noop_waker, async_trait_bounds)]
 
 use std::future::Future;
 use std::pin::pin;
@@ -19,7 +19,7 @@ pub fn block_on<T>(fut: impl Future<Output = T>) -> T {
     }
 }
 
-async fn call_once(f: impl async FnOnce(DropMe)) {
+async fn call_once(f: impl AsyncFnOnce(DropMe)) {
     f(DropMe("world")).await;
 }
 
diff --git a/tests/ui/async-await/async-fn/dyn-pos.rs b/tests/ui/async-await/async-fn/dyn-pos.rs
@@ -2,7 +2,7 @@
 
 #![feature(async_closure)]
 
-fn foo(x: &dyn async Fn()) {}
+fn foo(x: &dyn AsyncFn()) {}
 //~^ ERROR the trait `AsyncFn` cannot be made into an object
 //~| ERROR the trait `AsyncFnMut` cannot be made into an object
 //~| ERROR the trait `AsyncFnMut` cannot be made into an object
diff --git a/tests/ui/async-await/async-fn/dyn-pos.stderr b/tests/ui/async-await/async-fn/dyn-pos.stderr
@@ -1,8 +1,8 @@
 error[E0038]: the trait `AsyncFnMut` cannot be made into an object
   --> $DIR/dyn-pos.rs:5:16
    |
-LL | fn foo(x: &dyn async Fn()) {}
-   |                ^^^^^^^^^^ `AsyncFnMut` cannot be made into an object
+LL | fn foo(x: &dyn AsyncFn()) {}
+   |                ^^^^^^^^^ `AsyncFnMut` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $SRC_DIR/core/src/ops/async_function.rs:LL:COL
@@ -16,8 +16,8 @@ note: for a trait to be "dyn-compatible" it needs to allow building a vtable to
 error[E0038]: the trait `AsyncFnMut` cannot be made into an object
   --> $DIR/dyn-pos.rs:5:16
    |
-LL | fn foo(x: &dyn async Fn()) {}
-   |                ^^^^^^^^^^ `AsyncFnMut` cannot be made into an object
+LL | fn foo(x: &dyn AsyncFn()) {}
+   |                ^^^^^^^^^ `AsyncFnMut` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $SRC_DIR/core/src/ops/async_function.rs:LL:COL
@@ -32,8 +32,8 @@ note: for a trait to be "dyn-compatible" it needs to allow building a vtable to
 error[E0038]: the trait `AsyncFnMut` cannot be made into an object
   --> $DIR/dyn-pos.rs:5:16
    |
-LL | fn foo(x: &dyn async Fn()) {}
-   |                ^^^^^^^^^^ `AsyncFnMut` cannot be made into an object
+LL | fn foo(x: &dyn AsyncFn()) {}
+   |                ^^^^^^^^^ `AsyncFnMut` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $SRC_DIR/core/src/ops/async_function.rs:LL:COL
@@ -48,8 +48,8 @@ note: for a trait to be "dyn-compatible" it needs to allow building a vtable to
 error[E0038]: the trait `AsyncFn` cannot be made into an object
   --> $DIR/dyn-pos.rs:5:12
    |
-LL | fn foo(x: &dyn async Fn()) {}
-   |            ^^^^^^^^^^^^^^ `AsyncFn` cannot be made into an object
+LL | fn foo(x: &dyn AsyncFn()) {}
+   |            ^^^^^^^^^^^^^ `AsyncFn` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $SRC_DIR/core/src/ops/async_function.rs:LL:COL
diff --git a/tests/ui/async-await/async-fn/edition-2015.rs b/tests/ui/async-await/async-fn/edition-2015.rs
@@ -1,8 +1,8 @@
 fn foo(x: impl async Fn()) -> impl async Fn() { x }
 //~^ ERROR `async` trait bounds are only allowed in Rust 2018 or later
 //~| ERROR `async` trait bounds are only allowed in Rust 2018 or later
-//~| ERROR async closures are unstable
-//~| ERROR async closures are unstable
+//~| ERROR `async` trait bounds are unstable
+//~| ERROR `async` trait bounds are unstable
 //~| ERROR use of unstable library feature `async_closure`
 //~| ERROR use of unstable library feature `async_closure`
 
diff --git a/tests/ui/async-await/async-fn/edition-2015.stderr b/tests/ui/async-await/async-fn/edition-2015.stderr
@@ -16,27 +16,27 @@ LL | fn foo(x: impl async Fn()) -> impl async Fn() { x }
    = help: pass `--edition 2024` to `rustc`
    = note: for more on editions, read https://doc.rust-lang.org/edition-guide
 
-error[E0658]: async closures are unstable
+error[E0658]: `async` trait bounds are unstable
   --> $DIR/edition-2015.rs:1:16
    |
 LL | fn foo(x: impl async Fn()) -> impl async Fn() { x }
    |                ^^^^^
    |
    = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
-   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: to use an async block, remove the `||`: `async {`
+   = help: use the desugared name of the async trait, such as `AsyncFn`
 
-error[E0658]: async closures are unstable
+error[E0658]: `async` trait bounds are unstable
   --> $DIR/edition-2015.rs:1:36
    |
 LL | fn foo(x: impl async Fn()) -> impl async Fn() { x }
    |                                    ^^^^^
    |
    = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
-   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: to use an async block, remove the `||`: `async {`
+   = help: use the desugared name of the async trait, such as `AsyncFn`
 
 error[E0658]: use of unstable library feature `async_closure`
   --> $DIR/edition-2015.rs:1:42
diff --git a/tests/ui/async-await/async-fn/mbe-async-trait-bound-theoretical-regression.rs b/tests/ui/async-await/async-fn/mbe-async-trait-bound-theoretical-regression.rs
@@ -13,9 +13,9 @@ macro_rules! demo {
 }
 
 demo! { impl async Trait }
-//~^ ERROR async closures are unstable
+//~^ ERROR `async` trait bounds are unstable
 
 demo! { dyn async Trait }
-//~^ ERROR async closures are unstable
+//~^ ERROR `async` trait bounds are unstable
 
 fn main() {}
diff --git a/tests/ui/async-await/async-fn/mbe-async-trait-bound-theoretical-regression.stderr b/tests/ui/async-await/async-fn/mbe-async-trait-bound-theoretical-regression.stderr
@@ -20,27 +20,27 @@ LL | demo! { dyn async Trait }
    |
    = note: this error originates in the macro `demo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0658]: async closures are unstable
+error[E0658]: `async` trait bounds are unstable
   --> $DIR/mbe-async-trait-bound-theoretical-regression.rs:15:14
    |
 LL | demo! { impl async Trait }
    |              ^^^^^
    |
    = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
-   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: to use an async block, remove the `||`: `async {`
+   = help: use the desugared name of the async trait, such as `AsyncFn`
 
-error[E0658]: async closures are unstable
+error[E0658]: `async` trait bounds are unstable
   --> $DIR/mbe-async-trait-bound-theoretical-regression.rs:18:13
    |
 LL | demo! { dyn async Trait }
    |             ^^^^^
    |
    = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
-   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: to use an async block, remove the `||`: `async {`
+   = help: use the desugared name of the async trait, such as `AsyncFn`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/async-await/async-fn/not-a-trait.rs b/tests/ui/async-await/async-fn/not-a-trait.rs
@@ -1,6 +1,6 @@
 //@ edition:2018
 
-#![feature(async_closure)]
+#![feature(async_trait_bounds)]
 
 struct S;
 
diff --git a/tests/ui/async-await/async-fn/sugar.rs b/tests/ui/async-await/async-fn/sugar.rs
@@ -1,7 +1,7 @@
 //@ edition: 2021
 //@ check-pass
 
-#![feature(async_closure)]
+#![feature(async_closure, async_trait_bounds)]
 
 async fn foo() {}
 
diff --git a/tests/ui/async-await/async-fn/trait-bounds-in-macro.rs b/tests/ui/async-await/async-fn/trait-bounds-in-macro.rs
@@ -6,7 +6,7 @@ macro_rules! x {
 
 x! {
     async fn foo() -> impl async Fn() { }
-    //~^ ERROR async closures are unstable
+    //~^ ERROR `async` trait bounds are unstable
 }
 
 fn main() {}
diff --git a/tests/ui/async-await/async-fn/trait-bounds-in-macro.stderr b/tests/ui/async-await/async-fn/trait-bounds-in-macro.stderr
@@ -1,13 +1,13 @@
-error[E0658]: async closures are unstable
+error[E0658]: `async` trait bounds are unstable
   --> $DIR/trait-bounds-in-macro.rs:8:28
    |
 LL |     async fn foo() -> impl async Fn() { }
    |                            ^^^^^
    |
    = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
-   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: to use an async block, remove the `||`: `async {`
+   = help: use the desugared name of the async trait, such as `AsyncFn`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/async-fn/wrong-trait.rs b/tests/ui/async-await/async-fn/wrong-trait.rs
@@ -1,6 +1,6 @@
 //@ edition:2018
 
-#![feature(async_closure)]
+#![feature(async_trait_bounds)]
 
 trait Foo {}
 
diff --git a/tests/ui/feature-gates/feature-gate-async-trait-bounds.rs b/tests/ui/feature-gates/feature-gate-async-trait-bounds.rs
@@ -0,0 +1,7 @@
+//@ edition: 2021
+
+fn test(_: impl async Fn()) {}
+//~^ ERROR `async` trait bounds are unstable
+//~| ERROR use of unstable library feature `async_closure`
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-async-trait-bounds.stderr b/tests/ui/feature-gates/feature-gate-async-trait-bounds.stderr
@@ -0,0 +1,24 @@
+error[E0658]: `async` trait bounds are unstable
+  --> $DIR/feature-gate-async-trait-bounds.rs:3:17
+   |
+LL | fn test(_: impl async Fn()) {}
+   |                 ^^^^^
+   |
+   = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = help: use the desugared name of the async trait, such as `AsyncFn`
+
+error[E0658]: use of unstable library feature `async_closure`
+  --> $DIR/feature-gate-async-trait-bounds.rs:3:23
+   |
+LL | fn test(_: impl async Fn()) {}
+   |                       ^^^^
+   |
+   = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
+   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/impl-trait/precise-capturing/bound-modifiers.rs b/tests/ui/impl-trait/precise-capturing/bound-modifiers.rs
@@ -7,7 +7,7 @@ fn polarity() -> impl Sized + ?use<> {}
 fn asyncness() -> impl Sized + async use<> {}
 //~^ ERROR expected identifier, found keyword `use`
 //~| ERROR cannot find trait `r#use` in this scope
-//~| ERROR async closures are unstable
+//~| ERROR `async` trait bounds are unstable
 
 fn constness() -> impl Sized + const use<> {}
 //~^ ERROR expected identifier, found keyword `use`
diff --git a/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr b/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr
@@ -46,16 +46,16 @@ error[E0405]: cannot find trait `r#use` in this scope
 LL | fn binder() -> impl Sized + for<'a> use<> {}
    |                                     ^^^ not found in this scope
 
-error[E0658]: async closures are unstable
+error[E0658]: `async` trait bounds are unstable
   --> $DIR/bound-modifiers.rs:7:32
    |
 LL | fn asyncness() -> impl Sized + async use<> {}
    |                                ^^^^^
    |
    = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
-   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: to use an async block, remove the `||`: `async {`
+   = help: use the desugared name of the async trait, such as `AsyncFn`
 
 error[E0658]: const trait impls are experimental
   --> $DIR/bound-modifiers.rs:12:32
diff --git a/tests/ui/parser/bad-recover-kw-after-impl.rs b/tests/ui/parser/bad-recover-kw-after-impl.rs
@@ -12,6 +12,6 @@ macro_rules! impl_primitive {
 
 impl_primitive!(impl async);
 //~^ ERROR expected identifier, found `<eof>`
-//~| ERROR async closures are unstable
+//~| ERROR `async` trait bounds are unstable
 
 fn main() {}
diff --git a/tests/ui/parser/bad-recover-kw-after-impl.stderr b/tests/ui/parser/bad-recover-kw-after-impl.stderr
@@ -7,16 +7,16 @@ LL |     ($ty:ty) => {
 LL | impl_primitive!(impl async);
    |                      ^^^^^ expected identifier
 
-error[E0658]: async closures are unstable
+error[E0658]: `async` trait bounds are unstable
   --> $DIR/bad-recover-kw-after-impl.rs:13:22
    |
 LL | impl_primitive!(impl async);
    |                      ^^^^^
    |
    = note: see issue #62290 <https://github.com/rust-lang/rust/issues/62290> for more information
-   = help: add `#![feature(async_closure)]` to the crate attributes to enable
+   = help: add `#![feature(async_trait_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: to use an async block, remove the `||`: `async {`
+   = help: use the desugared name of the async trait, such as `AsyncFn`
 
 error: aborting due to 2 previous errors
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#![feature(async_closure, noop_waker, async_fn_traits)]`
	`1`	`+#![feature(async_closure, noop_waker, async_trait_bounds)]`
`2`	`2`
`3`	`3`	`use std::future::Future;`
`4`	`4`	`use std::pin::pin;`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`//@ aux-build: executor.rs`
`5`	`5`	`extern crate executor;`
`6`	`6`
`7`		`-async fn call_once(f: impl async FnOnce()) {`
	`7`	`+async fn call_once(f: impl AsyncFnOnce()) {`
`8`	`8`	`f().await;`
`9`	`9`	`}`
`10`	`10`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`//@ known-bug: #124020`
`2`	`2`	`//@ compile-flags: -Zpolymorphize=on --edition=2018 --crate-type=lib`
`3`	`3`
`4`		`-#![feature(async_closure, noop_waker, async_fn_traits)]`
	`4`	`+#![feature(async_closure, noop_waker, async_trait_bounds)]`
`5`	`5`
`6`	`6`	`use std::future::Future;`
`7`	`7`	`use std::pin::pin;`
`@@ -19,7 +19,7 @@ pub fn block_on<T>(fut: impl Future<Output = T>) -> T {`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`		`-async fn call_once(f: impl async FnOnce(DropMe)) {`
	`22`	`+async fn call_once(f: impl AsyncFnOnce(DropMe)) {`
`23`	`23`	`f(DropMe("world")).await;`
`24`	`24`	`}`
`25`	`25`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	error[E0038]: the trait `AsyncFnMut` cannot be made into an object
`2`	`2`	`--> $DIR/dyn-pos.rs:5:16`
`3`	`3`	`\|`
`4`		`-LL \| fn foo(x: &dyn async Fn()) {}`
`5`		- \| ^^^^^^^^^^ `AsyncFnMut` cannot be made into an object
	`4`	`+LL \| fn foo(x: &dyn AsyncFn()) {}`
	`5`	+ \| ^^^^^^^^^ `AsyncFnMut` cannot be made into an object
`6`	`6`	`\|`
`7`	`7`	`note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>`
`8`	`8`	`--> $SRC_DIR/core/src/ops/async_function.rs:LL:COL`
`@@ -16,8 +16,8 @@ note: for a trait to be "dyn-compatible" it needs to allow building a vtable to`
`16`	`16`	error[E0038]: the trait `AsyncFnMut` cannot be made into an object
`17`	`17`	`--> $DIR/dyn-pos.rs:5:16`
`18`	`18`	`\|`
`19`		`-LL \| fn foo(x: &dyn async Fn()) {}`
`20`		- \| ^^^^^^^^^^ `AsyncFnMut` cannot be made into an object
	`19`	`+LL \| fn foo(x: &dyn AsyncFn()) {}`
	`20`	+ \| ^^^^^^^^^ `AsyncFnMut` cannot be made into an object
`21`	`21`	`\|`
`22`	`22`	`note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>`
`23`	`23`	`--> $SRC_DIR/core/src/ops/async_function.rs:LL:COL`
`@@ -32,8 +32,8 @@ note: for a trait to be "dyn-compatible" it needs to allow building a vtable to`
`32`	`32`	error[E0038]: the trait `AsyncFnMut` cannot be made into an object
`33`	`33`	`--> $DIR/dyn-pos.rs:5:16`
`34`	`34`	`\|`
`35`		`-LL \| fn foo(x: &dyn async Fn()) {}`
`36`		- \| ^^^^^^^^^^ `AsyncFnMut` cannot be made into an object
	`35`	`+LL \| fn foo(x: &dyn AsyncFn()) {}`
	`36`	+ \| ^^^^^^^^^ `AsyncFnMut` cannot be made into an object
`37`	`37`	`\|`
`38`	`38`	`note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>`
`39`	`39`	`--> $SRC_DIR/core/src/ops/async_function.rs:LL:COL`
`@@ -48,8 +48,8 @@ note: for a trait to be "dyn-compatible" it needs to allow building a vtable to`
`48`	`48`	error[E0038]: the trait `AsyncFn` cannot be made into an object
`49`	`49`	`--> $DIR/dyn-pos.rs:5:12`
`50`	`50`	`\|`
`51`		`-LL \| fn foo(x: &dyn async Fn()) {}`
`52`		- \| ^^^^^^^^^^^^^^ `AsyncFn` cannot be made into an object
	`51`	`+LL \| fn foo(x: &dyn AsyncFn()) {}`
	`52`	+ \| ^^^^^^^^^^^^^ `AsyncFn` cannot be made into an object
`53`	`53`	`\|`
`54`	`54`	`note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>`
`55`	`55`	`--> $SRC_DIR/core/src/ops/async_function.rs:LL:COL`
Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,9 @@ macro_rules! demo {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`demo! { impl async Trait }`
`16`		`-//~^ ERROR async closures are unstable`
	`16`	+//~^ ERROR `async` trait bounds are unstable
`17`	`17`
`18`	`18`	`demo! { dyn async Trait }`
`19`		`-//~^ ERROR async closures are unstable`
	`19`	+//~^ ERROR `async` trait bounds are unstable
`20`	`20`
`21`	`21`	`fn main() {}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ macro_rules! x {`
`6`	`6`
`7`	`7`	`x! {`
`8`	`8`	`async fn foo() -> impl async Fn() { }`
`9`		`- //~^ ERROR async closures are unstable`
	`9`	+ //~^ ERROR `async` trait bounds are unstable
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`fn main() {}`