Auto merge of rust-lang#120717 - compiler-errors:cap-closure-kind, r=oli-obk

For async closures, cap closure kind, get rid of `by_mut_body`

Right now we have three `AsyncFn*` traits, and three corresponding futures that are returned by the `call_*` functions for them. This is fine, but it is a bit excessive, since the future returned by `AsyncFn` and `AsyncFnMut` are identical. Really, the only distinction we need to make with these bodies is "by ref" and "by move".

This PR removes `AsyncFn::CallFuture` and renames `AsyncFnMut::CallMutFuture` to `AsyncFnMut::CallRefFuture`. This simplifies MIR building for async closures, since we don't need to build an extra "by mut" body, but just a "by move" body which is materially different.

We need to do a bit of delicate handling of the ClosureKind for async closures, since we need to "cap" it to `AsyncFnMut` in some cases when we only care about what body we're looking for.

This also fixes a bug where `<{async closure} as Fn>::call` was returning a body that takes the async-closure receiver *by move*.

This also helps align the `AsyncFn` traits to the `LendingFn` traits' eventual designs.

Author: bors

alloc/src/boxed.rs

@@ -2042,18 +2042,16 @@ impl<Args: Tuple, F: AsyncFnOnce<Args> + ?Sized, A: Allocator> AsyncFnOnce<Args>
 
 #[unstable(feature = "async_fn_traits", issue = "none")]
 impl<Args: Tuple, F: AsyncFnMut<Args> + ?Sized, A: Allocator> AsyncFnMut<Args> for Box<F, A> {
-    type CallMutFuture<'a> = F::CallMutFuture<'a> where Self: 'a;
+    type CallRefFuture<'a> = F::CallRefFuture<'a> where Self: 'a;
 
-    extern "rust-call" fn async_call_mut(&mut self, args: Args) -> Self::CallMutFuture<'_> {
+    extern "rust-call" fn async_call_mut(&mut self, args: Args) -> Self::CallRefFuture<'_> {
         F::async_call_mut(self, args)
     }
 }
 
 #[unstable(feature = "async_fn_traits", issue = "none")]
 impl<Args: Tuple, F: AsyncFn<Args> + ?Sized, A: Allocator> AsyncFn<Args> for Box<F, A> {
-    type CallFuture<'a> = F::CallFuture<'a> where Self: 'a;
-
-    extern "rust-call" fn async_call(&self, args: Args) -> Self::CallFuture<'_> {
+    extern "rust-call" fn async_call(&self, args: Args) -> Self::CallRefFuture<'_> {
         F::async_call(self, args)
     }
 }

core/src/ops/async_function.rs

@@ -10,15 +10,9 @@ use crate::marker::Tuple;
 #[must_use = "async closures are lazy and do nothing unless called"]
 #[lang = "async_fn"]
 pub trait AsyncFn<Args: Tuple>: AsyncFnMut<Args> {
-    /// Future returned by [`AsyncFn::async_call`].
-    #[unstable(feature = "async_fn_traits", issue = "none")]
-    type CallFuture<'a>: Future<Output = Self::Output>
-    where
-        Self: 'a;
-
     /// Call the [`AsyncFn`], returning a future which may borrow from the called closure.
     #[unstable(feature = "async_fn_traits", issue = "none")]
-    extern "rust-call" fn async_call(&self, args: Args) -> Self::CallFuture<'_>;
+    extern "rust-call" fn async_call(&self, args: Args) -> Self::CallRefFuture<'_>;
 }
 
 /// An async-aware version of the [`FnMut`](crate::ops::FnMut) trait.
@@ -30,15 +24,15 @@ pub trait AsyncFn<Args: Tuple>: AsyncFnMut<Args> {
 #[must_use = "async closures are lazy and do nothing unless called"]
 #[lang = "async_fn_mut"]
 pub trait AsyncFnMut<Args: Tuple>: AsyncFnOnce<Args> {
-    /// Future returned by [`AsyncFnMut::async_call_mut`].
+    /// Future returned by [`AsyncFnMut::async_call_mut`] and [`AsyncFn::async_call`].
     #[unstable(feature = "async_fn_traits", issue = "none")]
-    type CallMutFuture<'a>: Future<Output = Self::Output>
+    type CallRefFuture<'a>: Future<Output = Self::Output>
     where
         Self: 'a;
 
     /// Call the [`AsyncFnMut`], returning a future which may borrow from the called closure.
     #[unstable(feature = "async_fn_traits", issue = "none")]
-    extern "rust-call" fn async_call_mut(&mut self, args: Args) -> Self::CallMutFuture<'_>;
+    extern "rust-call" fn async_call_mut(&mut self, args: Args) -> Self::CallRefFuture<'_>;
 }
 
 /// An async-aware version of the [`FnOnce`](crate::ops::FnOnce) trait.
@@ -72,9 +66,7 @@ mod impls {
     where
         F: AsyncFn<A>,
     {
-        type CallFuture<'a> = F::CallFuture<'a> where Self: 'a;
-
-        extern "rust-call" fn async_call(&self, args: A) -> Self::CallFuture<'_> {
+        extern "rust-call" fn async_call(&self, args: A) -> Self::CallRefFuture<'_> {
             F::async_call(*self, args)
         }
     }
@@ -84,9 +76,9 @@ mod impls {
     where
         F: AsyncFn<A>,
     {
-        type CallMutFuture<'a> = F::CallFuture<'a> where Self: 'a;
+        type CallRefFuture<'a> = F::CallRefFuture<'a> where Self: 'a;
 
-        extern "rust-call" fn async_call_mut(&mut self, args: A) -> Self::CallMutFuture<'_> {
+        extern "rust-call" fn async_call_mut(&mut self, args: A) -> Self::CallRefFuture<'_> {
             F::async_call(*self, args)
         }
     }
@@ -97,7 +89,7 @@ mod impls {
         F: AsyncFn<A>,
     {
         type Output = F::Output;
-        type CallOnceFuture = F::CallFuture<'a>;
+        type CallOnceFuture = F::CallRefFuture<'a>;
 
         extern "rust-call" fn async_call_once(self, args: A) -> Self::CallOnceFuture {
             F::async_call(self, args)
@@ -109,9 +101,9 @@ mod impls {
     where
         F: AsyncFnMut<A>,
     {
-        type CallMutFuture<'a> = F::CallMutFuture<'a> where Self: 'a;
+        type CallRefFuture<'a> = F::CallRefFuture<'a> where Self: 'a;
 
-        extern "rust-call" fn async_call_mut(&mut self, args: A) -> Self::CallMutFuture<'_> {
+        extern "rust-call" fn async_call_mut(&mut self, args: A) -> Self::CallRefFuture<'_> {
             F::async_call_mut(*self, args)
         }
     }
@@ -122,7 +114,7 @@ mod impls {
         F: AsyncFnMut<A>,
     {
         type Output = F::Output;
-        type CallOnceFuture = F::CallMutFuture<'a>;
+        type CallOnceFuture = F::CallRefFuture<'a>;
 
         extern "rust-call" fn async_call_once(self, args: A) -> Self::CallOnceFuture {
             F::async_call_mut(self, args)