Spurious type mismatches with function returning async closure returning a boxed trait object

[tim3z]

I tried this code:

type BoxedWork = Box<dyn Fn(u32) -> u32>;

// error[E0308]: mismatched types
fn make_work_builder() -> impl AsyncFn() -> BoxedWork {
    async || Box::new(move |x| x + 1)
}

// With a regular `Fn` all is fine.
fn make_sync_work_builder() -> impl Fn() -> BoxedWork {
    || Box::new(|x| x + 1)
}

// Wrapping the Box into a struct fixes it. WTF.
struct WrappedWork { work: BoxedWork }
fn make_wrapped_work_builder() -> impl AsyncFn() -> WrappedWork {
    async || WrappedWork { work: Box::new(|x| x + 1) }
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=b508bb1c161e3e4aedca432175026d5c

I expected to see this happen: It compiles.

Instead, this happened: The first function make_work_builder fails to compile with

error[E0308]: mismatched types
 --> src/lib.rs:5:14
  |
5 |     async || Box::new(move |x| x + 1)
  |              ^^^^^^^^^^^^^^^^^^^^^^^^ expected `dyn Fn`, found closure
  |
  = note: expected `async` closure body `{async closure body@src/lib.rs:5:14: 5:38}` (`dyn Fn`)
             found `async` closure body `{async closure body@src/lib.rs:5:14: 5:38}` (closure)
  = note: no two async blocks, even if identical, have the same type
  = help: consider pinning your async block and casting it to a trait object

This seems wrong, especially considering that the latter two examples compile just fine.

Meta

Reproduces on playground with current stable 1.89 but also in my local project with 1.88

rustc --version --verbose:

rustc 1.88.0 (6b00bc388 2025-06-23)
binary: rustc
commit-hash: 6b00bc3880198600130e1cf62b8f8a93494488cc
commit-date: 2025-06-23
host: aarch64-apple-darwin
release: 1.88.0
LLVM version: 20.1.5

[tim3z]

Simplified the example a bit further. Doesn't even need a boxed closure, Box<dyn SomeTrait> is sufficient.

trait Foo {}
struct Bar {}
impl Foo for Bar {}

type BoxedFoo = Box<dyn Foo>;

// error[E0308]: mismatched types
fn make_foo_builder() -> impl AsyncFn() -> BoxedFoo {
    async || Box::new(Bar {})
}

// error[E0599]: unsatisified trait bounds
fn make_foo_builder2() -> impl AsyncFn() -> BoxedFoo {
    async || Box::<dyn Foo>::new(Bar {})
}

// Explicitly specifying the type of an intermediate variable helps.
fn make_foo_builder_with_intermediate_var() -> impl AsyncFn() -> BoxedFoo {
    async || {
        let b: BoxedFoo = Box::new(Bar {});
        b
    }
}

// With a regular `Fn` all is fine.
fn make_sync_foo_builder() -> impl Fn() -> BoxedFoo {
    || Box::new(Bar {})
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=7a37ab06290bde63328a4e00b2d8e19a

[oatmealdealer]

I might be seeing the same issue, or something similar. The example that's failing for me is a bit more contrived, but here's a simplified representation of what I was trying to write:

pub struct Task<T, F> {
    t: T,
    f: F,
}

impl<T, F, Fut, O> Task<T, F>
where
    T: 'static + Send + Sync + Clone,
    F: 'static + Send + Sync + Fn(&T) -> Fut,
    Fut: 'static + Send + Future<Output = O>,
    O: 'static + Send,
{
    pub fn spawn(t: T, f: F) -> tokio::task::JoinHandle<O> {
        let task = Self { t, f };
        tokio::task::spawn(task.run())
    }
    async fn run(self) -> O {
        (self.f)(&self.t).await
    }
}

fn main() {
    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    rt.block_on(async {
        Task::spawn((), async |_| {});
    })
}

It's inconsistent whether I get the error from rust-analyzer as well, but if I do it's the same error as from rustc:

error[E0308]: mismatched types
  --> src/main.rs:28:9
   |
28 |         Task::spawn((), async |_| {});
   |         ^^^^^^^^^^^               --
   |         |                         |
   |         |                         the expected `async` closure body
   |         |                         the found `async` closure body
   |         one type is more general than the other
   |
   = note: expected `async` closure body `{async closure body@src/main.rs:28:35: 28:37}`
              found `async` closure body `{async closure body@src/main.rs:28:35: 28:37}`
   = note: no two async blocks, even if identical, have the same type
   = help: consider pinning your async block and casting it to a trait object

My rustc --version --verbose for reference as well (same commit-hash!):

rustc 1.88.0 (6b00bc388 2025-06-23)
binary: rustc
commit-hash: 6b00bc3880198600130e1cf62b8f8a93494488cc
commit-date: 2025-06-23
host: x86_64-unknown-linux-gnu
release: 1.88.0
LLVM version: 20.1.5