Invalid suggestion for `AsyncFnOnce` trait object

[ehuss]

Code

#![feature(async_closure)]

pub fn f(x: &dyn AsyncFnOnce()) {}

Current output

error[E0191]: the value of the associated type `CallOnceFuture` in `AsyncFnOnce` must be specified
 --> src/main.rs:3:18
  |
3 | pub fn f(x: &dyn AsyncFnOnce()) {}
  |                  ^^^^^^^^^^^^^ help: specify the associated type: `AsyncFnOnce()<CallOnceFuture = Type>`

Desired output

???

Rationale and extra context

The suggested replacement pub fn f(x: &dyn AsyncFnOnce()<CallOnceFuture = Type>) {} is not valid syntax.

Since dyn Async* is not supported, perhaps it should just say that? I don't know what the plans are here.

Other cases

Rust Version

rustc 1.85.0-nightly (a224f3807 2024-12-09)
binary: rustc
commit-hash: a224f3807e58afc9353510f1d556c607d367545d
commit-date: 2024-12-09
host: aarch64-apple-darwin
release: 1.85.0-nightly
LLVM version: 19.1.5

Anything else?

No response

[compiler-errors]

lol

[darkwaves-ofc]

Based on the error and the code you've provided, I can help explain what's happening and what might be a better error message.

The issue appears to be related to the experimental async_closure feature and attempting to use AsyncFnOnce as a trait object (dyn AsyncFnOnce()).

The current error message suggests adding a CallOnceFuture associated type specification, but as you noted, the suggested syntax is invalid.

A better error message might be something like:

error[E0038]: the trait `AsyncFnOnce` cannot be made into an object
 --> src/main.rs:3:18
  |
3 | pub fn f(x: &dyn AsyncFnOnce()) {}
  |                  ^^^^^^^^^^^^^ `AsyncFnOnce` cannot be made into an object
  |
  = note: trait objects for async traits are not supported
  = help: consider using a concrete type or `impl AsyncFnOnce()` instead

This error would be more accurate because:

1. dyn Trait (trait objects) typically don't work well with traits that have associated types
2. Specifically, async traits and closures have complicated future return types that make them incompatible with dynamic dispatch via trait objects

From what I understand about Rust's async ecosystem, a more appropriate approach might be:

pub fn f<T: AsyncFnOnce()>(x: &T) {}

Or using the newer impl Trait syntax:

pub fn f(x: &impl AsyncFnOnce()) {}

The fundamental problem is that the compiler can't create a vtable for an async trait because each implementation could have a different future type, and trait objects need to know the exact layout of all methods at compile time.