compilation does not terminate using async closures

[nikomatsakis]

The following code:

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=efa07d177105d0c3aecf5bc64a9bf8b3

use std::ops::AsyncFnMut;
use std::pin::Pin;

trait Db {}

impl Db for () { }

struct Env<'db> {
    db: &'db ()
}

#[derive(Debug)]
enum SymPerm<'db> {
    Dummy(&'db ()),
    Apply(Box<SymPerm<'db>>, Box<SymPerm<'db>>)
}

pub struct ToChain<'env, 'db> {
    db: &'db dyn crate::Db,
    env: &'env Env<'db>,
}

impl<'env, 'db> ToChain<'env, 'db> {
    fn perm_pairs<'l>(
        &'l self,
        perm: &'l SymPerm<'db>,
        yield_chain: &'l mut impl AsyncFnMut(&SymPerm<'db>),
    ) -> Pin<Box<dyn std::future::Future<Output = ()> + 'l>> {
        Box::pin(async move {
            match perm {
                SymPerm::Dummy(_) => {
                    yield_chain(perm).await
                }
                SymPerm::Apply(l, r) => {
                    self.perm_pairs(l, &mut async |left_pair| {
                        self.perm_pairs(r, yield_chain)
                            .await
                    })
                    .await
                }
            }
        })
    }
}

#[tokio::main]
async fn main() {
    let pair = SymPerm::Apply(
        Box::new(SymPerm::Dummy(&())),
        Box::new(SymPerm::Dummy(&()))
    );
    ToChain { db: &(), env: &Env { db: &() } }.perm_pairs(
        &pair,
        &mut async |p| {
            eprintln!("{p:?}");
        }
    ).await;
}

causes compilation to enter into an infinite loop. This was reduced from my dada project (run cargo build on the tip of this branch).

Many many thanks to @lqd for helping me minimize this.

cc @compiler-errors @rust-lang/types

[nikomatsakis]

Reproducing the hang requires a true cargo build, at least it does on the dada version.

[lqd]

Random notes along the way to finding the source+offending closure:

• confirm_async_closure_candidate here had some seemingly exponential behavior here.

FoldEscapingRegions done, in 5.39µs
...
FoldEscapingRegions done, in 4.302674ms
FoldEscapingRegions done, in 4.326781ms
...
FoldEscapingRegions done, in 1.102144628s
FoldEscapingRegions done, in 1.070276436s
FoldEscapingRegions done, in 4.392306293s
FoldEscapingRegions done, in 4.283039861s
FoldEscapingRegions done, in 17.604121163s
FoldEscapingRegions done, in 16.950846174s

• when minimizing and playing around, there are often reached the recursion limit while instantiating errors for the async closure instead of the hang.

I'll try to minimize this a bit more later today, while errs enjoys his well-deserved holiday ^^.

[compiler-errors]

This looks like a monomorphization overflow. I expect it to result in a build error, but obviously not a hang.

[lqd]

use std::ops::AsyncFn;

fn recur(closure: &impl AsyncFn()) {
    let _ = closure();
    if false {
        recur(&async || {
            let _ = closure();
        });
    }
}

fn main() {
    let closure = async || {};
    let _ = recur(&closure);
}

[Christiantyemele]

@rustbot claim