1.70.0: Type inference no longer works in conjunction with Glib's clone macro

[marhkb]

My code does not compile any more after updating to 1.70.0. The project can be found here

Code

I tried to create a minimal reproducer. It has something to do with glib's clone macro, which I use. Here is the reproducer that compiles fine on 1.69 but not on 1.70.0. I left some comments in the code describing what I observed so far. It needs glib and futures dependency):

use futures::Future;
use glib::clone;

fn main() {
    let obj = String::new();
    do_async(
        // just using `compound()` without `async` block works
        async { compound().await },
        clone!(@strong obj => move |info| if let Ok(info) = info {
            // removing this line makes the code compile
            println!("{:?}", info.t);
        }),
    );
}

struct Compound {
    t: i32
}

// Just returning a simple type like i32 makes the code compile
async fn compound() -> Result<Compound, ()> {
    Err(())
}

async fn do_async<R, Fut, F>(tokio_fut: Fut, glib_closure: F)
where
    R: Send + 'static,
    Fut: Future<Output = R> + Send + 'static,
    F: FnOnce(R) + 'static,
{
    glib_closure(tokio_fut.await);
}

Output

error[E0282]: type annotations needed for `Result<_, E>`
  --> src/main.rs:9:37
   |
9  |         clone!(@strong obj => move |info| if let Ok(info) = info {
   |                                     ^^^^
10 |             // removing this line makes the code compile
11 |             println!("{:?}", info.t);
   |                              ---- type must be known at this point
   |
help: consider giving this closure parameter an explicit type, where the placeholders `_` are specified
   |
9  |         clone!(@strong obj => move |info: Result<_, E>| if let Ok(info) = info {
   |                                         ++++++++++++++

For more information about this error, try `rustc --explain E0282`.

I expected to see this happen: The type info is correctly inferred

Instead, this happened: The compiler tells me that it doesn't know the type, although the type can be inferred

Version it worked on

It most recently worked on: 1.69.0

Version with regression

rustc --version --verbose:

rustc 1.70.0 (90c541806 2023-05-31)
binary: rustc
commit-hash: 90c541806f23a127002de5b4038be731ba1458ca
commit-date: 2023-05-31
host: x86_64-unknown-linux-gnu
release: 1.70.0
LLVM version: 16.0.2

[lukas-code]

regressed in #104833 cc @Swatinem

slightly minimized and removed dependencies: playground

use core::future::Future;

fn main() {
    do_async(
        async { (0,) },
        {
            // closure must be inside block
            |info| println!("{:?}", info.0)
        },
    );
}

fn do_async<R, Fut, F>(tokio_fut: Fut, glib_closure: F)
where
    Fut: Future<Output = R>,
    F: FnOnce(R),
{
}

Putting the identity function back (or wrapping the async block in a block) seems to "fix" the error:

    do_async(
-       async { (0,) },
+       core::convert::identity(async { (0,) }),
        {
            // closure must be inside block
            |info| println!("{:?}", info.0)
        },
    );

bisector output

searched nightlies: from nightly-2023-03-01 to nightly-2023-06-01
regressed nightly: nightly-2023-03-15
searched commit range: 22f247c...1716932
regressed commit: 669e751

bisected with cargo-bisect-rustc v0.6.6

Host triple: x86_64-unknown-linux-gnu
Reproduce with:

cargo bisect-rustc -- check 

@rustbot label -regression-untriaged +regression-from-stable-to-stable +A-inference +A-async-await

[Swatinem]

It is not only an identity function that makes this suddenly work, but putting the async block in a block works as well.
Permuting what to wrap in a block, only a single case out of the four fails:

// works:
    do_async(
        async { (0,) },
        |info| println!("{:?}", info.0),
    );

// works:
    do_async(
        {
            // async block in block
            async { (0,) }
        },
        |info| println!("{:?}", info.0),
    );

// works:
    do_async(
        {
            // both in block
            async { (0,) }
        },
        {
            // closure must be inside block
            |info| println!("{:?}", info.0)
        },
    );

// fails:
    do_async(
        async { (0,) },
        {
            // closure must be inside block
            |info| println!("{:?}", info.0)
        },
    );

Out of curiousity I tried the patch in #109338 thats supposed to fix #106527 to make async blocks "provide inference guidance", but that doesn’t work either.

[lukas-code]

This happens due to a hack in typeck, where function arguments that aren't closures, including block expressions that return closures, are typechecked before function parameters that are closures. Note that async blocks are desugared to closures.

rust/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

Lines 333 to 378 in 2f5e6bb

	// Check the arguments.
	// We do this in a pretty awful way: first we type-check any arguments
	// that are not closures, then we type-check the closures. This is so
	// that we have more information about the types of arguments when we
	// type-check the functions. This isn't really the right way to do this.
	for check_closures in [false, true] {
	// More awful hacks: before we check argument types, try to do
	// an "opportunistic" trait resolution of any trait bounds on
	// the call. This helps coercions.
	if check_closures {
	self.select_obligations_where_possible(|_| {})
	}
	// Check each argument, to satisfy the input it was provided for
	// Visually, we're traveling down the diagonal of the compatibility matrix
	for (idx, arg) in provided_args.iter().enumerate() {
	// Warn only for the first loop (the "no closures" one).
	// Closure arguments themselves can't be diverging, but
	// a previous argument can, e.g., `foo(panic!(), || {})`.
	if !check_closures {
	self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
	}
	// For C-variadic functions, we don't have a declared type for all of
	// the arguments hence we only do our usual type checking with
	// the arguments who's types we do know. However, we *can* check
	// for unreachable expressions (see above).
	// FIXME: unreachable warning current isn't emitted
	if idx >= minimum_input_count {
	continue;
	}
	let is_closure = matches!(arg.kind, ExprKind::Closure { .. });
	if is_closure != check_closures {
	continue;
	}
	let compatible = demand_compatible(idx);
	let is_compatible = matches!(compatible, Compatibility::Compatible);
	compatibility_diagonal[idx] = compatible;
	if !is_compatible {
	call_appears_satisfied = false;
	}
	}
	}

This basically means that closures and async blocks in function arguments behave as if they were ordered after all non-closure non-async-block arguments and you now get the same inference error that you would get on older compilers if you manually swapped the function arguments.

(Also, looks like this hack has existed forever.)

[Swatinem]

Wow, that is a very good catch! And also good news, as it means "fixing" the regression should be a oneliner, which I will try tomorrow.

However that does smell like a very gross hack, and I wonder if there will eventually be a better way altogether. But that is for a different day.

[lukas-code]

"fixing" the regression should be a oneliner

Note that just excluding desugared async block closures from this hack breaks inference for different programs that are now accepted on stable, for example:

fn main() {
    let x = Default::default();
    do_async(
        async { x.0; },
        { || { let _: &(i32,) = &x; } },
    );
}

fn do_async<Fut, T>(fut: Fut, val: T, ) {}

[Swatinem]

that are now accepted on stable

you mean which are only accepted as of 1.70?

[lukas-code]

Yeah, I mean stable 1.70. But I guess it's better to break a constructed program that compiled for one stable version instead of breaking a real codebase that compiled for several stable versions.

[compiler-errors]

@Swatinem @lukas-code: I'd be fine landing a PR that excludes future-desugared async blocks from this hack.