Strange inference failure with Arc::new_cyclic

[Sky9x]

I tried this code (playground):

#![allow(unused)]

use std::sync::Arc;
use tokio_util::task::AbortOnDropHandle;

pub struct Foo {
    thing: Thing,
    task: AbortOnDropHandle<()>,
}

impl Foo {
    pub fn new() -> Arc<Self> {
        // Fix 1: replace `<_>` with `<Self>`
        Arc::<_>::new_cyclic(|weak| {
            let weak = weak.clone();
            let handler = async move {
                async { /* ... */ }.await; // waiting for some event

                if let Some(this) = weak.upgrade() {
                    // "Fix" 2: comment out this line
                    this.thing.do_thing();
                }
            };

            Foo {
                thing: Thing,
                task: AbortOnDropHandle::new(tokio::spawn(handler)),
            }
        })
    }
}

struct Thing;

impl Thing {
    fn do_thing() { unimplemented!() }
}

I expected to see this happen: It compiles

Instead, this happened: It does not compile

I find it very strange the type inference is unable to figure out that
a. new_cyclic returns an Arc<Self>
b. the closure returns a Foo

I find it even stranger that commenting out the line where the inner value is used ("Fix" 2) makes it compile.

Compiler Error:

   Compiling playground v0.0.1 (/playground)
error[E0282]: type annotations needed for `&std::sync::Weak<_>`
  --> src/lib.rs:14:31
   |
14 |         Arc::<_>::new_cyclic(|weak| {
   |                               ^^^^
...
21 |                     this.thing.do_thing();
   |                     ---------- type must be known at this point
   |
help: consider giving this closure parameter an explicit type, where the type for type parameter `T` is specified
   |
14 |         Arc::<_>::new_cyclic(|weak: &std::sync::Weak<T>| {
   |                                   +++++++++++++++++++++

error[E0609]: no field `thing` on type `Arc<_>`
  --> src/lib.rs:21:26
   |
21 |                     this.thing.do_thing();
   |                          ^^^^^ unknown field

Some errors have detailed explanations: E0282, E0609.
For more information about an error, try `rustc --explain E0282`.
error: could not compile `playground` (lib) due to 2 previous errors

rustc version:

rustc 1.88.0-nightly (9ffde4b08 2025-04-12)
binary: rustc
commit-hash: 9ffde4b089fe8e43d5891eb517001df27a8443ff
commit-date: 2025-04-12
host: x86_64-unknown-linux-gnu
release: 1.88.0-nightly
LLVM version: 20.1.2

[compiler-errors]

I find it very strange the type inference is unable to figure out [...]

We check the type of the closure before unifying the return type with the value of the expression. So by the time we're type checking the closure, we know nothing about the pointee type of the argument weak: &Weak<_> in the closure.

By the time we do the field access this.thing we need to know the type of this. This is typically the source of E0282 errors, which stem from the order dependence of inference in Rust's type system.

Notably, this happens before we've checked the return type of the closure either, so we still haven't constrained the type of the pointee of the Arc.

I find it even stranger that commenting out the line where the inner value is used ("Fix" 2) makes it compile.

This removes the requirement that we know a values' type eagerly.

---

All that above was just me explaining why this is an error today; I don't believe this is possible to fix, at least not soon, though.

As a side note, #139423 will fix this erroneous extra error:

error[E0609]: no field `thing` on type `Arc<_>`
  --> src/lib.rs:21:26
   |
21 |                     this.thing.do_thing();
   |                          ^^^^^ unknown field

It's not yet present on the nightly toolchain on playground, tho.

[Sky9x]

Interesting. Thanks for the explanation.