Support move expressions in coroutine closures by TaKO8Ki · Pull Request #157738 · rust-lang/rust

TaKO8Ki · 2026-06-11T04:15:39Z

View all comments

This adds move(expr) support for coroutine closures.

Support for move expressions in coroutine closures
Support for move expressions in async blocks

RFC: rust-lang/rfcs#3968
Tracking issue: #155050
Project goal:

I used AI to write the tests and reviewed them myself.

r? @nikomatsakis

rustbot · 2026-06-11T04:15:43Z

Some changes occurred to MIR optimizations

cc @rust-lang/wg-mir-opt

rustbot · 2026-06-11T04:15:46Z

nikomatsakis is currently at their maximum review capacity.
They may take a while to respond.

nikomatsakis

Hmm. Something seems off here. I think we need more tests around nested-move and async blocks, async closures, and gen blocks. For example I'd expect:

let c: Arc<String> = Default::default();
let future = async {
    let f = async {
        move(c.clone());
    };
    assert!( /* c ref count is 2 */ );
    f.await;
    assert!( /* c ref count is 1 */ );
    drop(c);
};

let c: Arc<String> = Default::default();
let future = async {
    let f = async {
        move(c.clone());
    };
    f.await;
    drop(c);
};
println!("{c}"); // <-- ERROR: c is moved

let c: Arc<String> = Default::default();
let future = async {
    let f = async {
        move(move(c.clone()));
    };
    assert!( /* c ref count is 3 */ );
    f.await;
    assert!( /* c ref count is 2 */ );
    drop(c);
};
println!("{c}"); // OK, prints ""

View changes since this review

nikomatsakis

The behavior around async closures still seems off to me

View changes since this review

nikomatsakis · 2026-08-13T12:56:47Z

@@ -0,0 +1,77 @@
+//@ edition: 2021


✅ These match my expectations.

nikomatsakis · 2026-08-13T12:59:13Z

+        });
+        n
    };
+    assert_eq!(created.get(), 0);


❌ But this does not. I expected the move to execute when the closure was created. In other words, I expect these to be equivalent

let created = Cell::new(0); let c = || { let n = move({ created.set(created.get() + 1); created.get() }); n }; assert_eq!(created.get(), 1); assert_eq!(c(), 1); assert_eq!(c(), 1); assert_eq!(created.get(), 1);

and

let created = Cell::new(0); let c = async || { let n = move({ created.set(created.get() + 1); created.get() }); n }; assert_eq!(created.get(), 1); assert_eq!(c().await, 1); assert_eq!(c().await, 1); assert_eq!(created.get(), 1);

I think we are leaking the "desugaring" of async closures here somehow.

I fixed this in d9885df.

nikomatsakis · 2026-08-13T12:59:51Z

+        yield n;
+        yield n + 1;
+    });
+    assert_eq!(created.get(), 1);


✅ This matches my expectations

nikomatsakis · 2026-08-13T13:00:08Z

+        PendingOnce::new().await;
+        yield Arc::strong_count(&value);
+    });
+    assert_eq!(Arc::strong_count(&x), 2);


✅ As does this

nikomatsakis · 2026-08-13T13:00:23Z

+        });
+        yield ready_next(inner.as_mut()).unwrap();
+    });
+    assert_eq!(weak.strong_count(), 2);


✅ As does this

nikomatsakis · 2026-08-13T13:00:43Z

+        };
+        yield inner.next().unwrap();
+    };
+    assert_eq!(weak.strong_count(), 2);


✅ As does this

nikomatsakis · 2026-08-13T13:01:08Z

+
+fn main() {
+    let _ = || move(move(0));
+    //~^ ERROR nested `move(expr)` requires another enclosing closure


✅ These errors match my expectations

nikomatsakis · 2026-08-13T13:02:25Z

+        let value = move(z.clone());
+        yield Arc::strong_count(&value);
+    };
+    assert_eq!(Arc::strong_count(&z), 2);


✅ As does this

nikomatsakis · 2026-08-13T13:02:55Z

+        f.await;
+        drop(c);
+    };
+    println!("{c}"); //~ ERROR the type `Arc` does not implement `Copy`


✅ As does this

nikomatsakis · 2026-08-13T13:03:30Z

+    let inner = outer();
+    assert_eq!(Arc::strong_count(&v), 2);
+    assert_eq!(inner(), v.len());
+    assert_eq!(Arc::strong_count(&v), 1);


✅ Interesting example

nikomatsakis

Tests look good.

View changes since this review

nikomatsakis · 2026-09-08T15:39:01Z

+    assert_eq!(created.get(), 1);
+    assert_eq!(closure().next(), Some(1));
+    assert_eq!(closure().next(), Some(1));
+    assert_eq!(created.get(), 1);


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:39:19Z

+    let closure = iter! { || {
+        yield move(x.clone());
+    }};
+    assert_eq!(Arc::strong_count(&x), 2);


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:39:24Z

+    }};
+    assert_eq!(Arc::strong_count(&x), 2);
+    let mut generator = closure();
+    assert_eq!(Arc::strong_count(&x), 2);


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:40:27Z

+    assert_eq!(Arc::strong_count(&x), 2);
+    assert_eq!(generator.next(), None);
+    drop(yielded);
+    assert_eq!(Arc::strong_count(&x), 1);


❓ Huh, am I missing something here--- we didn't drop x nor did we drop the closure -- oh, perhaps it is a FnOnce?

nikomatsakis · 2026-09-08T15:40:58Z

+        let moved = move(a.clone());
+        yield (moved, b.len());
+    }};
+    assert_eq!(closure().next(), Some((String::from("a"), 3)));


✅ This makes sense.

nikomatsakis · 2026-09-08T15:44:43Z

+    assert_eq!(created.get(), 1);
+
+    let x = Arc::new(String::from("hello"));
+    assert_eq!(Arc::strong_count(&x), 1);


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:44:54Z

+    assert_eq!(Arc::strong_count(&x), 1);
+
+    let c = async || move(x.clone());
+    assert_eq!(Arc::strong_count(&x), 2);


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:45:01Z

+    let c = async || move(x.clone());
+    assert_eq!(Arc::strong_count(&x), 2);
+    let fut = c();
+    assert_eq!(Arc::strong_count(&x), 2);


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:45:08Z

+    let fut = c();
+    assert_eq!(Arc::strong_count(&x), 2);
+    drop(fut);
+    assert_eq!(Arc::strong_count(&x), 1);


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:45:37Z

+        let moved = move(a.clone());
+        (moved, b.len())
    };
+    assert_eq!(block_on(call_once(c)), (String::from("a"), 3));


✅ This matches expectations.

nikomatsakis · 2026-09-08T15:46:58Z

@TaKO8Ki r=me after rebased

rustbot · 2026-09-08T17:23:49Z

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

TaKO8Ki · 2026-09-08T18:48:48Z

@bors r=nikomatsakis rollup=iffy

rust-bors · 2026-09-08T18:48:51Z

📌 Commit 2ed8d0d has been approved by nikomatsakis

It is now in the queue for this repository.

@nikomatsakis

…es, r=nikomatsakis Support move expressions in coroutine closures This adds `move(expr)` support for coroutine closures. - [x] Support for move expressions in coroutine closures - [x] Support for move expressions in async blocks RFC: rust-lang/rfcs#3968 Tracking issue: rust-lang#155050 Project goal: - rust-lang/goals#107 - https://rust-lang.github.io/rust-project-goals/2026/ergonomic-rc.html I used AI to write the tests and reviewed them myself. r? @nikomatsakis

…uwer Rollup of 9 pull requests Successful merges: - #157738 (Support move expressions in coroutine closures) - #160219 (Implement `Thread::os_id`) - #162449 (Prefer removing a redundant shared reference over reborrow) - #162494 (Ignore `self-in-const-generics` test for parallel frontend) - #162495 (Reserve items in `Extend` implementations) - #162238 (trait solver: Include implied outlives assumptions) - #162473 (Small `x perf` improvements) - #162489 (Clean up on upvar_tys) - #162500 (Move the `expect-item-after-attribute.rs` test to the correct directory)

@nikomatsakis

Rollup merge of #157738 - TaKO8Ki:move-expr-coroutine-closures, r=nikomatsakis Support move expressions in coroutine closures This adds `move(expr)` support for coroutine closures. - [x] Support for move expressions in coroutine closures - [x] Support for move expressions in async blocks RFC: rust-lang/rfcs#3968 Tracking issue: #155050 Project goal: - rust-lang/goals#107 - https://rust-lang.github.io/rust-project-goals/2026/ergonomic-rc.html I used AI to write the tests and reviewed them myself. r? @nikomatsakis

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Jun 11, 2026

rustbot assigned nikomatsakis Jun 11, 2026

TaKO8Ki mentioned this pull request Jun 11, 2026

Tracking Issue for move expressions (move(expr)) #155050

Open

14 tasks

TaKO8Ki force-pushed the move-expr-coroutine-closures branch from b119411 to 219db1c Compare June 22, 2026 17:35