Using a closure in array repeat expr count causes "constant expression depends on a generic parameter" error

Using an (unevaluated) closure to size an array results in a "constant expression depends on a generic parameter" error inside async or generic functions. Assigning to a constant and then using the constant to size the array works:

pub const fn fn_size(_f: fn() -> ()) -> usize {
    0
}

// broken
fn generic1<T>() {
    let _ = [0u8; fn_size(|| ())];
}

// works
fn generic2<T>() {
    const N: usize = fn_size(|| ());
    let _ = [0u8; N];
}

This error happens inside generic functions, async functions and async blocks:

async fn asynchronous() {
    let _ = [0u8; fn_size(|| ())];
}

fn generic1<T>() {
    let _ = [0u8; fn_size(|| ())];
}

fn async_block() {
    async {
        let _ = [0u8; fn_size(|| ())];
    };
}

Both stable (1.93.1) and nightly are affected.

playground with a larger set of working and broken examples.

Reddit post

Start by reproducing the generic, async function, and async block examples from the issue, using the linked Rust Playground and comparing stable with nightly. Investigate the compiler path handling array repeat expression counts involving closures and generic parameters. Done means the reported examples compile without the constant workaround while existing working examples remain valid.