An async closure may implement FnMut/Fn if it has no self-borrows

[compiler-errors]

There's no reason that async closures may not implement FnMut or Fn if they don't actually borrow anything with the closure's env lifetime. Specifically, #123660 made it so that we don't always need to borrow captures from the closure's env.

See the doc comment on should_reborrow_from_env_of_parent_coroutine_closure:

rust/compiler/rustc_hir_typeck/src/upvar.rs

Lines 1777 to 1823 in c00957a

	/// Determines whether a child capture that is derived from a parent capture
	/// should be borrowed with the lifetime of the parent coroutine-closure's env.
	///
	/// There are two cases when this needs to happen:
	///
	/// (1.) Are we borrowing data owned by the parent closure? We can determine if
	/// that is the case by checking if the parent capture is by move, EXCEPT if we
	/// apply a deref projection, which means we're reborrowing a reference that we
	/// captured by move.
	///
	/// ```rust
	/// #![feature(async_closure)]
	/// let x = &1i32; // Let's call this lifetime `'1`.
	/// let c = async move || {
	/// println!("{:?}", *x);
	/// // Even though the inner coroutine borrows by ref, we're only capturing `*x`,
	/// // not `x`, so the inner closure is allowed to reborrow the data for `'1`.
	/// };
	/// ```
	///
	/// (2.) If a coroutine is mutably borrowing from a parent capture, then that
	/// mutable borrow cannot live for longer than either the parent *or* the borrow
	/// that we have on the original upvar. Therefore we always need to borrow the
	/// child capture with the lifetime of the parent coroutine-closure's env.
	///
	/// ```rust
	/// #![feature(async_closure)]
	/// let mut x = 1i32;
	/// let c = async || {
	/// x = 1;
	/// // The parent borrows `x` for some `&'1 mut i32`.
	/// // However, when we call `c()`, we implicitly autoref for the signature of
	/// // `AsyncFnMut::async_call_mut`. Let's call that lifetime `'call`. Since
	/// // the maximum that `&'call mut &'1 mut i32` can be reborrowed is `&'call mut i32`,
	/// // the inner coroutine should capture w/ the lifetime of the coroutine-closure.
	/// };
	/// ```
	///
	/// If either of these cases apply, then we should capture the borrow with the
	/// lifetime of the parent coroutine-closure's env. Luckily, if this function is
	/// not correct, then the program is not unsound, since we still borrowck and validate
	/// the choices made from this function -- the only side-effect is that the user
	/// may receive unnecessary borrowck errors.
	fn should_reborrow_from_env_of_parent_coroutine_closure<'tcx>(
	parent_capture: &ty::CapturedPlace<'tcx>,
	child_capture: &ty::CapturedPlace<'tcx>,
	) -> bool {

If there are no such borrows, then we are free to implement FnMut and Fn as permitted by our closure's inferred ClosureKind.

As far as I can tell, this change makes async || {} work in precisely the set of places they used to work before #120361.
Fixes #125247.

r? oli-obk

[rustbot]

Some changes occurred to the core trait solver

cc @rust-lang/initiative-trait-system-refactor

[oli-obk]

@bors r+ rollup

[bors]

📌 Commit 2e97dae has been approved by oli-obk

It is now in the queue for this repository.

[fmease]

bors sleepy @bors r-