Don't manually resolve async closures in `rustc_resolve` #120322

compiler-errors · 2024-01-24T20:50:43Z

There's a comment here that talks about doing this "[so] closure [args] are detected as upvars rather than normal closure arg usages", but we do upvar analysis on the HIR now:

rust/compiler/rustc_passes/src/upvars.rs

Lines 21 to 29 in cd6d8f2

    
           let mut local_collector = LocalCollector::default(); 
        
           local_collector.visit_body(body); 
        
           let mut capture_collector = CaptureCollector { 
        
               tcx, 
        
               locals: &local_collector.locals, 
        
               upvars: FxIndexMap::default(), 
        
           }; 
        
           capture_collector.visit_body(body);

Removing this ad-hoc logic makes it so that async |x: &str| now introduces an implicit binder, like regular closures.

r? @oli-obk

compiler-errors · 2024-01-24T20:52:07Z

compiler/rustc_resolve/src/late.rs

-                        // No need to resolve return type --
-                        // the outer closure return type is `FnRetTy::Default`.
-
-                        // Now resolve the inner closure


In any case, this code was literally not doing anything at all special for the inner async block. It's not introducing an inner ribs or anything, lol.

oli-obk · 2024-01-25T13:03:10Z

lol nice

@bors r+ rollup

bors · 2024-01-25T13:03:13Z

📌 Commit 8c2ae80 has been approved by oli-obk

It is now in the queue for this repository.

…c-closures, r=oli-obk Don't manually resolve async closures in `rustc_resolve` There's a comment here that talks about doing this "[so] closure [args] are detected as upvars rather than normal closure arg usages", but we do upvar analysis on the HIR now: https://github.com/rust-lang/rust/blob/cd6d8f2a04528f827ad3d399581c0f3502b15a72/compiler/rustc_passes/src/upvars.rs#L21-L29 Removing this ad-hoc logic makes it so that `async |x: &str|` now introduces an implicit binder, like regular closures. r? `@oli-obk`

…mpiler-errors Rollup of 8 pull requests Successful merges: - rust-lang#118803 (Add the `min_exhaustive_patterns` feature gate) - rust-lang#119286 (show linker output even if the linker succeeds) - rust-lang#119616 (Add a new `wasm32-wasi-preview2` target) - rust-lang#120124 (Split assembly tests for ELF and MachO) - rust-lang#120201 (Bump some deps with syn 1.0 dependencies) - rust-lang#120204 (Builtin macros effectively have implicit #[collapse_debuginfo(yes)]) - rust-lang#120322 (Don't manually resolve async closures in `rustc_resolve`) - rust-lang#120356 (Fix broken markdown in csky-unknown-linux-gnuabiv2.md) r? `@ghost` `@rustbot` modify labels: rollup

…c-closures, r=oli-obk Don't manually resolve async closures in `rustc_resolve` There's a comment here that talks about doing this "[so] closure [args] are detected as upvars rather than normal closure arg usages", but we do upvar analysis on the HIR now: https://github.com/rust-lang/rust/blob/cd6d8f2a04528f827ad3d399581c0f3502b15a72/compiler/rustc_passes/src/upvars.rs#L21-L29 Removing this ad-hoc logic makes it so that `async |x: &str|` now introduces an implicit binder, like regular closures. r? ``@oli-obk``

…iaskrgr Rollup of 8 pull requests Successful merges: - rust-lang#107464 (Add `str::Lines::remainder`) - rust-lang#118803 (Add the `min_exhaustive_patterns` feature gate) - rust-lang#119466 (Initial implementation of `str::from_raw_parts[_mut]`) - rust-lang#120053 (Specialize `Bytes` on `StdinLock<'_>`) - rust-lang#120124 (Split assembly tests for ELF and MachO) - rust-lang#120204 (Builtin macros effectively have implicit #[collapse_debuginfo(yes)]) - rust-lang#120322 (Don't manually resolve async closures in `rustc_resolve`) - rust-lang#120356 (Fix broken markdown in csky-unknown-linux-gnuabiv2.md) r? `@ghost` `@rustbot` modify labels: rollup

Rollup merge of rust-lang#120322 - compiler-errors:higher-ranked-async-closures, r=oli-obk Don't manually resolve async closures in `rustc_resolve` There's a comment here that talks about doing this "[so] closure [args] are detected as upvars rather than normal closure arg usages", but we do upvar analysis on the HIR now: https://github.com/rust-lang/rust/blob/cd6d8f2a04528f827ad3d399581c0f3502b15a72/compiler/rustc_passes/src/upvars.rs#L21-L29 Removing this ad-hoc logic makes it so that `async |x: &str|` now introduces an implicit binder, like regular closures. r? ```@oli-obk```

Rework support for async closures; allow them to return futures that borrow from the closure's captures This PR implements a new lowering for async closures via `TyKind::CoroutineClosure` which handles the curious relationship between the closure and the coroutine that it returns. I wrote up a bunch in [this hackmd](https://hackmd.io/`@compiler-errors/S1HvqQxca)` which will be copied to the dev guide after this PR lands, and hopefully left sufficient comments in the source code explaining why this change is as large as it is. This also necessitates that they begin implementing the `AsyncFn`-family of traits, rather than the `Fn`-family of traits -- if you need `Fn` implementations, you should probably use the non-sugar `|| async {}` syntax instead. Notably this PR does not yet implement `async Fn()` syntax sugar for bounds, but I expect to add those soon (**edit:** rust-lang#120392). For now, users must use `AsyncFn()` traits directly, which necessitates adding the `async_fn_traits` feature gate as well. I will add this as a follow-up very soon. r? oli-obk This is based on top of rust-lang#120322, but that PR is minimal.

…i-obk Rework support for async closures; allow them to return futures that borrow from the closure's captures This PR implements a new lowering for async closures via `TyKind::CoroutineClosure` which handles the curious relationship between the closure and the coroutine that it returns. I wrote up a bunch in [this hackmd](https://hackmd.io/`@compiler-errors/S1HvqQxca)` which will be copied to the dev guide after this PR lands, and hopefully left sufficient comments in the source code explaining why this change is as large as it is. This also necessitates that they begin implementing the `AsyncFn`-family of traits, rather than the `Fn`-family of traits -- if you need `Fn` implementations, you should probably use the non-sugar `|| async {}` syntax instead. Notably this PR does not yet implement `async Fn()` syntax sugar for bounds, but I expect to add those soon (**edit:** rust-lang#120392). For now, users must use `AsyncFn()` traits directly, which necessitates adding the `async_fn_traits` feature gate as well. I will add this as a follow-up very soon. r? oli-obk This is based on top of rust-lang#120322, but that PR is minimal.

Don't manually resolve async closures in rustc_resolve

8c2ae80

rustbot assigned oli-obk Jan 24, 2024

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 Jan 24, 2024

compiler-errors commented Jan 24, 2024

View reviewed changes

bors added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Jan 25, 2024

This was referenced Jan 26, 2024

Rollup of 8 pull requests #120359

Closed

Rework support for async closures; allow them to return futures that borrow from the closure's captures #120361

Merged

This was referenced Jan 26, 2024

Rollup of 9 pull requests #120364

Closed

Rollup of 8 pull requests #120365

Merged

bors merged commit e400311 into rust-lang:master Jan 26, 2024
11 checks passed

rustbot added this to the 1.77.0 milestone Jan 26, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Don't manually resolve async closures in `rustc_resolve` #120322

Don't manually resolve async closures in `rustc_resolve` #120322

compiler-errors commented Jan 24, 2024 •

edited

Loading

compiler-errors Jan 24, 2024 •

edited

Loading

oli-obk commented Jan 25, 2024

bors commented Jan 25, 2024

	let mut local_collector = LocalCollector::default();
	local_collector.visit_body(body);

	let mut capture_collector = CaptureCollector {
	tcx,
	locals: &local_collector.locals,
	upvars: FxIndexMap::default(),
	};
	capture_collector.visit_body(body);

Don't manually resolve async closures in rustc_resolve #120322

Don't manually resolve async closures in rustc_resolve #120322

Conversation

compiler-errors commented Jan 24, 2024 • edited Loading

compiler-errors Jan 24, 2024 • edited Loading

Choose a reason for hiding this comment

oli-obk commented Jan 25, 2024

bors commented Jan 25, 2024

Don't manually resolve async closures in `rustc_resolve` #120322

Don't manually resolve async closures in `rustc_resolve` #120322

compiler-errors commented Jan 24, 2024 •

edited

Loading

compiler-errors Jan 24, 2024 •

edited

Loading