`thirtyfour` non-`Send` witness regression

[lcnr]

cargo download thirtyfour@0.33.0-alpha.2
cd thirtyfour-0.33.0-alpha.2
RUSTFLAGS=-Znext-solver cargo +nightly b

results in 16 similar errors

error[E0277]: `{coroutine witness@src/extensions/query/element_query.rs:460:43: 505:6}` cannot be sent between threads safely
   --> src/components/wrapper/resolver.rs:366:9
    |
361 |             async move {
    |             ---------- within this `{async block@src/components/wrapper/resolver.rs:361:13: 361:23}`
...
366 |         Self::new_custom(base_element, resolver)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `{coroutine witness@src/extensions/query/element_query.rs:460:43: 505:6}` cannot be sent between threads safely
    |
...

this error is surprising. By testing with cargo rustc -- -Ztreat-err-as-bug the ICE does happen in query check_coroutine_obligations as it should. We apparently actually do a witness which previously implemented Send but no longer does so.

Would be good to minimize this issue to figure out what exactly is going wrong.

[Threated]

Spend some time minimizing:

trait AsyncFn: Send + 'static {
    type Fut: Future<Output = ()> + Send;

    fn call(&self) -> Self::Fut;
}

fn filter<I, P>(filters: I) -> impl Future<Output = ()>
where
    I: IntoIterator<Item = Box<P>>,
    P: AsyncFn + ?Sized,
{
    async move {
        let func = filters.into_iter().next().unwrap();
        func.call().await;
    }
}

async fn calls_it() {
    let filters: Vec<Box<dyn AsyncFn<Fut = BoxFuture<'static, ()>>>> = Vec::new();
    filter(filters).await;
}

fn observe_fut_not_send() {
    assert_send(calls_it());
}

fn assert_send<T: Send>(t: T) -> T {
    t
}

pub type BoxFuture<'a, T> = std::pin::Pin<Box<dyn Future<Output = T> + Send + 'a>>;

Things I found:

1. Either removing the 'static super trait bound on AsyncFn or adding a Send bound to the RPIT of filter and I: Send make the error go away.
2. With the following changes this code fails to compile in the old solver and ICEs in the new solver:

fn filter2<P>(filter: &P) -> impl Future<Output = ()>
where
    P: AsyncFn + ?Sized,
{
    async move {
        filter.call().await;
    }
}


async fn calls_it() {
    let filters: Vec<Box<dyn AsyncFn<Fut = BoxFuture<'static, ()>>>> = Vec::new();
    filter2(filters.first().unwrap().as_ref()).await;
}

3. While minimizing this I also found another ICE but that may be related to 2. maybe I will look into it some other time.

[Threated]

Simpler version of 1:

trait AsyncFn: Send + 'static {
    type Fut: Future<Output = ()> + Send;

    fn call(&self) -> Self::Fut;
}

type BoxFuture<'a, T> = std::pin::Pin<Box<dyn Future<Output = T> + Send + 'a>>;
type DynAsyncFnBoxed = dyn AsyncFn<Fut = BoxFuture<'static, ()>>;

fn wrap_call<P: AsyncFn + ?Sized>(func: Box<P>) -> impl Future<Output = ()> {
    func.call()
}

fn get_boxed_fn() -> Box<DynAsyncFnBoxed> {
    todo!()
}

async fn cursed_fut() {
    wrap_call(get_boxed_fn()).await;
}

fn observe_fut_not_send() {
    fn assert_send<T: Send>(t: T) -> T {
        t
    }
    assert_send(cursed_fut());
}

[Threated]

This is the ice I was talking about in 3:

trait AsyncFn: Send + Sync + 'static {
    type Fut: Future<Output = ()> + Send + 'static;

    fn call(&self) -> Self::Fut;
}

impl<Fut, Fun> AsyncFn for Fun
where
    Fun: Fn() -> Fut + Send + Sync + 'static,
    Fut: Future<Output = ()> + Send + 'static,
{
    type Fut = Fut;

    fn call(&self) -> Fut {
        self()
    }
}

type BoxFuture<'a, T> = std::pin::Pin<Box<dyn Future<Output = T> + Send + 'a>>;
type DynAsyncFnBoxed = dyn AsyncFn<Fut = BoxFuture<'static, ()>>;

fn wrap_call<P>(func: Box<P>) -> impl Future<Output = ()> + Send
where
    P: AsyncFn + ?Sized,
{
    func.call()
}

fn get_boxed_fn() -> Box<DynAsyncFnBoxed> {
    todo!()
}

async fn cursed_fut() {
    wrap_call(get_boxed_fn()).await;
}

pub fn triger_ice() {
    fn takes_resolver<F: AsyncFn>(r: F) {
        Box::new(move || Box::pin(r.call()) as BoxFuture<'static, ()>) as Box<DynAsyncFnBoxed>;
    }
    takes_resolver(|| cursed_fut());
}

The trait bounds are slightly different than in the example above to make it work. The main difference is the added Send bound of the RPIT of wrap_call. The older solver compiles this with or without the bound while the new one rejects to compile without it and ICEs with it.

[Threated]

Also here is a minimal version of 2 which fails to compile in the old solver and ICEs in the new one:

trait AsyncFn: Send + 'static {
    type Fut: Future<Output = ()> + Send;

    fn call(&self) -> Self::Fut;
}

async fn wrap_call<P: AsyncFn + ?Sized>(filter: &P) {
    filter.call().await;
}

fn get_boxed_fn() -> Box<DynAsyncFnBoxed> {
    todo!()
}

async fn cursed_fut() {
    wrap_call(get_boxed_fn().as_ref()).await;
}

fn observe_fut_not_send() {
    assert_send(cursed_fut());
}

fn assert_send<T: Send>(t: T) -> T {
    t
}

pub type BoxFuture<'a, T> = std::pin::Pin<Box<dyn Future<Output = T> + Send + 'a>>;
type DynAsyncFnBoxed = dyn AsyncFn<Fut = BoxFuture<'static, ()>>;

The ICE error message seems different from the one in 3 but the root cause is probably the same cursed future.

I hope this helps 🙈

[lcnr]

Thanks a lot ❤️ I still need to take the time to look into this issue and while I would be happy for someone else to figure this out, it seems challenging. Assume this happens because the new solver introduces an outlives constraint which isn't there in the old solver