Move tests back to using AsyncFn

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -794,7 +794,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     closure_def_id,
                     found_kind,
                     expected_kind,
-                    "async ",
+                    "Async",
                 );
                 self.note_obligation_cause(&mut err, &obligation);
                 self.point_at_returns_when_relevant(&mut err, &obligation);

tests/ui/async-await/async-closures/async-fn-mut-for-async-fn.rs

@@ -10,7 +10,7 @@ fn main() {
     block_on::block_on(async {
         let x = async || {};
 
-        async fn needs_async_fn_mut(mut x: impl async FnMut()) {
+        async fn needs_async_fn_mut(mut x: impl AsyncFnMut()) {
             x().await;
         }
         needs_async_fn_mut(x).await;

tests/ui/async-await/async-closures/async-fn-once-for-async-fn.rs

@@ -8,7 +8,7 @@ extern crate block_on;
 
 fn main() {
     block_on::block_on(async {
-        async fn needs_async_fn_once(x: impl async FnOnce()) {
+        async fn needs_async_fn_once(x: impl AsyncFnOnce()) {
             x().await;
         }
 

tests/ui/async-await/async-closures/auxiliary/foreign.rs

@@ -2,6 +2,6 @@
 
 #![feature(async_closure)]
 
-pub fn closure() -> impl async Fn() {
+pub fn closure() -> impl AsyncFn() {
     async || { /* Don't really need to do anything here. */ }
 }

tests/ui/async-await/async-closures/body-check-on-non-fnmut.rs

@@ -11,7 +11,7 @@ extern crate block_on;
 
 async fn empty() {}
 
-pub async fn call_once<F: async FnOnce()>(f: F) {
+pub async fn call_once<F: AsyncFnOnce()>(f: F) {
     f().await;
 }
 

tests/ui/async-await/async-closures/box-deref-in-debuginfo.rs

@@ -16,7 +16,7 @@ impl Trait for (i32,) {
     }
 }
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 

tests/ui/async-await/async-closures/brand.rs

@@ -13,7 +13,7 @@ struct S;
 struct B<'b>(PhantomData<&'b mut &'b mut ()>);
 
 impl S {
-    async fn q<F: async Fn(B<'_>)>(self, f: F) {
+    async fn q<F: AsyncFn(B<'_>)>(self, f: F) {
         f(B(PhantomData)).await;
     }
 }

tests/ui/async-await/async-closures/captures.rs

@@ -13,11 +13,11 @@ fn main() {
     block_on::block_on(async_main());
 }
 
-async fn call<T>(f: &impl async Fn() -> T) -> T {
+async fn call<T>(f: &impl AsyncFn() -> T) -> T {
     f().await
 }
 
-async fn call_once<T>(f: impl async FnOnce() -> T) -> T {
+async fn call_once<T>(f: impl AsyncFnOnce() -> T) -> T {
     f().await
 }
 
@@ -80,7 +80,7 @@ async fn async_main() {
         call_once(c).await;
     }
 
-    fn force_fnonce<T>(f: impl async FnOnce() -> T) -> impl async FnOnce() -> T {
+    fn force_fnonce<T>(f: impl AsyncFnOnce() -> T) -> impl AsyncFnOnce() -> T {
         f
     }
 

tests/ui/async-await/async-closures/clone-closure.rs

@@ -7,7 +7,7 @@
 
 extern crate block_on;
 
-async fn for_each(f: impl async FnOnce(&str) + Clone) {
+async fn for_each(f: impl AsyncFnOnce(&str) + Clone) {
     f.clone()("world").await;
     f.clone()("world2").await;
 }

tests/ui/async-await/async-closures/constrained-but-no-upvars-yet.rs

@@ -6,7 +6,7 @@
 
 #![feature(async_closure)]
 
-fn constrain<T: async FnOnce()>(t: T) -> T {
+fn constrain<T: AsyncFnOnce()>(t: T) -> T {
     t
 }
 
@@ -14,7 +14,7 @@ fn call_once<T>(f: impl FnOnce() -> T) -> T {
     f()
 }
 
-async fn async_call_once<T>(f: impl async FnOnce() -> T) -> T {
+async fn async_call_once<T>(f: impl AsyncFnOnce() -> T) -> T {
     f().await
 }
 

tests/ui/async-await/async-closures/debuginfo-by-move-body.rs

@@ -7,7 +7,7 @@
 
 extern crate block_on;
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 

tests/ui/async-await/async-closures/drop.rs

@@ -16,7 +16,7 @@ impl Drop for DropMe {
     }
 }
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     println!("before call");
     let fut = Box::pin(f());
     println!("after call");

tests/ui/async-await/async-closures/fn-exception-target-features.rs

@@ -10,7 +10,7 @@ use std::future::Future;
 #[target_feature(enable = "sse2")]
 fn target_feature()  -> Pin<Box<dyn Future<Output = ()> + 'static>> { todo!() }
 
-fn test(f: impl async Fn()) {}
+fn test(f: impl AsyncFn()) {}
 
 fn main() {
     test(target_feature); //~ ERROR the trait bound

tests/ui/async-await/async-closures/fn-exception-target-features.stderr

@@ -9,8 +9,8 @@ LL |     test(target_feature);
 note: required by a bound in `test`
   --> $DIR/fn-exception-target-features.rs:13:17
    |
-LL | fn test(f: impl async Fn()) {}
-   |                 ^^^^^^^^^^ required by this bound in `test`
+LL | fn test(f: impl AsyncFn()) {}
+   |                 ^^^^^^^^^ required by this bound in `test`
 
 error: aborting due to 1 previous error
 

tests/ui/async-await/async-closures/fn-exception.rs

@@ -13,7 +13,7 @@ unsafe extern "C" {
     pub safe fn abi() -> Pin<Box<dyn Future<Output = ()> + 'static>>;
 }
 
-fn test(f: impl async Fn()) {}
+fn test(f: impl AsyncFn()) {}
 
 fn main() {
     test(unsafety); //~ ERROR the trait bound

tests/ui/async-await/async-closures/fn-exception.stderr

@@ -9,8 +9,8 @@ LL |     test(unsafety);
 note: required by a bound in `test`
   --> $DIR/fn-exception.rs:16:17
    |
-LL | fn test(f: impl async Fn()) {}
-   |                 ^^^^^^^^^^ required by this bound in `test`
+LL | fn test(f: impl AsyncFn()) {}
+   |                 ^^^^^^^^^ required by this bound in `test`
 
 error[E0277]: the trait bound `extern "C" fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {abi}: AsyncFn()` is not satisfied
   --> $DIR/fn-exception.rs:20:10
@@ -23,8 +23,8 @@ LL |     test(abi);
 note: required by a bound in `test`
   --> $DIR/fn-exception.rs:16:17
    |
-LL | fn test(f: impl async Fn()) {}
-   |                 ^^^^^^^^^^ required by this bound in `test`
+LL | fn test(f: impl AsyncFn()) {}
+   |                 ^^^^^^^^^ required by this bound in `test`
 
 error: aborting due to 2 previous errors
 

tests/ui/async-await/async-closures/force-move-due-to-inferred-kind.rs

@@ -6,7 +6,7 @@
 
 extern crate block_on;
 
-fn force_fnonce<T: async FnOnce()>(t: T) -> T { t }
+fn force_fnonce<T: AsyncFnOnce()>(t: T) -> T { t }
 
 fn main() {
     block_on::block_on(async {

tests/ui/async-await/async-closures/foreign.rs

@@ -12,7 +12,7 @@ extern crate foreign;
 
 struct NoCopy;
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 

tests/ui/async-await/async-closures/implements-fnmut.rs

@@ -1,7 +1,7 @@
 //@ build-pass
 //@ edition: 2021
 
-// Demonstrates that an async closure may implement `FnMut` (not just `async FnMut`!)
+// Demonstrates that an async closure may implement `FnMut` (not just `AsyncFnMut`!)
 // if it has no self-borrows. In this case, `&Ty` is not borrowed from the closure env,
 // since it's fine to reborrow it with its original lifetime. See the doc comment on
 // `should_reborrow_from_env_of_parent_coroutine_closure` for more detail for when we

tests/ui/async-await/async-closures/inline-body.rs

@@ -24,7 +24,7 @@ pub fn block_on<T>(fut: impl Future<Output = T>) -> T {
     }
 }
 
-async fn call_once<T>(f: impl async FnOnce() -> T) -> T {
+async fn call_once<T>(f: impl AsyncFnOnce() -> T) -> T {
     f().await
 }
 

tests/ui/async-await/async-closures/mangle.rs

@@ -13,11 +13,11 @@ use std::future::Future;
 use std::pin::pin;
 use std::task::*;
 
-async fn call_mut(f: &mut impl async FnMut()) {
+async fn call_mut(f: &mut impl AsyncFnMut()) {
     f().await;
 }
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 

tests/ui/async-await/async-closures/moro-example.rs

@@ -22,7 +22,7 @@ impl<'scope, 'env: 'scope> Scope<'scope, 'env> {
 
 fn scope_with_closure<'env, B>(_body: B) -> BoxFuture<'env, ()>
 where
-    for<'scope> B: async FnOnce(&'scope Scope<'scope, 'env>),
+    for<'scope> B: AsyncFnOnce(&'scope Scope<'scope, 'env>),
 {
     todo!()
 }

tests/ui/async-await/async-closures/move-is-async-fn.rs

@@ -19,7 +19,7 @@ fn main() {
         is_static(&c);
 
         // Check that `<{async fn} as AsyncFnOnce>::CallOnceFuture` owns its captures.
-        fn call_once<F: async FnOnce()>(f: F) -> F::CallOnceFuture { f() }
+        fn call_once<F: AsyncFnOnce()>(f: F) -> F::CallOnceFuture { f() }
         is_static(&call_once(c));
     });
 }

tests/ui/async-await/async-closures/mut-ref-reborrow.rs

@@ -9,7 +9,7 @@
 
 extern crate block_on;
 
-async fn call_once(f: impl async FnOnce()) { f().await; }
+async fn call_once(f: impl AsyncFnOnce()) { f().await; }
 
 pub async fn async_closure(x: &mut i32) {
     let c = async move || {

tests/ui/async-await/async-closures/no-borrow-from-env.rs

@@ -5,7 +5,7 @@
 
 fn outlives<'a>(_: impl Sized + 'a) {}
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 

tests/ui/async-await/async-closures/non-copy-arg-does-not-force-inner-move.rs

@@ -6,7 +6,7 @@
 
 extern crate block_on;
 
-fn wrapper(f: impl Fn(String)) -> impl async Fn(String) {
+fn wrapper(f: impl Fn(String)) -> impl AsyncFn(String) {
     async move |s| f(s)
 }
 

tests/ui/async-await/async-closures/overlapping-projs.rs

@@ -7,7 +7,7 @@
 
 extern crate block_on;
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 

tests/ui/async-await/async-closures/precise-captures.rs

@@ -5,7 +5,7 @@
 //@ revisions: call call_once force_once
 
 // call - Call the closure regularly.
-// call_once - Call the closure w/ `async FnOnce`, so exercising the by_move shim.
+// call_once - Call the closure w/ `AsyncFnOnce`, so exercising the by_move shim.
 // force_once - Force the closure mode to `FnOnce`, so exercising what was fixed
 //   in <https://github.com/rust-lang/rust/pull/123350>.
 
@@ -20,7 +20,7 @@ macro_rules! call {
 }
 
 #[cfg(call_once)]
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await
 }
 
@@ -35,7 +35,7 @@ macro_rules! guidance {
 }
 
 #[cfg(force_once)]
-fn infer_fnonce(c: impl async FnOnce()) -> impl async FnOnce() { c }
+fn infer_fnonce(c: impl AsyncFnOnce()) -> impl AsyncFnOnce() { c }
 
 #[cfg(force_once)]
 macro_rules! guidance {

tests/ui/async-await/async-closures/refd.rs

@@ -10,15 +10,15 @@ struct NoCopy;
 
 fn main() {
     block_on::block_on(async {
-        async fn call_once(x: impl async Fn()) { x().await }
+        async fn call_once(x: impl AsyncFn()) { x().await }
 
-        // check that `&{async-closure}` implements `async Fn`.
+        // check that `&{async-closure}` implements `AsyncFn`.
         call_once(&async || {}).await;
 
-        // check that `&{closure}` implements `async Fn`.
+        // check that `&{closure}` implements `AsyncFn`.
         call_once(&|| async {}).await;
 
-        // check that `&fndef` implements `async Fn`.
+        // check that `&fndef` implements `AsyncFn`.
         async fn foo() {}
         call_once(&foo).await;
     });

tests/ui/async-await/async-closures/signature-deduction.rs

@@ -3,7 +3,7 @@
 
 #![feature(async_closure)]
 
-async fn foo(x: impl async Fn(&str) -> &str) {}
+async fn foo(x: impl AsyncFn(&str) -> &str) {}
 
 fn main() {
     foo(async |x| x);

tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.rs

@@ -8,7 +8,7 @@
 
 fn outlives<'a>(_: impl Sized + 'a) {}
 
-async fn call_once(f: impl async FnOnce()) {
+async fn call_once(f: impl AsyncFnOnce()) {
     f().await;
 }
 

tests/ui/async-await/async-closures/wrong-fn-kind.rs

@@ -2,7 +2,7 @@
 
 #![feature(async_closure)]
 
-fn needs_async_fn(_: impl async Fn()) {}
+fn needs_async_fn(_: impl AsyncFn()) {}
 
 fn a() {
     let mut x = 1;
@@ -15,7 +15,7 @@ fn a() {
 fn b() {
     let x = String::new();
     needs_async_fn(move || async move {
-        //~^ ERROR expected a closure that implements the `async Fn` trait, but this closure only implements `async FnOnce`
+        //~^ ERROR expected a closure that implements the `AsyncFn` trait, but this closure only implements `AsyncFnOnce`
         println!("{x}");
     });
 }

tests/ui/async-await/async-closures/wrong-fn-kind.stderr

@@ -1,29 +1,29 @@
-error[E0525]: expected a closure that implements the `async Fn` trait, but this closure only implements `async FnOnce`
+error[E0525]: expected a closure that implements the `AsyncFn` trait, but this closure only implements `AsyncFnOnce`
   --> $DIR/wrong-fn-kind.rs:17:20
    |
 LL |       needs_async_fn(move || async move {
    |       -------------- -^^^^^^
    |       |              |
-   |  _____|______________this closure implements `async FnOnce`, not `async Fn`
+   |  _____|______________this closure implements `AsyncFnOnce`, not `AsyncFn`
    | |     |
    | |     required by a bound introduced by this call
 LL | |
 LL | |         println!("{x}");
-   | |                    - closure is `async FnOnce` because it moves the variable `x` out of its environment
+   | |                    - closure is `AsyncFnOnce` because it moves the variable `x` out of its environment
 LL | |     });
-   | |_____- the requirement to implement `async Fn` derives from here
+   | |_____- the requirement to implement `AsyncFn` derives from here
    |
 note: required by a bound in `needs_async_fn`
   --> $DIR/wrong-fn-kind.rs:5:27
    |
-LL | fn needs_async_fn(_: impl async Fn()) {}
-   |                           ^^^^^^^^^^ required by this bound in `needs_async_fn`
+LL | fn needs_async_fn(_: impl AsyncFn()) {}
+   |                           ^^^^^^^^^ required by this bound in `needs_async_fn`
 
 error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure
   --> $DIR/wrong-fn-kind.rs:9:20
    |
-LL | fn needs_async_fn(_: impl async Fn()) {}
-   |                      --------------- change this to accept `FnMut` instead of `Fn`
+LL | fn needs_async_fn(_: impl AsyncFn()) {}
+   |                      -------------- change this to accept `FnMut` instead of `Fn`
 ...
 LL |     needs_async_fn(async || {
    |     -------------- ^^^^^^^^

tests/ui/async-await/async-fn/higher-ranked-async-fn.rs

@@ -15,7 +15,7 @@ async fn f(arg: &i32) {}
 
 async fn func<F>(f: F)
 where
-    F: for<'a> async Fn(&'a i32),
+    F: for<'a> AsyncFn(&'a i32),
 {
     let x: i32 = 0;
     f(&x).await;

tests/ui/async-await/async-fn/impl-trait.rs

@@ -3,13 +3,13 @@
 
 #![feature(async_closure, type_alias_impl_trait)]
 
-type Tait = impl async Fn();
+type Tait = impl AsyncFn();
 fn tait() -> Tait {
     || async {}
 }
 
-fn foo(x: impl async Fn()) -> impl async Fn() { x }
+fn foo(x: impl AsyncFn()) -> impl AsyncFn() { x }
 
-fn param<T: async Fn()>() {}
+fn param<T: AsyncFn()>() {}
 
 fn main() {}

tests/ui/async-await/async-fn/project.rs

@@ -6,7 +6,9 @@
 
 #![feature(async_closure, unboxed_closures, async_fn_traits)]
 
-fn project<F: async Fn<()>>(_: F) -> Option<F::Output> { None }
+use std::ops::AsyncFn;
+
+fn project<F: AsyncFn<()>>(_: F) -> Option<F::Output> { None }
 
 fn main() {
     let x: Option<i32> = project(|| async { 1i32 });