Async Closures Support

[Veykril]

We don't really support them at all right now I believe and they are going to be stabilized soon so we should at least implement them well enough to prevent diagnostics from cropping up. #16173 might be relevant here

rust-lang/rust#132706

[ChayimFriedman2]

@rustbot claim

[ChayimFriedman2]

Actually @Veykril we seem to support them well - do you know any specific problem?

[Veykril]

The main issues seems to be handling impl AsyncFn*

fn f(it: impl AsyncFn(u32) -> i32) {
    let it = it(0); // 	we error on this call
}

as plain closures we do handle them well enough (lowering them to impl Fn* -> impl Future (even though thats kind of wrong)

[ChayimFriedman2]

So... to fully handle it we require support from chalk (since it knows closures implements the fn traits), but this is only required for where bounds, which we don't currently report diagnostics for, and we can handle invocations ourselves.

[Veykril]

Alternatively We might be able to hack lowering of AsyncFn(...) -> T into Fn(...) -> impl Future<T>, that would suffice for our purposes as well. The main thing we need before stabilization is getting rid of diagnostics and resolve the return type when the thing is called. Implementing the whole thing shouldn't be necessary fortunately to get a good enough experience

[ChayimFriedman2]

Alternatively We might be able to hack lowering of AsyncFn(...) -> T into Fn(...) -> impl Future<T>, that would suffice for our purposes as well. The main thing we need before stabilization is getting rid of diagnostics and resolve the return type when the thing is called. Implementing the whole thing shouldn't be necessary fortunately to get a good enough experience

That would be harder I believe since we would have to hook into how Chalk resolves trait bounds, or handle them specifically somewhere in name resolution. Anyway I put a PR.

[compiler-errors]

Thanks for working on this @ChayimFriedman2.

Regarding AsyncFn*, as long as async || {} continues to just lower into || async {} in r-a, then I think all that is needed is a built-in blanket impl that looks conceptually like impl<F, Fut> AsyncFn for F where F: Fn() -> Fut, Fut: Future {}. I'd be happy to review a chalk PR that implements such an impl.