Potentially valid code doesn't compile - a silly error message

[vporton]

I tried this code:

use std::cell::RefCell;

thread_local! {
    static REQUESTS_CHECKER: RefCell<()> = RefCell::new(());
}

async fn a() {}

async fn b() {
    REQUESTS_CHECKER.with_borrow_mut(async |c|
        a().await
    ).await
}

fn main() {}

I expected to see this happen: the code to compile.

Instead, this happened:

mismatched types
expected `async` closure body `{async closure body@canister/src/lib.rs:27:9: 35:16}`
   found `async` closure body `{async closure body@canister/src/lib.rs:27:9: 35:16}`
no two async blocks, even if identical, have the same type
consider pinning your async block and casting it to a trait object

This is not two async blocks, it is one.

Meta

rustc --version --verbose:

rustc 1.90.0 (1159e78c4 2025-09-14)

Backtrace

<backtrace>

Real code: this.

[Kivooeo]

I'm not sure, do with_borrow_mut works with async closures?

@rustbot label -C-bug

[FrancescoV1985]

Hello @vporton, @Kivooeo.
It appears to me that the implementation of ""with_borrow_mut" requires the closure to be synchronous, looking at "with_borrow_mut" definition:

pub fn with_borrow_mut<F, R>(&'static self, f: F) -> R where F: FnOnce(&mut T) -> R, { self.with(|cell| f(&mut cell.borrow_mut())) }

This is due to the lines:

1. F: FnOnce(&mut T) -> R
2. cell| f(&mut cell.borrow_mut())) which is more or less equivalent to:
   "let temporary = cell.borrow_mut(); // type: RefMut<'tmp, T>
   let ptr: &mut T = &mut *temporary; // re-borrow with lifetime 'tmp
   f(ptr) // ===> user closure runs here
   drop(temporary); // borrow counter cleared here"

From the documentation of "borrow_mut()": pub const fn borrow_mut(&self) -> RefMut<'_, T>>
"The borrow lasts until the returned RefMut or all RefMuts derived from it exit scope."

Async input capture
"Async closures always capture all input arguments, regardless of whether or not they are used within the body."

An async closure would capture the input arguments — the
"&mut T " above —inside the future object it returns. That would make the reference
live until the future is dropped, after the RefMut has already been
dropped and the borrow counter has been cleared.

I hope this helps. Anyway someone else should confirm my view :)....
Best Regards